blob: 67aa0dd68250a8ca330bc8f3005a9e924d79ff8d [file] [log] [blame]
Dave Airlief453ba02008-11-07 14:05:41 -08001/*
2 * Copyright (c) 2006 Luc Verhaegen (quirks list)
3 * Copyright (c) 2007-2008 Intel Corporation
4 * Jesse Barnes <jesse.barnes@intel.com>
Adam Jackson61e57a82010-03-29 21:43:18 +00005 * Copyright 2010 Red Hat, Inc.
Dave Airlief453ba02008-11-07 14:05:41 -08006 *
7 * DDC probing routines (drm_ddc_read & drm_do_probe_ddc_edid) originally from
8 * FB layer.
9 * Copyright (C) 2006 Dennis Munsie <dmunsie@cecropia.com>
10 *
11 * Permission is hereby granted, free of charge, to any person obtaining a
12 * copy of this software and associated documentation files (the "Software"),
13 * to deal in the Software without restriction, including without limitation
14 * the rights to use, copy, modify, merge, publish, distribute, sub license,
15 * and/or sell copies of the Software, and to permit persons to whom the
16 * Software is furnished to do so, subject to the following conditions:
17 *
18 * The above copyright notice and this permission notice (including the
19 * next paragraph) shall be included in all copies or substantial portions
20 * of the Software.
21 *
22 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
23 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
24 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
25 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
26 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
27 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
28 * DEALINGS IN THE SOFTWARE.
29 */
30#include <linux/kernel.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090031#include <linux/slab.h>
Dave Airlief453ba02008-11-07 14:05:41 -080032#include <linux/i2c.h>
Adam Jackson47819ba2012-05-30 16:42:39 -040033#include <linux/module.h>
David Howells760285e2012-10-02 18:01:07 +010034#include <drm/drmP.h>
35#include <drm/drm_edid.h>
Adam Jackson38fcbb62010-08-03 14:38:20 -040036#include "drm_edid_modes.h"
Dave Airlief453ba02008-11-07 14:05:41 -080037
Adam Jackson13931572010-08-03 14:38:19 -040038#define version_greater(edid, maj, min) \
39 (((edid)->version > (maj)) || \
40 ((edid)->version == (maj) && (edid)->revision > (min)))
Dave Airlief453ba02008-11-07 14:05:41 -080041
Adam Jacksond1ff6402010-03-29 21:43:26 +000042#define EDID_EST_TIMINGS 16
43#define EDID_STD_TIMINGS 8
44#define EDID_DETAILED_TIMINGS 4
Dave Airlief453ba02008-11-07 14:05:41 -080045
46/*
47 * EDID blocks out in the wild have a variety of bugs, try to collect
48 * them here (note that userspace may work around broken monitors first,
49 * but fixes should make their way here so that the kernel "just works"
50 * on as many displays as possible).
51 */
52
53/* First detailed mode wrong, use largest 60Hz mode */
54#define EDID_QUIRK_PREFER_LARGE_60 (1 << 0)
55/* Reported 135MHz pixel clock is too high, needs adjustment */
56#define EDID_QUIRK_135_CLOCK_TOO_HIGH (1 << 1)
57/* Prefer the largest mode at 75 Hz */
58#define EDID_QUIRK_PREFER_LARGE_75 (1 << 2)
59/* Detail timing is in cm not mm */
60#define EDID_QUIRK_DETAILED_IN_CM (1 << 3)
61/* Detailed timing descriptors have bogus size values, so just take the
62 * maximum size and use that.
63 */
64#define EDID_QUIRK_DETAILED_USE_MAXIMUM_SIZE (1 << 4)
65/* Monitor forgot to set the first detailed is preferred bit. */
66#define EDID_QUIRK_FIRST_DETAILED_PREFERRED (1 << 5)
67/* use +hsync +vsync for detailed mode */
68#define EDID_QUIRK_DETAILED_SYNC_PP (1 << 6)
Adam Jacksonbc42aab2012-05-23 16:26:54 -040069/* Force reduced-blanking timings for detailed modes */
70#define EDID_QUIRK_FORCE_REDUCED_BLANKING (1 << 7)
Alex Deucher3c537882010-02-05 04:21:19 -050071
Adam Jackson13931572010-08-03 14:38:19 -040072struct detailed_mode_closure {
73 struct drm_connector *connector;
74 struct edid *edid;
75 bool preferred;
76 u32 quirks;
77 int modes;
78};
Dave Airlief453ba02008-11-07 14:05:41 -080079
Zhao Yakui5c612592009-06-22 13:17:10 +080080#define LEVEL_DMT 0
81#define LEVEL_GTF 1
Adam Jackson7a374352010-03-29 21:43:30 +000082#define LEVEL_GTF2 2
83#define LEVEL_CVT 3
Zhao Yakui5c612592009-06-22 13:17:10 +080084
Dave Airlief453ba02008-11-07 14:05:41 -080085static struct edid_quirk {
Ian Pilcherc51a3fd62012-04-22 11:40:26 -050086 char vendor[4];
Dave Airlief453ba02008-11-07 14:05:41 -080087 int product_id;
88 u32 quirks;
89} edid_quirk_list[] = {
90 /* Acer AL1706 */
91 { "ACR", 44358, EDID_QUIRK_PREFER_LARGE_60 },
92 /* Acer F51 */
93 { "API", 0x7602, EDID_QUIRK_PREFER_LARGE_60 },
94 /* Unknown Acer */
95 { "ACR", 2423, EDID_QUIRK_FIRST_DETAILED_PREFERRED },
96
97 /* Belinea 10 15 55 */
98 { "MAX", 1516, EDID_QUIRK_PREFER_LARGE_60 },
99 { "MAX", 0x77e, EDID_QUIRK_PREFER_LARGE_60 },
100
101 /* Envision Peripherals, Inc. EN-7100e */
102 { "EPI", 59264, EDID_QUIRK_135_CLOCK_TOO_HIGH },
Adam Jacksonba1163d2010-04-06 16:11:00 +0000103 /* Envision EN2028 */
104 { "EPI", 8232, EDID_QUIRK_PREFER_LARGE_60 },
Dave Airlief453ba02008-11-07 14:05:41 -0800105
106 /* Funai Electronics PM36B */
107 { "FCM", 13600, EDID_QUIRK_PREFER_LARGE_75 |
108 EDID_QUIRK_DETAILED_IN_CM },
109
110 /* LG Philips LCD LP154W01-A5 */
111 { "LPL", 0, EDID_QUIRK_DETAILED_USE_MAXIMUM_SIZE },
112 { "LPL", 0x2a00, EDID_QUIRK_DETAILED_USE_MAXIMUM_SIZE },
113
114 /* Philips 107p5 CRT */
115 { "PHL", 57364, EDID_QUIRK_FIRST_DETAILED_PREFERRED },
116
117 /* Proview AY765C */
118 { "PTS", 765, EDID_QUIRK_FIRST_DETAILED_PREFERRED },
119
120 /* Samsung SyncMaster 205BW. Note: irony */
121 { "SAM", 541, EDID_QUIRK_DETAILED_SYNC_PP },
122 /* Samsung SyncMaster 22[5-6]BW */
123 { "SAM", 596, EDID_QUIRK_PREFER_LARGE_60 },
124 { "SAM", 638, EDID_QUIRK_PREFER_LARGE_60 },
Adam Jacksonbc42aab2012-05-23 16:26:54 -0400125
126 /* ViewSonic VA2026w */
127 { "VSC", 5020, EDID_QUIRK_FORCE_REDUCED_BLANKING },
Dave Airlief453ba02008-11-07 14:05:41 -0800128};
129
Adam Jackson61e57a82010-03-29 21:43:18 +0000130/*** DDC fetch and block validation ***/
Dave Airlief453ba02008-11-07 14:05:41 -0800131
Adam Jackson083ae052009-09-23 17:30:45 -0400132static const u8 edid_header[] = {
133 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00
134};
Dave Airlief453ba02008-11-07 14:05:41 -0800135
Thomas Reim051963d2011-07-29 14:28:57 +0000136 /*
137 * Sanity check the header of the base EDID block. Return 8 if the header
138 * is perfect, down to 0 if it's totally wrong.
139 */
140int drm_edid_header_is_valid(const u8 *raw_edid)
141{
142 int i, score = 0;
143
144 for (i = 0; i < sizeof(edid_header); i++)
145 if (raw_edid[i] == edid_header[i])
146 score++;
147
148 return score;
149}
150EXPORT_SYMBOL(drm_edid_header_is_valid);
151
Adam Jackson47819ba2012-05-30 16:42:39 -0400152static int edid_fixup __read_mostly = 6;
153module_param_named(edid_fixup, edid_fixup, int, 0400);
154MODULE_PARM_DESC(edid_fixup,
155 "Minimum number of valid EDID header bytes (0-8, default 6)");
Thomas Reim051963d2011-07-29 14:28:57 +0000156
Adam Jackson61e57a82010-03-29 21:43:18 +0000157/*
158 * Sanity check the EDID block (base or extension). Return 0 if the block
159 * doesn't check out, or 1 if it's valid.
Dave Airlief453ba02008-11-07 14:05:41 -0800160 */
Jerome Glisse0b2443e2012-08-09 11:25:51 -0400161bool drm_edid_block_valid(u8 *raw_edid, int block, bool print_bad_edid)
Dave Airlief453ba02008-11-07 14:05:41 -0800162{
Adam Jackson61e57a82010-03-29 21:43:18 +0000163 int i;
Dave Airlief453ba02008-11-07 14:05:41 -0800164 u8 csum = 0;
Adam Jackson61e57a82010-03-29 21:43:18 +0000165 struct edid *edid = (struct edid *)raw_edid;
Dave Airlief453ba02008-11-07 14:05:41 -0800166
Adam Jackson47819ba2012-05-30 16:42:39 -0400167 if (edid_fixup > 8 || edid_fixup < 0)
168 edid_fixup = 6;
169
Adam Jacksonf89ec8a2012-04-16 10:40:08 -0400170 if (block == 0) {
Thomas Reim051963d2011-07-29 14:28:57 +0000171 int score = drm_edid_header_is_valid(raw_edid);
Adam Jackson61e57a82010-03-29 21:43:18 +0000172 if (score == 8) ;
Adam Jackson47819ba2012-05-30 16:42:39 -0400173 else if (score >= edid_fixup) {
Adam Jackson61e57a82010-03-29 21:43:18 +0000174 DRM_DEBUG("Fixing EDID header, your hardware may be failing\n");
175 memcpy(raw_edid, edid_header, sizeof(edid_header));
176 } else {
177 goto bad;
178 }
179 }
Dave Airlief453ba02008-11-07 14:05:41 -0800180
181 for (i = 0; i < EDID_LENGTH; i++)
182 csum += raw_edid[i];
183 if (csum) {
Jerome Glisse0b2443e2012-08-09 11:25:51 -0400184 if (print_bad_edid) {
185 DRM_ERROR("EDID checksum is invalid, remainder is %d\n", csum);
186 }
Adam Jackson4a638b42010-05-25 16:33:09 -0400187
188 /* allow CEA to slide through, switches mangle this */
189 if (raw_edid[0] != 0x02)
190 goto bad;
Dave Airlief453ba02008-11-07 14:05:41 -0800191 }
192
Adam Jackson61e57a82010-03-29 21:43:18 +0000193 /* per-block-type checks */
194 switch (raw_edid[0]) {
195 case 0: /* base */
196 if (edid->version != 1) {
197 DRM_ERROR("EDID has major version %d, instead of 1\n", edid->version);
198 goto bad;
199 }
Adam Jackson862b89c2009-11-23 14:23:06 -0500200
Adam Jackson61e57a82010-03-29 21:43:18 +0000201 if (edid->revision > 4)
202 DRM_DEBUG("EDID minor > 4, assuming backward compatibility\n");
203 break;
204
205 default:
206 break;
207 }
Adam Jackson47ee4ccf2009-11-23 14:23:05 -0500208
Dave Airlief453ba02008-11-07 14:05:41 -0800209 return 1;
210
211bad:
Jerome Glisse0b2443e2012-08-09 11:25:51 -0400212 if (raw_edid && print_bad_edid) {
Dave Airlief49dadb2011-06-14 06:13:54 +0000213 printk(KERN_ERR "Raw EDID:\n");
Tormod Volden0aff47f2011-07-05 20:12:53 +0000214 print_hex_dump(KERN_ERR, " \t", DUMP_PREFIX_NONE, 16, 1,
215 raw_edid, EDID_LENGTH, false);
Dave Airlief453ba02008-11-07 14:05:41 -0800216 }
217 return 0;
218}
Carsten Emdeda0df922012-03-18 22:37:33 +0100219EXPORT_SYMBOL(drm_edid_block_valid);
Adam Jackson61e57a82010-03-29 21:43:18 +0000220
221/**
222 * drm_edid_is_valid - sanity check EDID data
223 * @edid: EDID data
224 *
225 * Sanity-check an entire EDID record (including extensions)
226 */
227bool drm_edid_is_valid(struct edid *edid)
228{
229 int i;
230 u8 *raw = (u8 *)edid;
231
232 if (!edid)
233 return false;
234
235 for (i = 0; i <= edid->extensions; i++)
Jerome Glisse0b2443e2012-08-09 11:25:51 -0400236 if (!drm_edid_block_valid(raw + i * EDID_LENGTH, i, true))
Adam Jackson61e57a82010-03-29 21:43:18 +0000237 return false;
238
239 return true;
240}
Alex Deucher3c537882010-02-05 04:21:19 -0500241EXPORT_SYMBOL(drm_edid_is_valid);
Dave Airlief453ba02008-11-07 14:05:41 -0800242
Adam Jackson61e57a82010-03-29 21:43:18 +0000243#define DDC_SEGMENT_ADDR 0x30
244/**
245 * Get EDID information via I2C.
246 *
247 * \param adapter : i2c device adaptor
248 * \param buf : EDID data buffer to be filled
249 * \param len : EDID data buffer length
250 * \return 0 on success or -1 on failure.
251 *
252 * Try to fetch EDID information by calling i2c driver function.
253 */
254static int
255drm_do_probe_ddc_edid(struct i2c_adapter *adapter, unsigned char *buf,
256 int block, int len)
257{
258 unsigned char start = block * EDID_LENGTH;
Shirish Scd004b32012-08-30 07:04:06 +0000259 unsigned char segment = block >> 1;
260 unsigned char xfers = segment ? 3 : 2;
Chris Wilson4819d2e2011-03-15 11:04:41 +0000261 int ret, retries = 5;
Adam Jackson61e57a82010-03-29 21:43:18 +0000262
Chris Wilson4819d2e2011-03-15 11:04:41 +0000263 /* The core i2c driver will automatically retry the transfer if the
264 * adapter reports EAGAIN. However, we find that bit-banging transfers
265 * are susceptible to errors under a heavily loaded machine and
266 * generate spurious NAKs and timeouts. Retrying the transfer
267 * of the individual block a few times seems to overcome this.
268 */
269 do {
270 struct i2c_msg msgs[] = {
271 {
Shirish Scd004b32012-08-30 07:04:06 +0000272 .addr = DDC_SEGMENT_ADDR,
273 .flags = 0,
274 .len = 1,
275 .buf = &segment,
276 }, {
Chris Wilson4819d2e2011-03-15 11:04:41 +0000277 .addr = DDC_ADDR,
278 .flags = 0,
279 .len = 1,
280 .buf = &start,
281 }, {
282 .addr = DDC_ADDR,
283 .flags = I2C_M_RD,
284 .len = len,
285 .buf = buf,
286 }
287 };
Shirish Scd004b32012-08-30 07:04:06 +0000288
289 /*
290 * Avoid sending the segment addr to not upset non-compliant ddc
291 * monitors.
292 */
293 ret = i2c_transfer(adapter, &msgs[3 - xfers], xfers);
294
Eugeni Dodonov9292f372012-01-05 09:34:28 -0200295 if (ret == -ENXIO) {
296 DRM_DEBUG_KMS("drm: skipping non-existent adapter %s\n",
297 adapter->name);
298 break;
299 }
Shirish Scd004b32012-08-30 07:04:06 +0000300 } while (ret != xfers && --retries);
Adam Jackson61e57a82010-03-29 21:43:18 +0000301
Shirish Scd004b32012-08-30 07:04:06 +0000302 return ret == xfers ? 0 : -1;
Adam Jackson61e57a82010-03-29 21:43:18 +0000303}
304
Dave Airlie4a9a8b72011-06-14 06:13:55 +0000305static bool drm_edid_is_zero(u8 *in_edid, int length)
306{
Akinobu Mita63118032012-11-09 12:10:42 +0000307 if (memchr_inv(in_edid, 0, length))
308 return false;
Dave Airlie4a9a8b72011-06-14 06:13:55 +0000309
Dave Airlie4a9a8b72011-06-14 06:13:55 +0000310 return true;
311}
312
Adam Jackson61e57a82010-03-29 21:43:18 +0000313static u8 *
314drm_do_get_edid(struct drm_connector *connector, struct i2c_adapter *adapter)
315{
Sam Tygier0ea75e22010-09-23 10:11:01 +0100316 int i, j = 0, valid_extensions = 0;
Adam Jackson61e57a82010-03-29 21:43:18 +0000317 u8 *block, *new;
Jerome Glisse0b2443e2012-08-09 11:25:51 -0400318 bool print_bad_edid = !connector->bad_edid_counter || (drm_debug & DRM_UT_KMS);
Adam Jackson61e57a82010-03-29 21:43:18 +0000319
320 if ((block = kmalloc(EDID_LENGTH, GFP_KERNEL)) == NULL)
321 return NULL;
322
323 /* base block fetch */
324 for (i = 0; i < 4; i++) {
325 if (drm_do_probe_ddc_edid(adapter, block, 0, EDID_LENGTH))
326 goto out;
Jerome Glisse0b2443e2012-08-09 11:25:51 -0400327 if (drm_edid_block_valid(block, 0, print_bad_edid))
Adam Jackson61e57a82010-03-29 21:43:18 +0000328 break;
Dave Airlie4a9a8b72011-06-14 06:13:55 +0000329 if (i == 0 && drm_edid_is_zero(block, EDID_LENGTH)) {
330 connector->null_edid_counter++;
331 goto carp;
332 }
Adam Jackson61e57a82010-03-29 21:43:18 +0000333 }
334 if (i == 4)
335 goto carp;
336
337 /* if there's no extensions, we're done */
338 if (block[0x7e] == 0)
339 return block;
340
341 new = krealloc(block, (block[0x7e] + 1) * EDID_LENGTH, GFP_KERNEL);
342 if (!new)
343 goto out;
344 block = new;
345
346 for (j = 1; j <= block[0x7e]; j++) {
347 for (i = 0; i < 4; i++) {
Sam Tygier0ea75e22010-09-23 10:11:01 +0100348 if (drm_do_probe_ddc_edid(adapter,
349 block + (valid_extensions + 1) * EDID_LENGTH,
350 j, EDID_LENGTH))
Adam Jackson61e57a82010-03-29 21:43:18 +0000351 goto out;
Jerome Glisse0b2443e2012-08-09 11:25:51 -0400352 if (drm_edid_block_valid(block + (valid_extensions + 1) * EDID_LENGTH, j, print_bad_edid)) {
Sam Tygier0ea75e22010-09-23 10:11:01 +0100353 valid_extensions++;
Adam Jackson61e57a82010-03-29 21:43:18 +0000354 break;
Sam Tygier0ea75e22010-09-23 10:11:01 +0100355 }
Adam Jackson61e57a82010-03-29 21:43:18 +0000356 }
Maarten Lankhorstf934ec8c2013-01-29 14:27:39 +0100357
358 if (i == 4 && print_bad_edid) {
Sam Tygier0ea75e22010-09-23 10:11:01 +0100359 dev_warn(connector->dev->dev,
360 "%s: Ignoring invalid EDID block %d.\n",
361 drm_get_connector_name(connector), j);
Maarten Lankhorstf934ec8c2013-01-29 14:27:39 +0100362
363 connector->bad_edid_counter++;
364 }
Sam Tygier0ea75e22010-09-23 10:11:01 +0100365 }
366
367 if (valid_extensions != block[0x7e]) {
368 block[EDID_LENGTH-1] += block[0x7e] - valid_extensions;
369 block[0x7e] = valid_extensions;
370 new = krealloc(block, (valid_extensions + 1) * EDID_LENGTH, GFP_KERNEL);
371 if (!new)
372 goto out;
373 block = new;
Adam Jackson61e57a82010-03-29 21:43:18 +0000374 }
375
376 return block;
377
378carp:
Jerome Glisse0b2443e2012-08-09 11:25:51 -0400379 if (print_bad_edid) {
380 dev_warn(connector->dev->dev, "%s: EDID block %d invalid.\n",
381 drm_get_connector_name(connector), j);
382 }
383 connector->bad_edid_counter++;
Adam Jackson61e57a82010-03-29 21:43:18 +0000384
385out:
386 kfree(block);
387 return NULL;
388}
389
390/**
391 * Probe DDC presence.
392 *
393 * \param adapter : i2c device adaptor
394 * \return 1 on success
395 */
Adam Jacksonfbff4692012-09-18 10:58:47 -0400396bool
Adam Jackson61e57a82010-03-29 21:43:18 +0000397drm_probe_ddc(struct i2c_adapter *adapter)
398{
399 unsigned char out;
400
401 return (drm_do_probe_ddc_edid(adapter, &out, 0, 1) == 0);
402}
Adam Jacksonfbff4692012-09-18 10:58:47 -0400403EXPORT_SYMBOL(drm_probe_ddc);
Adam Jackson61e57a82010-03-29 21:43:18 +0000404
405/**
406 * drm_get_edid - get EDID data, if available
407 * @connector: connector we're probing
408 * @adapter: i2c adapter to use for DDC
409 *
410 * Poke the given i2c channel to grab EDID data if possible. If found,
411 * attach it to the connector.
412 *
413 * Return edid data or NULL if we couldn't find any.
414 */
415struct edid *drm_get_edid(struct drm_connector *connector,
416 struct i2c_adapter *adapter)
417{
418 struct edid *edid = NULL;
419
420 if (drm_probe_ddc(adapter))
421 edid = (struct edid *)drm_do_get_edid(connector, adapter);
422
Adam Jackson61e57a82010-03-29 21:43:18 +0000423 return edid;
Adam Jackson61e57a82010-03-29 21:43:18 +0000424}
425EXPORT_SYMBOL(drm_get_edid);
426
427/*** EDID parsing ***/
428
Dave Airlief453ba02008-11-07 14:05:41 -0800429/**
430 * edid_vendor - match a string against EDID's obfuscated vendor field
431 * @edid: EDID to match
432 * @vendor: vendor string
433 *
434 * Returns true if @vendor is in @edid, false otherwise
435 */
436static bool edid_vendor(struct edid *edid, char *vendor)
437{
438 char edid_vendor[3];
439
440 edid_vendor[0] = ((edid->mfg_id[0] & 0x7c) >> 2) + '@';
441 edid_vendor[1] = (((edid->mfg_id[0] & 0x3) << 3) |
442 ((edid->mfg_id[1] & 0xe0) >> 5)) + '@';
Dave Airlie16456c82009-04-03 09:10:33 +1000443 edid_vendor[2] = (edid->mfg_id[1] & 0x1f) + '@';
Dave Airlief453ba02008-11-07 14:05:41 -0800444
445 return !strncmp(edid_vendor, vendor, 3);
446}
447
448/**
449 * edid_get_quirks - return quirk flags for a given EDID
450 * @edid: EDID to process
451 *
452 * This tells subsequent routines what fixes they need to apply.
453 */
454static u32 edid_get_quirks(struct edid *edid)
455{
456 struct edid_quirk *quirk;
457 int i;
458
459 for (i = 0; i < ARRAY_SIZE(edid_quirk_list); i++) {
460 quirk = &edid_quirk_list[i];
461
462 if (edid_vendor(edid, quirk->vendor) &&
463 (EDID_PRODUCT_ID(edid) == quirk->product_id))
464 return quirk->quirks;
465 }
466
467 return 0;
468}
469
470#define MODE_SIZE(m) ((m)->hdisplay * (m)->vdisplay)
471#define MODE_REFRESH_DIFF(m,r) (abs((m)->vrefresh - target_refresh))
472
Dave Airlief453ba02008-11-07 14:05:41 -0800473/**
474 * edid_fixup_preferred - set preferred modes based on quirk list
475 * @connector: has mode list to fix up
476 * @quirks: quirks list
477 *
478 * Walk the mode list for @connector, clearing the preferred status
479 * on existing modes and setting it anew for the right mode ala @quirks.
480 */
481static void edid_fixup_preferred(struct drm_connector *connector,
482 u32 quirks)
483{
484 struct drm_display_mode *t, *cur_mode, *preferred_mode;
Dave Airlief8906072008-12-18 16:59:02 +1000485 int target_refresh = 0;
Dave Airlief453ba02008-11-07 14:05:41 -0800486
487 if (list_empty(&connector->probed_modes))
488 return;
489
490 if (quirks & EDID_QUIRK_PREFER_LARGE_60)
491 target_refresh = 60;
492 if (quirks & EDID_QUIRK_PREFER_LARGE_75)
493 target_refresh = 75;
494
495 preferred_mode = list_first_entry(&connector->probed_modes,
496 struct drm_display_mode, head);
497
498 list_for_each_entry_safe(cur_mode, t, &connector->probed_modes, head) {
499 cur_mode->type &= ~DRM_MODE_TYPE_PREFERRED;
500
501 if (cur_mode == preferred_mode)
502 continue;
503
504 /* Largest mode is preferred */
505 if (MODE_SIZE(cur_mode) > MODE_SIZE(preferred_mode))
506 preferred_mode = cur_mode;
507
508 /* At a given size, try to get closest to target refresh */
509 if ((MODE_SIZE(cur_mode) == MODE_SIZE(preferred_mode)) &&
510 MODE_REFRESH_DIFF(cur_mode, target_refresh) <
511 MODE_REFRESH_DIFF(preferred_mode, target_refresh)) {
512 preferred_mode = cur_mode;
513 }
514 }
515
516 preferred_mode->type |= DRM_MODE_TYPE_PREFERRED;
517}
518
Adam Jacksonf6e252b2012-04-13 16:33:31 -0400519static bool
520mode_is_rb(const struct drm_display_mode *mode)
521{
522 return (mode->htotal - mode->hdisplay == 160) &&
523 (mode->hsync_end - mode->hdisplay == 80) &&
524 (mode->hsync_end - mode->hsync_start == 32) &&
525 (mode->vsync_start - mode->vdisplay == 3);
526}
527
Adam Jackson33c75312012-04-13 16:33:29 -0400528/*
529 * drm_mode_find_dmt - Create a copy of a mode if present in DMT
530 * @dev: Device to duplicate against
531 * @hsize: Mode width
532 * @vsize: Mode height
533 * @fresh: Mode refresh rate
Adam Jacksonf6e252b2012-04-13 16:33:31 -0400534 * @rb: Mode reduced-blanking-ness
Adam Jackson33c75312012-04-13 16:33:29 -0400535 *
536 * Walk the DMT mode list looking for a match for the given parameters.
537 * Return a newly allocated copy of the mode, or NULL if not found.
538 */
Dave Airlie1d42bbc2010-05-07 05:02:30 +0000539struct drm_display_mode *drm_mode_find_dmt(struct drm_device *dev,
Adam Jacksonf6e252b2012-04-13 16:33:31 -0400540 int hsize, int vsize, int fresh,
541 bool rb)
Zhao Yakui559ee212009-09-03 09:33:47 +0800542{
Adam Jackson07a5e632009-12-03 17:44:38 -0500543 int i;
Zhao Yakui559ee212009-09-03 09:33:47 +0800544
Adam Jackson07a5e632009-12-03 17:44:38 -0500545 for (i = 0; i < drm_num_dmt_modes; i++) {
Chris Wilsonb1f559e2011-01-26 09:49:47 +0000546 const struct drm_display_mode *ptr = &drm_dmt_modes[i];
Adam Jacksonf8b46a02012-04-13 16:33:30 -0400547 if (hsize != ptr->hdisplay)
548 continue;
549 if (vsize != ptr->vdisplay)
550 continue;
551 if (fresh != drm_mode_vrefresh(ptr))
552 continue;
Adam Jacksonf6e252b2012-04-13 16:33:31 -0400553 if (rb != mode_is_rb(ptr))
554 continue;
Adam Jacksonf8b46a02012-04-13 16:33:30 -0400555
556 return drm_mode_duplicate(dev, ptr);
Zhao Yakui559ee212009-09-03 09:33:47 +0800557 }
Adam Jacksonf8b46a02012-04-13 16:33:30 -0400558
559 return NULL;
Zhao Yakui559ee212009-09-03 09:33:47 +0800560}
Dave Airlie1d42bbc2010-05-07 05:02:30 +0000561EXPORT_SYMBOL(drm_mode_find_dmt);
Adam Jackson23425ca2009-09-23 17:30:58 -0400562
Adam Jacksond1ff6402010-03-29 21:43:26 +0000563typedef void detailed_cb(struct detailed_timing *timing, void *closure);
564
565static void
Adam Jackson4d76a222010-08-03 14:38:17 -0400566cea_for_each_detailed_block(u8 *ext, detailed_cb *cb, void *closure)
567{
568 int i, n = 0;
Christian Schmidt4966b2a2011-12-19 20:03:43 +0100569 u8 d = ext[0x02];
Adam Jackson4d76a222010-08-03 14:38:17 -0400570 u8 *det_base = ext + d;
571
Christian Schmidt4966b2a2011-12-19 20:03:43 +0100572 n = (127 - d) / 18;
Adam Jackson4d76a222010-08-03 14:38:17 -0400573 for (i = 0; i < n; i++)
574 cb((struct detailed_timing *)(det_base + 18 * i), closure);
575}
576
577static void
Adam Jacksoncbba98f2010-08-03 14:38:18 -0400578vtb_for_each_detailed_block(u8 *ext, detailed_cb *cb, void *closure)
579{
580 unsigned int i, n = min((int)ext[0x02], 6);
581 u8 *det_base = ext + 5;
582
583 if (ext[0x01] != 1)
584 return; /* unknown version */
585
586 for (i = 0; i < n; i++)
587 cb((struct detailed_timing *)(det_base + 18 * i), closure);
588}
589
590static void
Adam Jacksond1ff6402010-03-29 21:43:26 +0000591drm_for_each_detailed_block(u8 *raw_edid, detailed_cb *cb, void *closure)
592{
593 int i;
594 struct edid *edid = (struct edid *)raw_edid;
595
596 if (edid == NULL)
597 return;
598
599 for (i = 0; i < EDID_DETAILED_TIMINGS; i++)
600 cb(&(edid->detailed_timings[i]), closure);
601
Adam Jackson4d76a222010-08-03 14:38:17 -0400602 for (i = 1; i <= raw_edid[0x7e]; i++) {
603 u8 *ext = raw_edid + (i * EDID_LENGTH);
604 switch (*ext) {
605 case CEA_EXT:
606 cea_for_each_detailed_block(ext, cb, closure);
607 break;
Adam Jacksoncbba98f2010-08-03 14:38:18 -0400608 case VTB_EXT:
609 vtb_for_each_detailed_block(ext, cb, closure);
610 break;
Adam Jackson4d76a222010-08-03 14:38:17 -0400611 default:
612 break;
613 }
614 }
Adam Jacksond1ff6402010-03-29 21:43:26 +0000615}
616
617static void
618is_rb(struct detailed_timing *t, void *data)
619{
620 u8 *r = (u8 *)t;
621 if (r[3] == EDID_DETAIL_MONITOR_RANGE)
622 if (r[15] & 0x10)
623 *(bool *)data = true;
624}
625
626/* EDID 1.4 defines this explicitly. For EDID 1.3, we guess, badly. */
627static bool
628drm_monitor_supports_rb(struct edid *edid)
629{
630 if (edid->revision >= 4) {
Daniel Vetterb196a492012-06-19 11:33:06 +0200631 bool ret = false;
Adam Jacksond1ff6402010-03-29 21:43:26 +0000632 drm_for_each_detailed_block((u8 *)edid, is_rb, &ret);
633 return ret;
634 }
635
636 return ((edid->input & DRM_EDID_INPUT_DIGITAL) != 0);
637}
638
Adam Jackson7a374352010-03-29 21:43:30 +0000639static void
640find_gtf2(struct detailed_timing *t, void *data)
641{
642 u8 *r = (u8 *)t;
643 if (r[3] == EDID_DETAIL_MONITOR_RANGE && r[10] == 0x02)
644 *(u8 **)data = r;
645}
646
647/* Secondary GTF curve kicks in above some break frequency */
648static int
649drm_gtf2_hbreak(struct edid *edid)
650{
651 u8 *r = NULL;
652 drm_for_each_detailed_block((u8 *)edid, find_gtf2, &r);
653 return r ? (r[12] * 2) : 0;
654}
655
656static int
657drm_gtf2_2c(struct edid *edid)
658{
659 u8 *r = NULL;
660 drm_for_each_detailed_block((u8 *)edid, find_gtf2, &r);
661 return r ? r[13] : 0;
662}
663
664static int
665drm_gtf2_m(struct edid *edid)
666{
667 u8 *r = NULL;
668 drm_for_each_detailed_block((u8 *)edid, find_gtf2, &r);
669 return r ? (r[15] << 8) + r[14] : 0;
670}
671
672static int
673drm_gtf2_k(struct edid *edid)
674{
675 u8 *r = NULL;
676 drm_for_each_detailed_block((u8 *)edid, find_gtf2, &r);
677 return r ? r[16] : 0;
678}
679
680static int
681drm_gtf2_2j(struct edid *edid)
682{
683 u8 *r = NULL;
684 drm_for_each_detailed_block((u8 *)edid, find_gtf2, &r);
685 return r ? r[17] : 0;
686}
687
688/**
689 * standard_timing_level - get std. timing level(CVT/GTF/DMT)
690 * @edid: EDID block to scan
691 */
692static int standard_timing_level(struct edid *edid)
693{
694 if (edid->revision >= 2) {
695 if (edid->revision >= 4 && (edid->features & DRM_EDID_FEATURE_DEFAULT_GTF))
696 return LEVEL_CVT;
697 if (drm_gtf2_hbreak(edid))
698 return LEVEL_GTF2;
699 return LEVEL_GTF;
700 }
701 return LEVEL_DMT;
702}
703
Adam Jackson23425ca2009-09-23 17:30:58 -0400704/*
705 * 0 is reserved. The spec says 0x01 fill for unused timings. Some old
706 * monitors fill with ascii space (0x20) instead.
707 */
708static int
709bad_std_timing(u8 a, u8 b)
710{
711 return (a == 0x00 && b == 0x00) ||
712 (a == 0x01 && b == 0x01) ||
713 (a == 0x20 && b == 0x20);
714}
715
Dave Airlief453ba02008-11-07 14:05:41 -0800716/**
717 * drm_mode_std - convert standard mode info (width, height, refresh) into mode
718 * @t: standard timing params
Zhao Yakui5c612592009-06-22 13:17:10 +0800719 * @timing_level: standard timing level
Dave Airlief453ba02008-11-07 14:05:41 -0800720 *
721 * Take the standard timing params (in this case width, aspect, and refresh)
Zhao Yakui5c612592009-06-22 13:17:10 +0800722 * and convert them into a real mode using CVT/GTF/DMT.
Dave Airlief453ba02008-11-07 14:05:41 -0800723 */
Adam Jackson7ca6adb2010-03-29 21:43:29 +0000724static struct drm_display_mode *
Adam Jackson7a374352010-03-29 21:43:30 +0000725drm_mode_std(struct drm_connector *connector, struct edid *edid,
726 struct std_timing *t, int revision)
Dave Airlief453ba02008-11-07 14:05:41 -0800727{
Adam Jackson7ca6adb2010-03-29 21:43:29 +0000728 struct drm_device *dev = connector->dev;
729 struct drm_display_mode *m, *mode = NULL;
Zhao Yakui5c612592009-06-22 13:17:10 +0800730 int hsize, vsize;
731 int vrefresh_rate;
Michel Dänzer0454bea2009-06-15 16:56:07 +0200732 unsigned aspect_ratio = (t->vfreq_aspect & EDID_TIMING_ASPECT_MASK)
733 >> EDID_TIMING_ASPECT_SHIFT;
Zhao Yakui5c612592009-06-22 13:17:10 +0800734 unsigned vfreq = (t->vfreq_aspect & EDID_TIMING_VFREQ_MASK)
735 >> EDID_TIMING_VFREQ_SHIFT;
Adam Jackson7a374352010-03-29 21:43:30 +0000736 int timing_level = standard_timing_level(edid);
Dave Airlief453ba02008-11-07 14:05:41 -0800737
Adam Jackson23425ca2009-09-23 17:30:58 -0400738 if (bad_std_timing(t->hsize, t->vfreq_aspect))
739 return NULL;
740
Zhao Yakui5c612592009-06-22 13:17:10 +0800741 /* According to the EDID spec, the hdisplay = hsize * 8 + 248 */
742 hsize = t->hsize * 8 + 248;
743 /* vrefresh_rate = vfreq + 60 */
744 vrefresh_rate = vfreq + 60;
745 /* the vdisplay is calculated based on the aspect ratio */
Adam Jacksonf066a172009-09-23 17:31:21 -0400746 if (aspect_ratio == 0) {
747 if (revision < 3)
748 vsize = hsize;
749 else
750 vsize = (hsize * 10) / 16;
751 } else if (aspect_ratio == 1)
Dave Airlief453ba02008-11-07 14:05:41 -0800752 vsize = (hsize * 3) / 4;
Michel Dänzer0454bea2009-06-15 16:56:07 +0200753 else if (aspect_ratio == 2)
Dave Airlief453ba02008-11-07 14:05:41 -0800754 vsize = (hsize * 4) / 5;
755 else
756 vsize = (hsize * 9) / 16;
Adam Jacksona0910c82010-03-29 21:43:28 +0000757
758 /* HDTV hack, part 1 */
759 if (vrefresh_rate == 60 &&
760 ((hsize == 1360 && vsize == 765) ||
761 (hsize == 1368 && vsize == 769))) {
762 hsize = 1366;
763 vsize = 768;
764 }
765
Adam Jackson7ca6adb2010-03-29 21:43:29 +0000766 /*
767 * If this connector already has a mode for this size and refresh
768 * rate (because it came from detailed or CVT info), use that
769 * instead. This way we don't have to guess at interlace or
770 * reduced blanking.
771 */
Adam Jackson522032d2010-04-09 16:52:49 +0000772 list_for_each_entry(m, &connector->probed_modes, head)
Adam Jackson7ca6adb2010-03-29 21:43:29 +0000773 if (m->hdisplay == hsize && m->vdisplay == vsize &&
774 drm_mode_vrefresh(m) == vrefresh_rate)
775 return NULL;
776
Adam Jacksona0910c82010-03-29 21:43:28 +0000777 /* HDTV hack, part 2 */
778 if (hsize == 1366 && vsize == 768 && vrefresh_rate == 60) {
779 mode = drm_cvt_mode(dev, 1366, 768, vrefresh_rate, 0, 0,
Dave Airlied50ba252009-09-23 14:44:08 +1000780 false);
Zhao Yakui559ee212009-09-03 09:33:47 +0800781 mode->hdisplay = 1366;
Adam Jacksona4967de62010-07-28 07:40:32 +1000782 mode->hsync_start = mode->hsync_start - 1;
783 mode->hsync_end = mode->hsync_end - 1;
Zhao Yakui559ee212009-09-03 09:33:47 +0800784 return mode;
785 }
Adam Jacksona0910c82010-03-29 21:43:28 +0000786
Zhao Yakui559ee212009-09-03 09:33:47 +0800787 /* check whether it can be found in default mode table */
Adam Jacksonf6e252b2012-04-13 16:33:31 -0400788 if (drm_monitor_supports_rb(edid)) {
789 mode = drm_mode_find_dmt(dev, hsize, vsize, vrefresh_rate,
790 true);
791 if (mode)
792 return mode;
793 }
794 mode = drm_mode_find_dmt(dev, hsize, vsize, vrefresh_rate, false);
Zhao Yakui559ee212009-09-03 09:33:47 +0800795 if (mode)
796 return mode;
797
Adam Jacksonf6e252b2012-04-13 16:33:31 -0400798 /* okay, generate it */
Zhao Yakui5c612592009-06-22 13:17:10 +0800799 switch (timing_level) {
800 case LEVEL_DMT:
Zhao Yakui5c612592009-06-22 13:17:10 +0800801 break;
802 case LEVEL_GTF:
803 mode = drm_gtf_mode(dev, hsize, vsize, vrefresh_rate, 0, 0);
804 break;
Adam Jackson7a374352010-03-29 21:43:30 +0000805 case LEVEL_GTF2:
806 /*
807 * This is potentially wrong if there's ever a monitor with
808 * more than one ranges section, each claiming a different
809 * secondary GTF curve. Please don't do that.
810 */
811 mode = drm_gtf_mode(dev, hsize, vsize, vrefresh_rate, 0, 0);
Takashi Iwaifc48f162012-04-20 12:59:33 +0100812 if (!mode)
813 return NULL;
Adam Jackson7a374352010-03-29 21:43:30 +0000814 if (drm_mode_hsync(mode) > drm_gtf2_hbreak(edid)) {
Sascha Haueraefd3302012-02-01 11:38:21 +0100815 drm_mode_destroy(dev, mode);
Adam Jackson7a374352010-03-29 21:43:30 +0000816 mode = drm_gtf_mode_complex(dev, hsize, vsize,
817 vrefresh_rate, 0, 0,
818 drm_gtf2_m(edid),
819 drm_gtf2_2c(edid),
820 drm_gtf2_k(edid),
821 drm_gtf2_2j(edid));
822 }
823 break;
Zhao Yakui5c612592009-06-22 13:17:10 +0800824 case LEVEL_CVT:
Dave Airlied50ba252009-09-23 14:44:08 +1000825 mode = drm_cvt_mode(dev, hsize, vsize, vrefresh_rate, 0, 0,
826 false);
Zhao Yakui5c612592009-06-22 13:17:10 +0800827 break;
828 }
Dave Airlief453ba02008-11-07 14:05:41 -0800829 return mode;
830}
831
Adam Jacksonb58db2c2010-02-15 22:15:39 +0000832/*
833 * EDID is delightfully ambiguous about how interlaced modes are to be
834 * encoded. Our internal representation is of frame height, but some
835 * HDTV detailed timings are encoded as field height.
836 *
837 * The format list here is from CEA, in frame size. Technically we
838 * should be checking refresh rate too. Whatever.
839 */
840static void
841drm_mode_do_interlace_quirk(struct drm_display_mode *mode,
842 struct detailed_pixel_timing *pt)
843{
844 int i;
845 static const struct {
846 int w, h;
847 } cea_interlaced[] = {
848 { 1920, 1080 },
849 { 720, 480 },
850 { 1440, 480 },
851 { 2880, 480 },
852 { 720, 576 },
853 { 1440, 576 },
854 { 2880, 576 },
855 };
Adam Jacksonb58db2c2010-02-15 22:15:39 +0000856
857 if (!(pt->misc & DRM_EDID_PT_INTERLACED))
858 return;
859
Kulikov Vasiliy3c581412010-06-28 15:54:52 +0400860 for (i = 0; i < ARRAY_SIZE(cea_interlaced); i++) {
Adam Jacksonb58db2c2010-02-15 22:15:39 +0000861 if ((mode->hdisplay == cea_interlaced[i].w) &&
862 (mode->vdisplay == cea_interlaced[i].h / 2)) {
863 mode->vdisplay *= 2;
864 mode->vsync_start *= 2;
865 mode->vsync_end *= 2;
866 mode->vtotal *= 2;
867 mode->vtotal |= 1;
868 }
869 }
870
871 mode->flags |= DRM_MODE_FLAG_INTERLACE;
872}
873
Dave Airlief453ba02008-11-07 14:05:41 -0800874/**
875 * drm_mode_detailed - create a new mode from an EDID detailed timing section
876 * @dev: DRM device (needed to create new mode)
877 * @edid: EDID block
878 * @timing: EDID detailed timing info
879 * @quirks: quirks to apply
880 *
881 * An EDID detailed timing block contains enough info for us to create and
882 * return a new struct drm_display_mode.
883 */
884static struct drm_display_mode *drm_mode_detailed(struct drm_device *dev,
885 struct edid *edid,
886 struct detailed_timing *timing,
887 u32 quirks)
888{
889 struct drm_display_mode *mode;
890 struct detailed_pixel_timing *pt = &timing->data.pixel_data;
Michel Dänzer0454bea2009-06-15 16:56:07 +0200891 unsigned hactive = (pt->hactive_hblank_hi & 0xf0) << 4 | pt->hactive_lo;
892 unsigned vactive = (pt->vactive_vblank_hi & 0xf0) << 4 | pt->vactive_lo;
893 unsigned hblank = (pt->hactive_hblank_hi & 0xf) << 8 | pt->hblank_lo;
894 unsigned vblank = (pt->vactive_vblank_hi & 0xf) << 8 | pt->vblank_lo;
Michel Dänzere14cbee2009-06-23 12:36:32 +0200895 unsigned hsync_offset = (pt->hsync_vsync_offset_pulse_width_hi & 0xc0) << 2 | pt->hsync_offset_lo;
896 unsigned hsync_pulse_width = (pt->hsync_vsync_offset_pulse_width_hi & 0x30) << 4 | pt->hsync_pulse_width_lo;
897 unsigned vsync_offset = (pt->hsync_vsync_offset_pulse_width_hi & 0xc) >> 2 | pt->vsync_offset_pulse_width_lo >> 4;
898 unsigned vsync_pulse_width = (pt->hsync_vsync_offset_pulse_width_hi & 0x3) << 4 | (pt->vsync_offset_pulse_width_lo & 0xf);
Dave Airlief453ba02008-11-07 14:05:41 -0800899
Adam Jacksonfc438962009-06-04 10:20:34 +1000900 /* ignore tiny modes */
Michel Dänzer0454bea2009-06-15 16:56:07 +0200901 if (hactive < 64 || vactive < 64)
Adam Jacksonfc438962009-06-04 10:20:34 +1000902 return NULL;
903
Michel Dänzer0454bea2009-06-15 16:56:07 +0200904 if (pt->misc & DRM_EDID_PT_STEREO) {
Dave Airlief453ba02008-11-07 14:05:41 -0800905 printk(KERN_WARNING "stereo mode not supported\n");
906 return NULL;
907 }
Michel Dänzer0454bea2009-06-15 16:56:07 +0200908 if (!(pt->misc & DRM_EDID_PT_SEPARATE_SYNC)) {
Jerome Glisse79b7dcb2010-01-14 19:02:20 +0100909 printk(KERN_WARNING "composite sync not supported\n");
Dave Airlief453ba02008-11-07 14:05:41 -0800910 }
911
Zhao Yakuifcb45612009-10-14 09:11:25 +0800912 /* it is incorrect if hsync/vsync width is zero */
913 if (!hsync_pulse_width || !vsync_pulse_width) {
914 DRM_DEBUG_KMS("Incorrect Detailed timing. "
915 "Wrong Hsync/Vsync pulse width\n");
916 return NULL;
917 }
Adam Jacksonbc42aab2012-05-23 16:26:54 -0400918
919 if (quirks & EDID_QUIRK_FORCE_REDUCED_BLANKING) {
920 mode = drm_cvt_mode(dev, hactive, vactive, 60, true, false, false);
921 if (!mode)
922 return NULL;
923
924 goto set_size;
925 }
926
Dave Airlief453ba02008-11-07 14:05:41 -0800927 mode = drm_mode_create(dev);
928 if (!mode)
929 return NULL;
930
Dave Airlief453ba02008-11-07 14:05:41 -0800931 if (quirks & EDID_QUIRK_135_CLOCK_TOO_HIGH)
Michel Dänzer0454bea2009-06-15 16:56:07 +0200932 timing->pixel_clock = cpu_to_le16(1088);
Dave Airlief453ba02008-11-07 14:05:41 -0800933
Michel Dänzer0454bea2009-06-15 16:56:07 +0200934 mode->clock = le16_to_cpu(timing->pixel_clock) * 10;
Dave Airlief453ba02008-11-07 14:05:41 -0800935
Michel Dänzer0454bea2009-06-15 16:56:07 +0200936 mode->hdisplay = hactive;
937 mode->hsync_start = mode->hdisplay + hsync_offset;
938 mode->hsync_end = mode->hsync_start + hsync_pulse_width;
939 mode->htotal = mode->hdisplay + hblank;
Dave Airlief453ba02008-11-07 14:05:41 -0800940
Michel Dänzer0454bea2009-06-15 16:56:07 +0200941 mode->vdisplay = vactive;
942 mode->vsync_start = mode->vdisplay + vsync_offset;
943 mode->vsync_end = mode->vsync_start + vsync_pulse_width;
944 mode->vtotal = mode->vdisplay + vblank;
Dave Airlief453ba02008-11-07 14:05:41 -0800945
Jesse Barnes7064fef2009-11-05 10:12:54 -0800946 /* Some EDIDs have bogus h/vtotal values */
947 if (mode->hsync_end > mode->htotal)
948 mode->htotal = mode->hsync_end + 1;
949 if (mode->vsync_end > mode->vtotal)
950 mode->vtotal = mode->vsync_end + 1;
951
Adam Jacksonb58db2c2010-02-15 22:15:39 +0000952 drm_mode_do_interlace_quirk(mode, pt);
Dave Airlief453ba02008-11-07 14:05:41 -0800953
954 if (quirks & EDID_QUIRK_DETAILED_SYNC_PP) {
Michel Dänzer0454bea2009-06-15 16:56:07 +0200955 pt->misc |= DRM_EDID_PT_HSYNC_POSITIVE | DRM_EDID_PT_VSYNC_POSITIVE;
Dave Airlief453ba02008-11-07 14:05:41 -0800956 }
957
Michel Dänzer0454bea2009-06-15 16:56:07 +0200958 mode->flags |= (pt->misc & DRM_EDID_PT_HSYNC_POSITIVE) ?
959 DRM_MODE_FLAG_PHSYNC : DRM_MODE_FLAG_NHSYNC;
960 mode->flags |= (pt->misc & DRM_EDID_PT_VSYNC_POSITIVE) ?
961 DRM_MODE_FLAG_PVSYNC : DRM_MODE_FLAG_NVSYNC;
Dave Airlief453ba02008-11-07 14:05:41 -0800962
Adam Jacksonbc42aab2012-05-23 16:26:54 -0400963set_size:
Michel Dänzere14cbee2009-06-23 12:36:32 +0200964 mode->width_mm = pt->width_mm_lo | (pt->width_height_mm_hi & 0xf0) << 4;
965 mode->height_mm = pt->height_mm_lo | (pt->width_height_mm_hi & 0xf) << 8;
Dave Airlief453ba02008-11-07 14:05:41 -0800966
967 if (quirks & EDID_QUIRK_DETAILED_IN_CM) {
968 mode->width_mm *= 10;
969 mode->height_mm *= 10;
970 }
971
972 if (quirks & EDID_QUIRK_DETAILED_USE_MAXIMUM_SIZE) {
973 mode->width_mm = edid->width_cm * 10;
974 mode->height_mm = edid->height_cm * 10;
975 }
976
Adam Jacksonbc42aab2012-05-23 16:26:54 -0400977 mode->type = DRM_MODE_TYPE_DRIVER;
978 drm_mode_set_name(mode);
979
Dave Airlief453ba02008-11-07 14:05:41 -0800980 return mode;
981}
982
Adam Jackson07a5e632009-12-03 17:44:38 -0500983static bool
Chris Wilsonb1f559e2011-01-26 09:49:47 +0000984mode_in_hsync_range(const struct drm_display_mode *mode,
985 struct edid *edid, u8 *t)
Adam Jacksonb17e52e2010-03-29 21:43:27 +0000986{
987 int hsync, hmin, hmax;
Adam Jackson07a5e632009-12-03 17:44:38 -0500988
Adam Jacksonb17e52e2010-03-29 21:43:27 +0000989 hmin = t[7];
990 if (edid->revision >= 4)
991 hmin += ((t[4] & 0x04) ? 255 : 0);
992 hmax = t[8];
993 if (edid->revision >= 4)
994 hmax += ((t[4] & 0x08) ? 255 : 0);
Adam Jackson07a5e632009-12-03 17:44:38 -0500995 hsync = drm_mode_hsync(mode);
Adam Jackson07a5e632009-12-03 17:44:38 -0500996
Adam Jacksonb17e52e2010-03-29 21:43:27 +0000997 return (hsync <= hmax && hsync >= hmin);
998}
999
1000static bool
Chris Wilsonb1f559e2011-01-26 09:49:47 +00001001mode_in_vsync_range(const struct drm_display_mode *mode,
1002 struct edid *edid, u8 *t)
Adam Jacksonb17e52e2010-03-29 21:43:27 +00001003{
1004 int vsync, vmin, vmax;
1005
1006 vmin = t[5];
1007 if (edid->revision >= 4)
1008 vmin += ((t[4] & 0x01) ? 255 : 0);
1009 vmax = t[6];
1010 if (edid->revision >= 4)
1011 vmax += ((t[4] & 0x02) ? 255 : 0);
1012 vsync = drm_mode_vrefresh(mode);
1013
1014 return (vsync <= vmax && vsync >= vmin);
1015}
1016
1017static u32
1018range_pixel_clock(struct edid *edid, u8 *t)
1019{
1020 /* unspecified */
1021 if (t[9] == 0 || t[9] == 255)
1022 return 0;
1023
1024 /* 1.4 with CVT support gives us real precision, yay */
1025 if (edid->revision >= 4 && t[10] == 0x04)
1026 return (t[9] * 10000) - ((t[12] >> 2) * 250);
1027
1028 /* 1.3 is pathetic, so fuzz up a bit */
1029 return t[9] * 10000 + 5001;
1030}
1031
Adam Jackson07a5e632009-12-03 17:44:38 -05001032static bool
Chris Wilsonb1f559e2011-01-26 09:49:47 +00001033mode_in_range(const struct drm_display_mode *mode, struct edid *edid,
Adam Jacksonb17e52e2010-03-29 21:43:27 +00001034 struct detailed_timing *timing)
Adam Jackson07a5e632009-12-03 17:44:38 -05001035{
Adam Jacksonb17e52e2010-03-29 21:43:27 +00001036 u32 max_clock;
1037 u8 *t = (u8 *)timing;
Adam Jackson07a5e632009-12-03 17:44:38 -05001038
Adam Jacksonb17e52e2010-03-29 21:43:27 +00001039 if (!mode_in_hsync_range(mode, edid, t))
Adam Jackson07a5e632009-12-03 17:44:38 -05001040 return false;
1041
Adam Jacksonb17e52e2010-03-29 21:43:27 +00001042 if (!mode_in_vsync_range(mode, edid, t))
Adam Jackson07a5e632009-12-03 17:44:38 -05001043 return false;
1044
Adam Jacksonb17e52e2010-03-29 21:43:27 +00001045 if ((max_clock = range_pixel_clock(edid, t)))
Adam Jackson07a5e632009-12-03 17:44:38 -05001046 if (mode->clock > max_clock)
1047 return false;
Adam Jacksonb17e52e2010-03-29 21:43:27 +00001048
1049 /* 1.4 max horizontal check */
1050 if (edid->revision >= 4 && t[10] == 0x04)
1051 if (t[13] && mode->hdisplay > 8 * (t[13] + (256 * (t[12]&0x3))))
1052 return false;
1053
1054 if (mode_is_rb(mode) && !drm_monitor_supports_rb(edid))
1055 return false;
Adam Jackson07a5e632009-12-03 17:44:38 -05001056
1057 return true;
1058}
1059
Takashi Iwai7b668eb2012-07-03 11:22:11 +02001060static bool valid_inferred_mode(const struct drm_connector *connector,
1061 const struct drm_display_mode *mode)
1062{
1063 struct drm_display_mode *m;
1064 bool ok = false;
1065
1066 list_for_each_entry(m, &connector->probed_modes, head) {
1067 if (mode->hdisplay == m->hdisplay &&
1068 mode->vdisplay == m->vdisplay &&
1069 drm_mode_vrefresh(mode) == drm_mode_vrefresh(m))
1070 return false; /* duplicated */
1071 if (mode->hdisplay <= m->hdisplay &&
1072 mode->vdisplay <= m->vdisplay)
1073 ok = true;
1074 }
1075 return ok;
1076}
1077
Adam Jacksonb17e52e2010-03-29 21:43:27 +00001078static int
Adam Jacksoncd4cd3d2012-04-13 16:33:33 -04001079drm_dmt_modes_for_range(struct drm_connector *connector, struct edid *edid,
Adam Jacksonb17e52e2010-03-29 21:43:27 +00001080 struct detailed_timing *timing)
Adam Jackson07a5e632009-12-03 17:44:38 -05001081{
1082 int i, modes = 0;
1083 struct drm_display_mode *newmode;
1084 struct drm_device *dev = connector->dev;
1085
1086 for (i = 0; i < drm_num_dmt_modes; i++) {
Takashi Iwai7b668eb2012-07-03 11:22:11 +02001087 if (mode_in_range(drm_dmt_modes + i, edid, timing) &&
1088 valid_inferred_mode(connector, drm_dmt_modes + i)) {
Adam Jackson07a5e632009-12-03 17:44:38 -05001089 newmode = drm_mode_duplicate(dev, &drm_dmt_modes[i]);
1090 if (newmode) {
1091 drm_mode_probed_add(connector, newmode);
1092 modes++;
1093 }
1094 }
1095 }
1096
1097 return modes;
1098}
1099
Takashi Iwaic09dedb2012-04-23 17:40:33 +01001100/* fix up 1366x768 mode from 1368x768;
1101 * GFT/CVT can't express 1366 width which isn't dividable by 8
1102 */
1103static void fixup_mode_1366x768(struct drm_display_mode *mode)
1104{
1105 if (mode->hdisplay == 1368 && mode->vdisplay == 768) {
1106 mode->hdisplay = 1366;
1107 mode->hsync_start--;
1108 mode->hsync_end--;
1109 drm_mode_set_name(mode);
1110 }
1111}
1112
Adam Jacksonb309bd32012-04-13 16:33:40 -04001113static int
1114drm_gtf_modes_for_range(struct drm_connector *connector, struct edid *edid,
1115 struct detailed_timing *timing)
1116{
1117 int i, modes = 0;
1118 struct drm_display_mode *newmode;
1119 struct drm_device *dev = connector->dev;
1120
1121 for (i = 0; i < num_extra_modes; i++) {
1122 const struct minimode *m = &extra_modes[i];
1123 newmode = drm_gtf_mode(dev, m->w, m->h, m->r, 0, 0);
Takashi Iwaifc48f162012-04-20 12:59:33 +01001124 if (!newmode)
1125 return modes;
Adam Jacksonb309bd32012-04-13 16:33:40 -04001126
Takashi Iwaic09dedb2012-04-23 17:40:33 +01001127 fixup_mode_1366x768(newmode);
Takashi Iwai7b668eb2012-07-03 11:22:11 +02001128 if (!mode_in_range(newmode, edid, timing) ||
1129 !valid_inferred_mode(connector, newmode)) {
Adam Jacksonb309bd32012-04-13 16:33:40 -04001130 drm_mode_destroy(dev, newmode);
1131 continue;
1132 }
1133
1134 drm_mode_probed_add(connector, newmode);
1135 modes++;
1136 }
1137
1138 return modes;
1139}
1140
1141static int
1142drm_cvt_modes_for_range(struct drm_connector *connector, struct edid *edid,
1143 struct detailed_timing *timing)
1144{
1145 int i, modes = 0;
1146 struct drm_display_mode *newmode;
1147 struct drm_device *dev = connector->dev;
1148 bool rb = drm_monitor_supports_rb(edid);
1149
1150 for (i = 0; i < num_extra_modes; i++) {
1151 const struct minimode *m = &extra_modes[i];
1152 newmode = drm_cvt_mode(dev, m->w, m->h, m->r, rb, 0, 0);
Takashi Iwaifc48f162012-04-20 12:59:33 +01001153 if (!newmode)
1154 return modes;
Adam Jacksonb309bd32012-04-13 16:33:40 -04001155
Takashi Iwaic09dedb2012-04-23 17:40:33 +01001156 fixup_mode_1366x768(newmode);
Takashi Iwai7b668eb2012-07-03 11:22:11 +02001157 if (!mode_in_range(newmode, edid, timing) ||
1158 !valid_inferred_mode(connector, newmode)) {
Adam Jacksonb309bd32012-04-13 16:33:40 -04001159 drm_mode_destroy(dev, newmode);
1160 continue;
1161 }
1162
1163 drm_mode_probed_add(connector, newmode);
1164 modes++;
1165 }
1166
1167 return modes;
1168}
1169
Adam Jackson13931572010-08-03 14:38:19 -04001170static void
1171do_inferred_modes(struct detailed_timing *timing, void *c)
Adam Jackson9340d8c2009-12-03 17:44:40 -05001172{
Adam Jackson13931572010-08-03 14:38:19 -04001173 struct detailed_mode_closure *closure = c;
1174 struct detailed_non_pixel *data = &timing->data.other_data;
Adam Jacksonb309bd32012-04-13 16:33:40 -04001175 struct detailed_data_monitor_range *range = &data->data.range;
Adam Jackson9340d8c2009-12-03 17:44:40 -05001176
Adam Jacksoncb21aaf2012-04-13 16:33:36 -04001177 if (data->type != EDID_DETAIL_MONITOR_RANGE)
1178 return;
1179
1180 closure->modes += drm_dmt_modes_for_range(closure->connector,
1181 closure->edid,
1182 timing);
Adam Jacksonb309bd32012-04-13 16:33:40 -04001183
1184 if (!version_greater(closure->edid, 1, 1))
1185 return; /* GTF not defined yet */
1186
1187 switch (range->flags) {
1188 case 0x02: /* secondary gtf, XXX could do more */
1189 case 0x00: /* default gtf */
1190 closure->modes += drm_gtf_modes_for_range(closure->connector,
1191 closure->edid,
1192 timing);
1193 break;
1194 case 0x04: /* cvt, only in 1.4+ */
1195 if (!version_greater(closure->edid, 1, 3))
1196 break;
1197
1198 closure->modes += drm_cvt_modes_for_range(closure->connector,
1199 closure->edid,
1200 timing);
1201 break;
1202 case 0x01: /* just the ranges, no formula */
1203 default:
1204 break;
1205 }
Adam Jackson9340d8c2009-12-03 17:44:40 -05001206}
1207
Adam Jackson13931572010-08-03 14:38:19 -04001208static int
1209add_inferred_modes(struct drm_connector *connector, struct edid *edid)
1210{
1211 struct detailed_mode_closure closure = {
1212 connector, edid, 0, 0, 0
1213 };
1214
1215 if (version_greater(edid, 1, 0))
1216 drm_for_each_detailed_block((u8 *)edid, do_inferred_modes,
1217 &closure);
1218
1219 return closure.modes;
1220}
1221
Adam Jackson2255be12010-03-29 21:43:22 +00001222static int
1223drm_est3_modes(struct drm_connector *connector, struct detailed_timing *timing)
1224{
1225 int i, j, m, modes = 0;
1226 struct drm_display_mode *mode;
1227 u8 *est = ((u8 *)timing) + 5;
1228
1229 for (i = 0; i < 6; i++) {
1230 for (j = 7; j > 0; j--) {
1231 m = (i * 8) + (7 - j);
Linus Torvaldsaa9f56b2010-08-12 09:21:39 -07001232 if (m >= ARRAY_SIZE(est3_modes))
Adam Jackson2255be12010-03-29 21:43:22 +00001233 break;
1234 if (est[i] & (1 << j)) {
Dave Airlie1d42bbc2010-05-07 05:02:30 +00001235 mode = drm_mode_find_dmt(connector->dev,
1236 est3_modes[m].w,
1237 est3_modes[m].h,
Adam Jacksonf6e252b2012-04-13 16:33:31 -04001238 est3_modes[m].r,
1239 est3_modes[m].rb);
Adam Jackson2255be12010-03-29 21:43:22 +00001240 if (mode) {
1241 drm_mode_probed_add(connector, mode);
1242 modes++;
1243 }
1244 }
1245 }
1246 }
1247
1248 return modes;
1249}
1250
Adam Jackson13931572010-08-03 14:38:19 -04001251static void
1252do_established_modes(struct detailed_timing *timing, void *c)
Adam Jackson9cf00972009-12-03 17:44:36 -05001253{
Adam Jackson13931572010-08-03 14:38:19 -04001254 struct detailed_mode_closure *closure = c;
Adam Jackson9cf00972009-12-03 17:44:36 -05001255 struct detailed_non_pixel *data = &timing->data.other_data;
Adam Jackson13931572010-08-03 14:38:19 -04001256
1257 if (data->type == EDID_DETAIL_EST_TIMINGS)
1258 closure->modes += drm_est3_modes(closure->connector, timing);
1259}
1260
1261/**
1262 * add_established_modes - get est. modes from EDID and add them
1263 * @edid: EDID block to scan
1264 *
1265 * Each EDID block contains a bitmap of the supported "established modes" list
1266 * (defined above). Tease them out and add them to the global modes list.
1267 */
1268static int
1269add_established_modes(struct drm_connector *connector, struct edid *edid)
1270{
Adam Jackson9cf00972009-12-03 17:44:36 -05001271 struct drm_device *dev = connector->dev;
Adam Jackson13931572010-08-03 14:38:19 -04001272 unsigned long est_bits = edid->established_timings.t1 |
1273 (edid->established_timings.t2 << 8) |
1274 ((edid->established_timings.mfg_rsvd & 0x80) << 9);
1275 int i, modes = 0;
1276 struct detailed_mode_closure closure = {
1277 connector, edid, 0, 0, 0
1278 };
Adam Jackson9cf00972009-12-03 17:44:36 -05001279
Adam Jackson13931572010-08-03 14:38:19 -04001280 for (i = 0; i <= EDID_EST_TIMINGS; i++) {
1281 if (est_bits & (1<<i)) {
1282 struct drm_display_mode *newmode;
1283 newmode = drm_mode_duplicate(dev, &edid_est_modes[i]);
1284 if (newmode) {
1285 drm_mode_probed_add(connector, newmode);
1286 modes++;
1287 }
1288 }
Adam Jackson9cf00972009-12-03 17:44:36 -05001289 }
1290
Adam Jackson13931572010-08-03 14:38:19 -04001291 if (version_greater(edid, 1, 0))
1292 drm_for_each_detailed_block((u8 *)edid,
1293 do_established_modes, &closure);
1294
1295 return modes + closure.modes;
1296}
1297
1298static void
1299do_standard_modes(struct detailed_timing *timing, void *c)
1300{
1301 struct detailed_mode_closure *closure = c;
1302 struct detailed_non_pixel *data = &timing->data.other_data;
1303 struct drm_connector *connector = closure->connector;
1304 struct edid *edid = closure->edid;
1305
1306 if (data->type == EDID_DETAIL_STD_MODES) {
1307 int i;
Adam Jackson9cf00972009-12-03 17:44:36 -05001308 for (i = 0; i < 6; i++) {
1309 struct std_timing *std;
1310 struct drm_display_mode *newmode;
1311
1312 std = &data->data.timings[i];
Adam Jackson7a374352010-03-29 21:43:30 +00001313 newmode = drm_mode_std(connector, edid, std,
1314 edid->revision);
Adam Jackson9cf00972009-12-03 17:44:36 -05001315 if (newmode) {
1316 drm_mode_probed_add(connector, newmode);
Adam Jackson13931572010-08-03 14:38:19 -04001317 closure->modes++;
Adam Jackson9cf00972009-12-03 17:44:36 -05001318 }
1319 }
Adam Jackson13931572010-08-03 14:38:19 -04001320 }
1321}
1322
1323/**
1324 * add_standard_modes - get std. modes from EDID and add them
1325 * @edid: EDID block to scan
1326 *
1327 * Standard modes can be calculated using the appropriate standard (DMT,
1328 * GTF or CVT. Grab them from @edid and add them to the list.
1329 */
1330static int
1331add_standard_modes(struct drm_connector *connector, struct edid *edid)
1332{
1333 int i, modes = 0;
1334 struct detailed_mode_closure closure = {
1335 connector, edid, 0, 0, 0
1336 };
1337
1338 for (i = 0; i < EDID_STD_TIMINGS; i++) {
1339 struct drm_display_mode *newmode;
1340
1341 newmode = drm_mode_std(connector, edid,
1342 &edid->standard_timings[i],
1343 edid->revision);
1344 if (newmode) {
1345 drm_mode_probed_add(connector, newmode);
1346 modes++;
1347 }
1348 }
1349
1350 if (version_greater(edid, 1, 0))
1351 drm_for_each_detailed_block((u8 *)edid, do_standard_modes,
1352 &closure);
1353
1354 /* XXX should also look for standard codes in VTB blocks */
1355
1356 return modes + closure.modes;
1357}
1358
Dave Airlief453ba02008-11-07 14:05:41 -08001359static int drm_cvt_modes(struct drm_connector *connector,
1360 struct detailed_timing *timing)
1361{
1362 int i, j, modes = 0;
1363 struct drm_display_mode *newmode;
1364 struct drm_device *dev = connector->dev;
Zhao Yakui5c612592009-06-22 13:17:10 +08001365 struct cvt_timing *cvt;
1366 const int rates[] = { 60, 85, 75, 60, 50 };
1367 const u8 empty[3] = { 0, 0, 0 };
Dave Airlief453ba02008-11-07 14:05:41 -08001368
1369 for (i = 0; i < 4; i++) {
1370 int uninitialized_var(width), height;
1371 cvt = &(timing->data.other_data.data.cvt[i]);
1372
1373 if (!memcmp(cvt->code, empty, 3))
Michel Dänzer0454bea2009-06-15 16:56:07 +02001374 continue;
Dave Airlief453ba02008-11-07 14:05:41 -08001375
1376 height = (cvt->code[0] + ((cvt->code[1] & 0xf0) << 4) + 1) * 2;
Zhao Yakui5c612592009-06-22 13:17:10 +08001377 switch (cvt->code[1] & 0x0c) {
Adam Jacksonf066a172009-09-23 17:31:21 -04001378 case 0x00:
Dave Airlief453ba02008-11-07 14:05:41 -08001379 width = height * 4 / 3;
1380 break;
1381 case 0x04:
1382 width = height * 16 / 9;
1383 break;
1384 case 0x08:
1385 width = height * 16 / 10;
1386 break;
1387 case 0x0c:
Dave Airlief453ba02008-11-07 14:05:41 -08001388 width = height * 15 / 9;
1389 break;
1390 }
1391
1392 for (j = 1; j < 5; j++) {
1393 if (cvt->code[2] & (1 << j)) {
1394 newmode = drm_cvt_mode(dev, width, height,
1395 rates[j], j == 0,
1396 false, false);
1397 if (newmode) {
1398 drm_mode_probed_add(connector, newmode);
1399 modes++;
1400 }
1401 }
1402 }
1403 }
1404
1405 return modes;
1406}
1407
Adam Jackson13931572010-08-03 14:38:19 -04001408static void
1409do_cvt_mode(struct detailed_timing *timing, void *c)
1410{
1411 struct detailed_mode_closure *closure = c;
1412 struct detailed_non_pixel *data = &timing->data.other_data;
1413
1414 if (data->type == EDID_DETAIL_CVT_3BYTE)
1415 closure->modes += drm_cvt_modes(closure->connector, timing);
1416}
Adam Jackson9cf00972009-12-03 17:44:36 -05001417
1418static int
Adam Jackson13931572010-08-03 14:38:19 -04001419add_cvt_modes(struct drm_connector *connector, struct edid *edid)
1420{
1421 struct detailed_mode_closure closure = {
1422 connector, edid, 0, 0, 0
1423 };
Adam Jackson9cf00972009-12-03 17:44:36 -05001424
Adam Jackson13931572010-08-03 14:38:19 -04001425 if (version_greater(edid, 1, 2))
1426 drm_for_each_detailed_block((u8 *)edid, do_cvt_mode, &closure);
Dave Airlief453ba02008-11-07 14:05:41 -08001427
Adam Jackson13931572010-08-03 14:38:19 -04001428 /* XXX should also look for CVT codes in VTB blocks */
1429
1430 return closure.modes;
Dave Airlief453ba02008-11-07 14:05:41 -08001431}
1432
Adam Jackson13931572010-08-03 14:38:19 -04001433static void
1434do_detailed_mode(struct detailed_timing *timing, void *c)
Dave Airlief453ba02008-11-07 14:05:41 -08001435{
Adam Jackson13931572010-08-03 14:38:19 -04001436 struct detailed_mode_closure *closure = c;
Dave Airlief453ba02008-11-07 14:05:41 -08001437 struct drm_display_mode *newmode;
Adam Jackson9cf00972009-12-03 17:44:36 -05001438
1439 if (timing->pixel_clock) {
Adam Jackson13931572010-08-03 14:38:19 -04001440 newmode = drm_mode_detailed(closure->connector->dev,
1441 closure->edid, timing,
1442 closure->quirks);
Dave Airlief453ba02008-11-07 14:05:41 -08001443 if (!newmode)
Adam Jackson13931572010-08-03 14:38:19 -04001444 return;
Adam Jackson9cf00972009-12-03 17:44:36 -05001445
Adam Jackson13931572010-08-03 14:38:19 -04001446 if (closure->preferred)
Dave Airlief453ba02008-11-07 14:05:41 -08001447 newmode->type |= DRM_MODE_TYPE_PREFERRED;
1448
Adam Jackson13931572010-08-03 14:38:19 -04001449 drm_mode_probed_add(closure->connector, newmode);
1450 closure->modes++;
1451 closure->preferred = 0;
Zhao Yakui882f0212009-08-26 18:20:49 +08001452 }
Ma Ling167f3a02009-03-20 14:09:48 +08001453}
1454
Adam Jackson13931572010-08-03 14:38:19 -04001455/*
1456 * add_detailed_modes - Add modes from detailed timings
Dave Airlief453ba02008-11-07 14:05:41 -08001457 * @connector: attached connector
1458 * @edid: EDID block to scan
1459 * @quirks: quirks to apply
Dave Airlief453ba02008-11-07 14:05:41 -08001460 */
Adam Jackson13931572010-08-03 14:38:19 -04001461static int
1462add_detailed_modes(struct drm_connector *connector, struct edid *edid,
1463 u32 quirks)
Dave Airlief453ba02008-11-07 14:05:41 -08001464{
Adam Jackson13931572010-08-03 14:38:19 -04001465 struct detailed_mode_closure closure = {
1466 connector,
1467 edid,
1468 1,
1469 quirks,
1470 0
1471 };
Dave Airlief453ba02008-11-07 14:05:41 -08001472
Adam Jackson13931572010-08-03 14:38:19 -04001473 if (closure.preferred && !version_greater(edid, 1, 3))
1474 closure.preferred =
1475 (edid->features & DRM_EDID_FEATURE_PREFERRED_TIMING);
Adam Jacksona327f6b2010-03-29 21:43:25 +00001476
Adam Jackson13931572010-08-03 14:38:19 -04001477 drm_for_each_detailed_block((u8 *)edid, do_detailed_mode, &closure);
Dave Airlief453ba02008-11-07 14:05:41 -08001478
Adam Jackson13931572010-08-03 14:38:19 -04001479 return closure.modes;
Zhao Yakui882f0212009-08-26 18:20:49 +08001480}
Dave Airlief453ba02008-11-07 14:05:41 -08001481
Ma Lingf23c20c2009-03-26 19:26:23 +08001482#define HDMI_IDENTIFIER 0x000C03
Zhenyu Wang8fe97902010-09-19 14:27:28 +08001483#define AUDIO_BLOCK 0x01
Christian Schmidt54ac76f2011-12-19 14:53:16 +00001484#define VIDEO_BLOCK 0x02
Ma Lingf23c20c2009-03-26 19:26:23 +08001485#define VENDOR_BLOCK 0x03
Wu Fengguang76adaa342011-09-05 14:23:20 +08001486#define SPEAKER_BLOCK 0x04
Ville Syrjäläb1edd6a2013-01-17 16:31:30 +02001487#define VIDEO_CAPABILITY_BLOCK 0x07
Zhenyu Wang8fe97902010-09-19 14:27:28 +08001488#define EDID_BASIC_AUDIO (1 << 6)
Lars-Peter Clausena988bc72012-04-16 15:16:19 +02001489#define EDID_CEA_YCRCB444 (1 << 5)
1490#define EDID_CEA_YCRCB422 (1 << 4)
Ville Syrjäläb1edd6a2013-01-17 16:31:30 +02001491#define EDID_CEA_VCDB_QS (1 << 6)
Zhenyu Wang8fe97902010-09-19 14:27:28 +08001492
1493/**
1494 * Search EDID for CEA extension block.
1495 */
Ben Skeggseccaca22011-03-30 05:03:47 +00001496u8 *drm_find_cea_extension(struct edid *edid)
Zhenyu Wang8fe97902010-09-19 14:27:28 +08001497{
1498 u8 *edid_ext = NULL;
1499 int i;
1500
1501 /* No EDID or EDID extensions */
1502 if (edid == NULL || edid->extensions == 0)
1503 return NULL;
1504
1505 /* Find CEA extension */
1506 for (i = 0; i < edid->extensions; i++) {
1507 edid_ext = (u8 *)edid + EDID_LENGTH * (i + 1);
1508 if (edid_ext[0] == CEA_EXT)
1509 break;
1510 }
1511
1512 if (i == edid->extensions)
1513 return NULL;
1514
1515 return edid_ext;
1516}
Ben Skeggseccaca22011-03-30 05:03:47 +00001517EXPORT_SYMBOL(drm_find_cea_extension);
Zhenyu Wang8fe97902010-09-19 14:27:28 +08001518
Stephane Marchesina4799032012-11-09 16:21:05 +00001519/*
1520 * Looks for a CEA mode matching given drm_display_mode.
1521 * Returns its CEA Video ID code, or 0 if not found.
1522 */
1523u8 drm_match_cea_mode(struct drm_display_mode *to_match)
1524{
1525 struct drm_display_mode *cea_mode;
1526 u8 mode;
1527
1528 for (mode = 0; mode < drm_num_cea_modes; mode++) {
1529 cea_mode = (struct drm_display_mode *)&edid_cea_modes[mode];
1530
1531 if (drm_mode_equal(to_match, cea_mode))
1532 return mode + 1;
1533 }
1534 return 0;
1535}
1536EXPORT_SYMBOL(drm_match_cea_mode);
1537
1538
Christian Schmidt54ac76f2011-12-19 14:53:16 +00001539static int
1540do_cea_modes (struct drm_connector *connector, u8 *db, u8 len)
1541{
1542 struct drm_device *dev = connector->dev;
1543 u8 * mode, cea_mode;
1544 int modes = 0;
1545
1546 for (mode = db; mode < db + len; mode++) {
1547 cea_mode = (*mode & 127) - 1; /* CEA modes are numbered 1..127 */
1548 if (cea_mode < drm_num_cea_modes) {
1549 struct drm_display_mode *newmode;
1550 newmode = drm_mode_duplicate(dev,
1551 &edid_cea_modes[cea_mode]);
1552 if (newmode) {
1553 drm_mode_probed_add(connector, newmode);
1554 modes++;
1555 }
1556 }
1557 }
1558
1559 return modes;
1560}
1561
1562static int
Ville Syrjälä9e50b9d2012-08-16 14:55:04 +00001563cea_db_payload_len(const u8 *db)
1564{
1565 return db[0] & 0x1f;
1566}
1567
1568static int
1569cea_db_tag(const u8 *db)
1570{
1571 return db[0] >> 5;
1572}
1573
1574static int
1575cea_revision(const u8 *cea)
1576{
1577 return cea[1];
1578}
1579
1580static int
1581cea_db_offsets(const u8 *cea, int *start, int *end)
1582{
1583 /* Data block offset in CEA extension block */
1584 *start = 4;
1585 *end = cea[2];
1586 if (*end == 0)
1587 *end = 127;
1588 if (*end < 4 || *end > 127)
1589 return -ERANGE;
1590 return 0;
1591}
1592
1593#define for_each_cea_db(cea, i, start, end) \
1594 for ((i) = (start); (i) < (end) && (i) + cea_db_payload_len(&(cea)[(i)]) < (end); (i) += cea_db_payload_len(&(cea)[(i)]) + 1)
1595
1596static int
Christian Schmidt54ac76f2011-12-19 14:53:16 +00001597add_cea_modes(struct drm_connector *connector, struct edid *edid)
1598{
1599 u8 * cea = drm_find_cea_extension(edid);
1600 u8 * db, dbl;
1601 int modes = 0;
1602
Ville Syrjälä9e50b9d2012-08-16 14:55:04 +00001603 if (cea && cea_revision(cea) >= 3) {
1604 int i, start, end;
1605
1606 if (cea_db_offsets(cea, &start, &end))
1607 return 0;
1608
1609 for_each_cea_db(cea, i, start, end) {
1610 db = &cea[i];
1611 dbl = cea_db_payload_len(db);
1612
1613 if (cea_db_tag(db) == VIDEO_BLOCK)
Christian Schmidt54ac76f2011-12-19 14:53:16 +00001614 modes += do_cea_modes (connector, db+1, dbl);
1615 }
1616 }
1617
1618 return modes;
1619}
1620
Wu Fengguang76adaa342011-09-05 14:23:20 +08001621static void
Ville Syrjälä85040722012-08-16 14:55:05 +00001622parse_hdmi_vsdb(struct drm_connector *connector, const u8 *db)
Wu Fengguang76adaa342011-09-05 14:23:20 +08001623{
Ville Syrjälä85040722012-08-16 14:55:05 +00001624 u8 len = cea_db_payload_len(db);
Wu Fengguang76adaa342011-09-05 14:23:20 +08001625
Ville Syrjälä85040722012-08-16 14:55:05 +00001626 if (len >= 6) {
1627 connector->eld[5] |= (db[6] >> 7) << 1; /* Supports_AI */
1628 connector->dvi_dual = db[6] & 1;
1629 }
1630 if (len >= 7)
1631 connector->max_tmds_clock = db[7] * 5;
1632 if (len >= 8) {
1633 connector->latency_present[0] = db[8] >> 7;
1634 connector->latency_present[1] = (db[8] >> 6) & 1;
1635 }
1636 if (len >= 9)
1637 connector->video_latency[0] = db[9];
1638 if (len >= 10)
1639 connector->audio_latency[0] = db[10];
1640 if (len >= 11)
1641 connector->video_latency[1] = db[11];
1642 if (len >= 12)
1643 connector->audio_latency[1] = db[12];
Wu Fengguang76adaa342011-09-05 14:23:20 +08001644
Daniel Vetter670c1ef2012-11-22 09:53:55 +01001645 DRM_DEBUG_KMS("HDMI: DVI dual %d, "
Wu Fengguang76adaa342011-09-05 14:23:20 +08001646 "max TMDS clock %d, "
1647 "latency present %d %d, "
1648 "video latency %d %d, "
1649 "audio latency %d %d\n",
1650 connector->dvi_dual,
1651 connector->max_tmds_clock,
1652 (int) connector->latency_present[0],
1653 (int) connector->latency_present[1],
1654 connector->video_latency[0],
1655 connector->video_latency[1],
1656 connector->audio_latency[0],
1657 connector->audio_latency[1]);
1658}
1659
1660static void
1661monitor_name(struct detailed_timing *t, void *data)
1662{
1663 if (t->data.other_data.type == EDID_DETAIL_MONITOR_NAME)
1664 *(u8 **)data = t->data.other_data.data.str.str;
1665}
1666
Ville Syrjälä14f77fd2012-08-16 14:55:06 +00001667static bool cea_db_is_hdmi_vsdb(const u8 *db)
1668{
1669 int hdmi_id;
1670
1671 if (cea_db_tag(db) != VENDOR_BLOCK)
1672 return false;
1673
1674 if (cea_db_payload_len(db) < 5)
1675 return false;
1676
1677 hdmi_id = db[1] | (db[2] << 8) | (db[3] << 16);
1678
1679 return hdmi_id == HDMI_IDENTIFIER;
1680}
1681
Wu Fengguang76adaa342011-09-05 14:23:20 +08001682/**
1683 * drm_edid_to_eld - build ELD from EDID
1684 * @connector: connector corresponding to the HDMI/DP sink
1685 * @edid: EDID to parse
1686 *
1687 * Fill the ELD (EDID-Like Data) buffer for passing to the audio driver.
1688 * Some ELD fields are left to the graphics driver caller:
1689 * - Conn_Type
1690 * - HDCP
1691 * - Port_ID
1692 */
1693void drm_edid_to_eld(struct drm_connector *connector, struct edid *edid)
1694{
1695 uint8_t *eld = connector->eld;
1696 u8 *cea;
1697 u8 *name;
1698 u8 *db;
1699 int sad_count = 0;
1700 int mnl;
1701 int dbl;
1702
1703 memset(eld, 0, sizeof(connector->eld));
1704
1705 cea = drm_find_cea_extension(edid);
1706 if (!cea) {
1707 DRM_DEBUG_KMS("ELD: no CEA Extension found\n");
1708 return;
1709 }
1710
1711 name = NULL;
1712 drm_for_each_detailed_block((u8 *)edid, monitor_name, &name);
1713 for (mnl = 0; name && mnl < 13; mnl++) {
1714 if (name[mnl] == 0x0a)
1715 break;
1716 eld[20 + mnl] = name[mnl];
1717 }
1718 eld[4] = (cea[1] << 5) | mnl;
1719 DRM_DEBUG_KMS("ELD monitor %s\n", eld + 20);
1720
1721 eld[0] = 2 << 3; /* ELD version: 2 */
1722
1723 eld[16] = edid->mfg_id[0];
1724 eld[17] = edid->mfg_id[1];
1725 eld[18] = edid->prod_code[0];
1726 eld[19] = edid->prod_code[1];
1727
Ville Syrjälä9e50b9d2012-08-16 14:55:04 +00001728 if (cea_revision(cea) >= 3) {
1729 int i, start, end;
1730
1731 if (cea_db_offsets(cea, &start, &end)) {
1732 start = 0;
1733 end = 0;
1734 }
1735
1736 for_each_cea_db(cea, i, start, end) {
1737 db = &cea[i];
1738 dbl = cea_db_payload_len(db);
1739
1740 switch (cea_db_tag(db)) {
Christian Schmidta0ab7342011-12-19 20:03:38 +01001741 case AUDIO_BLOCK:
1742 /* Audio Data Block, contains SADs */
1743 sad_count = dbl / 3;
Ville Syrjälä9e50b9d2012-08-16 14:55:04 +00001744 if (dbl >= 1)
1745 memcpy(eld + 20 + mnl, &db[1], dbl);
Christian Schmidta0ab7342011-12-19 20:03:38 +01001746 break;
1747 case SPEAKER_BLOCK:
Ville Syrjälä9e50b9d2012-08-16 14:55:04 +00001748 /* Speaker Allocation Data Block */
1749 if (dbl >= 1)
1750 eld[7] = db[1];
Christian Schmidta0ab7342011-12-19 20:03:38 +01001751 break;
1752 case VENDOR_BLOCK:
1753 /* HDMI Vendor-Specific Data Block */
Ville Syrjälä14f77fd2012-08-16 14:55:06 +00001754 if (cea_db_is_hdmi_vsdb(db))
Christian Schmidta0ab7342011-12-19 20:03:38 +01001755 parse_hdmi_vsdb(connector, db);
1756 break;
1757 default:
1758 break;
1759 }
Wu Fengguang76adaa342011-09-05 14:23:20 +08001760 }
Ville Syrjälä9e50b9d2012-08-16 14:55:04 +00001761 }
Wu Fengguang76adaa342011-09-05 14:23:20 +08001762 eld[5] |= sad_count << 4;
1763 eld[2] = (20 + mnl + sad_count * 3 + 3) / 4;
1764
1765 DRM_DEBUG_KMS("ELD size %d, SAD count %d\n", (int)eld[2], sad_count);
1766}
1767EXPORT_SYMBOL(drm_edid_to_eld);
1768
1769/**
1770 * drm_av_sync_delay - HDMI/DP sink audio-video sync delay in millisecond
1771 * @connector: connector associated with the HDMI/DP sink
1772 * @mode: the display mode
1773 */
1774int drm_av_sync_delay(struct drm_connector *connector,
1775 struct drm_display_mode *mode)
1776{
1777 int i = !!(mode->flags & DRM_MODE_FLAG_INTERLACE);
1778 int a, v;
1779
1780 if (!connector->latency_present[0])
1781 return 0;
1782 if (!connector->latency_present[1])
1783 i = 0;
1784
1785 a = connector->audio_latency[i];
1786 v = connector->video_latency[i];
1787
1788 /*
1789 * HDMI/DP sink doesn't support audio or video?
1790 */
1791 if (a == 255 || v == 255)
1792 return 0;
1793
1794 /*
1795 * Convert raw EDID values to millisecond.
1796 * Treat unknown latency as 0ms.
1797 */
1798 if (a)
1799 a = min(2 * (a - 1), 500);
1800 if (v)
1801 v = min(2 * (v - 1), 500);
1802
1803 return max(v - a, 0);
1804}
1805EXPORT_SYMBOL(drm_av_sync_delay);
1806
1807/**
1808 * drm_select_eld - select one ELD from multiple HDMI/DP sinks
1809 * @encoder: the encoder just changed display mode
1810 * @mode: the adjusted display mode
1811 *
1812 * It's possible for one encoder to be associated with multiple HDMI/DP sinks.
1813 * The policy is now hard coded to simply use the first HDMI/DP sink's ELD.
1814 */
1815struct drm_connector *drm_select_eld(struct drm_encoder *encoder,
1816 struct drm_display_mode *mode)
1817{
1818 struct drm_connector *connector;
1819 struct drm_device *dev = encoder->dev;
1820
1821 list_for_each_entry(connector, &dev->mode_config.connector_list, head)
1822 if (connector->encoder == encoder && connector->eld[0])
1823 return connector;
1824
1825 return NULL;
1826}
1827EXPORT_SYMBOL(drm_select_eld);
1828
Ma Lingf23c20c2009-03-26 19:26:23 +08001829/**
1830 * drm_detect_hdmi_monitor - detect whether monitor is hdmi.
1831 * @edid: monitor EDID information
1832 *
1833 * Parse the CEA extension according to CEA-861-B.
1834 * Return true if HDMI, false if not or unknown.
1835 */
1836bool drm_detect_hdmi_monitor(struct edid *edid)
1837{
Zhenyu Wang8fe97902010-09-19 14:27:28 +08001838 u8 *edid_ext;
Ville Syrjälä14f77fd2012-08-16 14:55:06 +00001839 int i;
Ma Lingf23c20c2009-03-26 19:26:23 +08001840 int start_offset, end_offset;
Ma Lingf23c20c2009-03-26 19:26:23 +08001841
Zhenyu Wang8fe97902010-09-19 14:27:28 +08001842 edid_ext = drm_find_cea_extension(edid);
1843 if (!edid_ext)
Ville Syrjälä14f77fd2012-08-16 14:55:06 +00001844 return false;
Ma Lingf23c20c2009-03-26 19:26:23 +08001845
Ville Syrjälä9e50b9d2012-08-16 14:55:04 +00001846 if (cea_db_offsets(edid_ext, &start_offset, &end_offset))
Ville Syrjälä14f77fd2012-08-16 14:55:06 +00001847 return false;
Ma Lingf23c20c2009-03-26 19:26:23 +08001848
1849 /*
1850 * Because HDMI identifier is in Vendor Specific Block,
1851 * search it from all data blocks of CEA extension.
1852 */
Ville Syrjälä9e50b9d2012-08-16 14:55:04 +00001853 for_each_cea_db(edid_ext, i, start_offset, end_offset) {
Ville Syrjälä14f77fd2012-08-16 14:55:06 +00001854 if (cea_db_is_hdmi_vsdb(&edid_ext[i]))
1855 return true;
Ma Lingf23c20c2009-03-26 19:26:23 +08001856 }
1857
Ville Syrjälä14f77fd2012-08-16 14:55:06 +00001858 return false;
Ma Lingf23c20c2009-03-26 19:26:23 +08001859}
1860EXPORT_SYMBOL(drm_detect_hdmi_monitor);
1861
Dave Airlief453ba02008-11-07 14:05:41 -08001862/**
Zhenyu Wang8fe97902010-09-19 14:27:28 +08001863 * drm_detect_monitor_audio - check monitor audio capability
1864 *
1865 * Monitor should have CEA extension block.
1866 * If monitor has 'basic audio', but no CEA audio blocks, it's 'basic
1867 * audio' only. If there is any audio extension block and supported
1868 * audio format, assume at least 'basic audio' support, even if 'basic
1869 * audio' is not defined in EDID.
1870 *
1871 */
1872bool drm_detect_monitor_audio(struct edid *edid)
1873{
1874 u8 *edid_ext;
1875 int i, j;
1876 bool has_audio = false;
1877 int start_offset, end_offset;
1878
1879 edid_ext = drm_find_cea_extension(edid);
1880 if (!edid_ext)
1881 goto end;
1882
1883 has_audio = ((edid_ext[3] & EDID_BASIC_AUDIO) != 0);
1884
1885 if (has_audio) {
1886 DRM_DEBUG_KMS("Monitor has basic audio support\n");
1887 goto end;
1888 }
1889
Ville Syrjälä9e50b9d2012-08-16 14:55:04 +00001890 if (cea_db_offsets(edid_ext, &start_offset, &end_offset))
1891 goto end;
Zhenyu Wang8fe97902010-09-19 14:27:28 +08001892
Ville Syrjälä9e50b9d2012-08-16 14:55:04 +00001893 for_each_cea_db(edid_ext, i, start_offset, end_offset) {
1894 if (cea_db_tag(&edid_ext[i]) == AUDIO_BLOCK) {
Zhenyu Wang8fe97902010-09-19 14:27:28 +08001895 has_audio = true;
Ville Syrjälä9e50b9d2012-08-16 14:55:04 +00001896 for (j = 1; j < cea_db_payload_len(&edid_ext[i]) + 1; j += 3)
Zhenyu Wang8fe97902010-09-19 14:27:28 +08001897 DRM_DEBUG_KMS("CEA audio format %d\n",
1898 (edid_ext[i + j] >> 3) & 0xf);
1899 goto end;
1900 }
1901 }
1902end:
1903 return has_audio;
1904}
1905EXPORT_SYMBOL(drm_detect_monitor_audio);
1906
1907/**
Ville Syrjäläb1edd6a2013-01-17 16:31:30 +02001908 * drm_rgb_quant_range_selectable - is RGB quantization range selectable?
1909 *
1910 * Check whether the monitor reports the RGB quantization range selection
1911 * as supported. The AVI infoframe can then be used to inform the monitor
1912 * which quantization range (full or limited) is used.
1913 */
1914bool drm_rgb_quant_range_selectable(struct edid *edid)
1915{
1916 u8 *edid_ext;
1917 int i, start, end;
1918
1919 edid_ext = drm_find_cea_extension(edid);
1920 if (!edid_ext)
1921 return false;
1922
1923 if (cea_db_offsets(edid_ext, &start, &end))
1924 return false;
1925
1926 for_each_cea_db(edid_ext, i, start, end) {
1927 if (cea_db_tag(&edid_ext[i]) == VIDEO_CAPABILITY_BLOCK &&
1928 cea_db_payload_len(&edid_ext[i]) == 2) {
1929 DRM_DEBUG_KMS("CEA VCDB 0x%02x\n", edid_ext[i + 2]);
1930 return edid_ext[i + 2] & EDID_CEA_VCDB_QS;
1931 }
1932 }
1933
1934 return false;
1935}
1936EXPORT_SYMBOL(drm_rgb_quant_range_selectable);
1937
1938/**
Jesse Barnes3b112282011-04-15 12:49:23 -07001939 * drm_add_display_info - pull display info out if present
1940 * @edid: EDID data
1941 * @info: display info (attached to connector)
1942 *
1943 * Grab any available display info and stuff it into the drm_display_info
1944 * structure that's part of the connector. Useful for tracking bpp and
1945 * color spaces.
1946 */
1947static void drm_add_display_info(struct edid *edid,
1948 struct drm_display_info *info)
1949{
Jesse Barnesebec9a7b2011-08-03 09:22:54 -07001950 u8 *edid_ext;
1951
Jesse Barnes3b112282011-04-15 12:49:23 -07001952 info->width_mm = edid->width_cm * 10;
1953 info->height_mm = edid->height_cm * 10;
1954
1955 /* driver figures it out in this case */
1956 info->bpc = 0;
Jesse Barnesda05a5a72011-04-15 13:48:57 -07001957 info->color_formats = 0;
Jesse Barnes3b112282011-04-15 12:49:23 -07001958
Lars-Peter Clausena988bc72012-04-16 15:16:19 +02001959 if (edid->revision < 3)
Jesse Barnes3b112282011-04-15 12:49:23 -07001960 return;
1961
1962 if (!(edid->input & DRM_EDID_INPUT_DIGITAL))
1963 return;
1964
Lars-Peter Clausena988bc72012-04-16 15:16:19 +02001965 /* Get data from CEA blocks if present */
1966 edid_ext = drm_find_cea_extension(edid);
1967 if (edid_ext) {
1968 info->cea_rev = edid_ext[1];
1969
1970 /* The existence of a CEA block should imply RGB support */
1971 info->color_formats = DRM_COLOR_FORMAT_RGB444;
1972 if (edid_ext[3] & EDID_CEA_YCRCB444)
1973 info->color_formats |= DRM_COLOR_FORMAT_YCRCB444;
1974 if (edid_ext[3] & EDID_CEA_YCRCB422)
1975 info->color_formats |= DRM_COLOR_FORMAT_YCRCB422;
1976 }
1977
1978 /* Only defined for 1.4 with digital displays */
1979 if (edid->revision < 4)
1980 return;
1981
Jesse Barnes3b112282011-04-15 12:49:23 -07001982 switch (edid->input & DRM_EDID_DIGITAL_DEPTH_MASK) {
1983 case DRM_EDID_DIGITAL_DEPTH_6:
1984 info->bpc = 6;
1985 break;
1986 case DRM_EDID_DIGITAL_DEPTH_8:
1987 info->bpc = 8;
1988 break;
1989 case DRM_EDID_DIGITAL_DEPTH_10:
1990 info->bpc = 10;
1991 break;
1992 case DRM_EDID_DIGITAL_DEPTH_12:
1993 info->bpc = 12;
1994 break;
1995 case DRM_EDID_DIGITAL_DEPTH_14:
1996 info->bpc = 14;
1997 break;
1998 case DRM_EDID_DIGITAL_DEPTH_16:
1999 info->bpc = 16;
2000 break;
2001 case DRM_EDID_DIGITAL_DEPTH_UNDEF:
2002 default:
2003 info->bpc = 0;
2004 break;
2005 }
Jesse Barnesda05a5a72011-04-15 13:48:57 -07002006
Lars-Peter Clausena988bc72012-04-16 15:16:19 +02002007 info->color_formats |= DRM_COLOR_FORMAT_RGB444;
Lars-Peter Clausenee588082012-04-16 15:16:18 +02002008 if (edid->features & DRM_EDID_FEATURE_RGB_YCRCB444)
2009 info->color_formats |= DRM_COLOR_FORMAT_YCRCB444;
2010 if (edid->features & DRM_EDID_FEATURE_RGB_YCRCB422)
2011 info->color_formats |= DRM_COLOR_FORMAT_YCRCB422;
Jesse Barnes3b112282011-04-15 12:49:23 -07002012}
2013
2014/**
Dave Airlief453ba02008-11-07 14:05:41 -08002015 * drm_add_edid_modes - add modes from EDID data, if available
2016 * @connector: connector we're probing
2017 * @edid: edid data
2018 *
2019 * Add the specified modes to the connector's mode list.
2020 *
2021 * Return number of modes added or 0 if we couldn't find any.
2022 */
2023int drm_add_edid_modes(struct drm_connector *connector, struct edid *edid)
2024{
2025 int num_modes = 0;
2026 u32 quirks;
2027
2028 if (edid == NULL) {
2029 return 0;
2030 }
Alex Deucher3c537882010-02-05 04:21:19 -05002031 if (!drm_edid_is_valid(edid)) {
Jordan Crousedcdb1672010-05-27 13:40:25 -06002032 dev_warn(connector->dev->dev, "%s: EDID invalid.\n",
Dave Airlief453ba02008-11-07 14:05:41 -08002033 drm_get_connector_name(connector));
2034 return 0;
2035 }
2036
2037 quirks = edid_get_quirks(edid);
2038
Adam Jacksonc867df72010-03-29 21:43:21 +00002039 /*
2040 * EDID spec says modes should be preferred in this order:
2041 * - preferred detailed mode
2042 * - other detailed modes from base block
2043 * - detailed modes from extension blocks
2044 * - CVT 3-byte code modes
2045 * - standard timing codes
2046 * - established timing codes
2047 * - modes inferred from GTF or CVT range information
2048 *
Adam Jackson13931572010-08-03 14:38:19 -04002049 * We get this pretty much right.
Adam Jacksonc867df72010-03-29 21:43:21 +00002050 *
2051 * XXX order for additional mode types in extension blocks?
2052 */
Adam Jackson13931572010-08-03 14:38:19 -04002053 num_modes += add_detailed_modes(connector, edid, quirks);
2054 num_modes += add_cvt_modes(connector, edid);
Adam Jacksonc867df72010-03-29 21:43:21 +00002055 num_modes += add_standard_modes(connector, edid);
2056 num_modes += add_established_modes(connector, edid);
Paulo Zanoni196e0772013-02-15 13:36:27 -02002057 if (edid->features & DRM_EDID_FEATURE_DEFAULT_GTF)
2058 num_modes += add_inferred_modes(connector, edid);
Christian Schmidt54ac76f2011-12-19 14:53:16 +00002059 num_modes += add_cea_modes(connector, edid);
Dave Airlief453ba02008-11-07 14:05:41 -08002060
2061 if (quirks & (EDID_QUIRK_PREFER_LARGE_60 | EDID_QUIRK_PREFER_LARGE_75))
2062 edid_fixup_preferred(connector, quirks);
2063
Jesse Barnes3b112282011-04-15 12:49:23 -07002064 drm_add_display_info(edid, &connector->display_info);
Dave Airlief453ba02008-11-07 14:05:41 -08002065
2066 return num_modes;
2067}
2068EXPORT_SYMBOL(drm_add_edid_modes);
Zhao Yakuif0fda0a2009-09-03 09:33:48 +08002069
2070/**
2071 * drm_add_modes_noedid - add modes for the connectors without EDID
2072 * @connector: connector we're probing
2073 * @hdisplay: the horizontal display limit
2074 * @vdisplay: the vertical display limit
2075 *
2076 * Add the specified modes to the connector's mode list. Only when the
2077 * hdisplay/vdisplay is not beyond the given limit, it will be added.
2078 *
2079 * Return number of modes added or 0 if we couldn't find any.
2080 */
2081int drm_add_modes_noedid(struct drm_connector *connector,
2082 int hdisplay, int vdisplay)
2083{
2084 int i, count, num_modes = 0;
Chris Wilsonb1f559e2011-01-26 09:49:47 +00002085 struct drm_display_mode *mode;
Zhao Yakuif0fda0a2009-09-03 09:33:48 +08002086 struct drm_device *dev = connector->dev;
2087
2088 count = sizeof(drm_dmt_modes) / sizeof(struct drm_display_mode);
2089 if (hdisplay < 0)
2090 hdisplay = 0;
2091 if (vdisplay < 0)
2092 vdisplay = 0;
2093
2094 for (i = 0; i < count; i++) {
Chris Wilsonb1f559e2011-01-26 09:49:47 +00002095 const struct drm_display_mode *ptr = &drm_dmt_modes[i];
Zhao Yakuif0fda0a2009-09-03 09:33:48 +08002096 if (hdisplay && vdisplay) {
2097 /*
2098 * Only when two are valid, they will be used to check
2099 * whether the mode should be added to the mode list of
2100 * the connector.
2101 */
2102 if (ptr->hdisplay > hdisplay ||
2103 ptr->vdisplay > vdisplay)
2104 continue;
2105 }
Adam Jacksonf985ded2009-11-23 14:23:04 -05002106 if (drm_mode_vrefresh(ptr) > 61)
2107 continue;
Zhao Yakuif0fda0a2009-09-03 09:33:48 +08002108 mode = drm_mode_duplicate(dev, ptr);
2109 if (mode) {
2110 drm_mode_probed_add(connector, mode);
2111 num_modes++;
2112 }
2113 }
2114 return num_modes;
2115}
2116EXPORT_SYMBOL(drm_add_modes_noedid);
Paulo Zanoni374a8682012-11-23 12:09:26 -02002117
2118/**
2119 * drm_mode_cea_vic - return the CEA-861 VIC of a given mode
2120 * @mode: mode
2121 *
2122 * RETURNS:
2123 * The VIC number, 0 in case it's not a CEA-861 mode.
2124 */
2125uint8_t drm_mode_cea_vic(const struct drm_display_mode *mode)
2126{
2127 uint8_t i;
2128
2129 for (i = 0; i < drm_num_cea_modes; i++)
2130 if (drm_mode_equal(mode, &edid_cea_modes[i]))
2131 return i + 1;
2132
2133 return 0;
2134}
2135EXPORT_SYMBOL(drm_mode_cea_vic);