source: src/linux/universal/linux-4.9/drivers/gpu/drm/drm_edid.c @ 31859

Last change on this file since 31859 was 31859, checked in by brainslayer, 2 months ago

kernel update

File size: 129.7 KB
Line 
1/*
2 * Copyright (c) 2006 Luc Verhaegen (quirks list)
3 * Copyright (c) 2007-2008 Intel Corporation
4 *   Jesse Barnes <jesse.barnes@intel.com>
5 * Copyright 2010 Red Hat, Inc.
6 *
7 * DDC probing routines (drm_ddc_read & drm_do_probe_ddc_edid) originally from
8 * FB layer.
9 *   Copyright (C) 2006 Dennis Munsie <dmunsie@cecropia.com>
10 *
11 * Permission is hereby granted, free of charge, to any person obtaining a
12 * copy of this software and associated documentation files (the "Software"),
13 * to deal in the Software without restriction, including without limitation
14 * the rights to use, copy, modify, merge, publish, distribute, sub license,
15 * and/or sell copies of the Software, and to permit persons to whom the
16 * Software is furnished to do so, subject to the following conditions:
17 *
18 * The above copyright notice and this permission notice (including the
19 * next paragraph) shall be included in all copies or substantial portions
20 * of the Software.
21 *
22 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
23 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
24 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
25 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
26 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
27 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
28 * DEALINGS IN THE SOFTWARE.
29 */
30#include <linux/kernel.h>
31#include <linux/slab.h>
32#include <linux/hdmi.h>
33#include <linux/i2c.h>
34#include <linux/module.h>
35#include <linux/vga_switcheroo.h>
36#include <drm/drmP.h>
37#include <drm/drm_edid.h>
38#include <drm/drm_displayid.h>
39
40#define version_greater(edid, maj, min) \
41        (((edid)->version > (maj)) || \
42         ((edid)->version == (maj) && (edid)->revision > (min)))
43
44#define EDID_EST_TIMINGS 16
45#define EDID_STD_TIMINGS 8
46#define EDID_DETAILED_TIMINGS 4
47
48/*
49 * EDID blocks out in the wild have a variety of bugs, try to collect
50 * them here (note that userspace may work around broken monitors first,
51 * but fixes should make their way here so that the kernel "just works"
52 * on as many displays as possible).
53 */
54
55/* First detailed mode wrong, use largest 60Hz mode */
56#define EDID_QUIRK_PREFER_LARGE_60              (1 << 0)
57/* Reported 135MHz pixel clock is too high, needs adjustment */
58#define EDID_QUIRK_135_CLOCK_TOO_HIGH           (1 << 1)
59/* Prefer the largest mode at 75 Hz */
60#define EDID_QUIRK_PREFER_LARGE_75              (1 << 2)
61/* Detail timing is in cm not mm */
62#define EDID_QUIRK_DETAILED_IN_CM               (1 << 3)
63/* Detailed timing descriptors have bogus size values, so just take the
64 * maximum size and use that.
65 */
66#define EDID_QUIRK_DETAILED_USE_MAXIMUM_SIZE    (1 << 4)
67/* Monitor forgot to set the first detailed is preferred bit. */
68#define EDID_QUIRK_FIRST_DETAILED_PREFERRED     (1 << 5)
69/* use +hsync +vsync for detailed mode */
70#define EDID_QUIRK_DETAILED_SYNC_PP             (1 << 6)
71/* Force reduced-blanking timings for detailed modes */
72#define EDID_QUIRK_FORCE_REDUCED_BLANKING       (1 << 7)
73/* Force 8bpc */
74#define EDID_QUIRK_FORCE_8BPC                   (1 << 8)
75/* Force 12bpc */
76#define EDID_QUIRK_FORCE_12BPC                  (1 << 9)
77/* Force 6bpc */
78#define EDID_QUIRK_FORCE_6BPC                   (1 << 10)
79
80struct detailed_mode_closure {
81        struct drm_connector *connector;
82        struct edid *edid;
83        bool preferred;
84        u32 quirks;
85        int modes;
86};
87
88#define LEVEL_DMT       0
89#define LEVEL_GTF       1
90#define LEVEL_GTF2      2
91#define LEVEL_CVT       3
92
93static const struct edid_quirk {
94        char vendor[4];
95        int product_id;
96        u32 quirks;
97} edid_quirk_list[] = {
98        /* Acer AL1706 */
99        { "ACR", 44358, EDID_QUIRK_PREFER_LARGE_60 },
100        /* Acer F51 */
101        { "API", 0x7602, EDID_QUIRK_PREFER_LARGE_60 },
102        /* Unknown Acer */
103        { "ACR", 2423, EDID_QUIRK_FIRST_DETAILED_PREFERRED },
104
105        /* AEO model 0 reports 8 bpc, but is a 6 bpc panel */
106        { "AEO", 0, EDID_QUIRK_FORCE_6BPC },
107
108        /* Belinea 10 15 55 */
109        { "MAX", 1516, EDID_QUIRK_PREFER_LARGE_60 },
110        { "MAX", 0x77e, EDID_QUIRK_PREFER_LARGE_60 },
111
112        /* Envision Peripherals, Inc. EN-7100e */
113        { "EPI", 59264, EDID_QUIRK_135_CLOCK_TOO_HIGH },
114        /* Envision EN2028 */
115        { "EPI", 8232, EDID_QUIRK_PREFER_LARGE_60 },
116
117        /* Funai Electronics PM36B */
118        { "FCM", 13600, EDID_QUIRK_PREFER_LARGE_75 |
119          EDID_QUIRK_DETAILED_IN_CM },
120
121        /* LG Philips LCD LP154W01-A5 */
122        { "LPL", 0, EDID_QUIRK_DETAILED_USE_MAXIMUM_SIZE },
123        { "LPL", 0x2a00, EDID_QUIRK_DETAILED_USE_MAXIMUM_SIZE },
124
125        /* Philips 107p5 CRT */
126        { "PHL", 57364, EDID_QUIRK_FIRST_DETAILED_PREFERRED },
127
128        /* Proview AY765C */
129        { "PTS", 765, EDID_QUIRK_FIRST_DETAILED_PREFERRED },
130
131        /* Samsung SyncMaster 205BW.  Note: irony */
132        { "SAM", 541, EDID_QUIRK_DETAILED_SYNC_PP },
133        /* Samsung SyncMaster 22[5-6]BW */
134        { "SAM", 596, EDID_QUIRK_PREFER_LARGE_60 },
135        { "SAM", 638, EDID_QUIRK_PREFER_LARGE_60 },
136
137        /* Sony PVM-2541A does up to 12 bpc, but only reports max 8 bpc */
138        { "SNY", 0x2541, EDID_QUIRK_FORCE_12BPC },
139
140        /* ViewSonic VA2026w */
141        { "VSC", 5020, EDID_QUIRK_FORCE_REDUCED_BLANKING },
142
143        /* Medion MD 30217 PG */
144        { "MED", 0x7b8, EDID_QUIRK_PREFER_LARGE_75 },
145
146        /* Panel in Samsung NP700G7A-S01PL notebook reports 6bpc */
147        { "SEC", 0xd033, EDID_QUIRK_FORCE_8BPC },
148
149        /* Rotel RSX-1058 forwards sink's EDID but only does HDMI 1.1*/
150        { "ETR", 13896, EDID_QUIRK_FORCE_8BPC },
151};
152
153/*
154 * Autogenerated from the DMT spec.
155 * This table is copied from xfree86/modes/xf86EdidModes.c.
156 */
157static const struct drm_display_mode drm_dmt_modes[] = {
158        /* 0x01 - 640x350@85Hz */
159        { DRM_MODE("640x350", DRM_MODE_TYPE_DRIVER, 31500, 640, 672,
160                   736, 832, 0, 350, 382, 385, 445, 0,
161                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC) },
162        /* 0x02 - 640x400@85Hz */
163        { DRM_MODE("640x400", DRM_MODE_TYPE_DRIVER, 31500, 640, 672,
164                   736, 832, 0, 400, 401, 404, 445, 0,
165                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
166        /* 0x03 - 720x400@85Hz */
167        { DRM_MODE("720x400", DRM_MODE_TYPE_DRIVER, 35500, 720, 756,
168                   828, 936, 0, 400, 401, 404, 446, 0,
169                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
170        /* 0x04 - 640x480@60Hz */
171        { DRM_MODE("640x480", DRM_MODE_TYPE_DRIVER, 25175, 640, 656,
172                   752, 800, 0, 480, 490, 492, 525, 0,
173                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) },
174        /* 0x05 - 640x480@72Hz */
175        { DRM_MODE("640x480", DRM_MODE_TYPE_DRIVER, 31500, 640, 664,
176                   704, 832, 0, 480, 489, 492, 520, 0,
177                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) },
178        /* 0x06 - 640x480@75Hz */
179        { DRM_MODE("640x480", DRM_MODE_TYPE_DRIVER, 31500, 640, 656,
180                   720, 840, 0, 480, 481, 484, 500, 0,
181                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) },
182        /* 0x07 - 640x480@85Hz */
183        { DRM_MODE("640x480", DRM_MODE_TYPE_DRIVER, 36000, 640, 696,
184                   752, 832, 0, 480, 481, 484, 509, 0,
185                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) },
186        /* 0x08 - 800x600@56Hz */
187        { DRM_MODE("800x600", DRM_MODE_TYPE_DRIVER, 36000, 800, 824,
188                   896, 1024, 0, 600, 601, 603, 625, 0,
189                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
190        /* 0x09 - 800x600@60Hz */
191        { DRM_MODE("800x600", DRM_MODE_TYPE_DRIVER, 40000, 800, 840,
192                   968, 1056, 0, 600, 601, 605, 628, 0,
193                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
194        /* 0x0a - 800x600@72Hz */
195        { DRM_MODE("800x600", DRM_MODE_TYPE_DRIVER, 50000, 800, 856,
196                   976, 1040, 0, 600, 637, 643, 666, 0,
197                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
198        /* 0x0b - 800x600@75Hz */
199        { DRM_MODE("800x600", DRM_MODE_TYPE_DRIVER, 49500, 800, 816,
200                   896, 1056, 0, 600, 601, 604, 625, 0,
201                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
202        /* 0x0c - 800x600@85Hz */
203        { DRM_MODE("800x600", DRM_MODE_TYPE_DRIVER, 56250, 800, 832,
204                   896, 1048, 0, 600, 601, 604, 631, 0,
205                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
206        /* 0x0d - 800x600@120Hz RB */
207        { DRM_MODE("800x600", DRM_MODE_TYPE_DRIVER, 73250, 800, 848,
208                   880, 960, 0, 600, 603, 607, 636, 0,
209                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC) },
210        /* 0x0e - 848x480@60Hz */
211        { DRM_MODE("848x480", DRM_MODE_TYPE_DRIVER, 33750, 848, 864,
212                   976, 1088, 0, 480, 486, 494, 517, 0,
213                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
214        /* 0x0f - 1024x768@43Hz, interlace */
215        { DRM_MODE("1024x768i", DRM_MODE_TYPE_DRIVER, 44900, 1024, 1032,
216                   1208, 1264, 0, 768, 768, 776, 817, 0,
217                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC |
218                   DRM_MODE_FLAG_INTERLACE) },
219        /* 0x10 - 1024x768@60Hz */
220        { DRM_MODE("1024x768", DRM_MODE_TYPE_DRIVER, 65000, 1024, 1048,
221                   1184, 1344, 0, 768, 771, 777, 806, 0,
222                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) },
223        /* 0x11 - 1024x768@70Hz */
224        { DRM_MODE("1024x768", DRM_MODE_TYPE_DRIVER, 75000, 1024, 1048,
225                   1184, 1328, 0, 768, 771, 777, 806, 0,
226                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) },
227        /* 0x12 - 1024x768@75Hz */
228        { DRM_MODE("1024x768", DRM_MODE_TYPE_DRIVER, 78750, 1024, 1040,
229                   1136, 1312, 0, 768, 769, 772, 800, 0,
230                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
231        /* 0x13 - 1024x768@85Hz */
232        { DRM_MODE("1024x768", DRM_MODE_TYPE_DRIVER, 94500, 1024, 1072,
233                   1168, 1376, 0, 768, 769, 772, 808, 0,
234                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
235        /* 0x14 - 1024x768@120Hz RB */
236        { DRM_MODE("1024x768", DRM_MODE_TYPE_DRIVER, 115500, 1024, 1072,
237                   1104, 1184, 0, 768, 771, 775, 813, 0,
238                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC) },
239        /* 0x15 - 1152x864@75Hz */
240        { DRM_MODE("1152x864", DRM_MODE_TYPE_DRIVER, 108000, 1152, 1216,
241                   1344, 1600, 0, 864, 865, 868, 900, 0,
242                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
243        /* 0x55 - 1280x720@60Hz */
244        { DRM_MODE("1280x720", DRM_MODE_TYPE_DRIVER, 74250, 1280, 1390,
245                   1430, 1650, 0, 720, 725, 730, 750, 0,
246                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
247        /* 0x16 - 1280x768@60Hz RB */
248        { DRM_MODE("1280x768", DRM_MODE_TYPE_DRIVER, 68250, 1280, 1328,
249                   1360, 1440, 0, 768, 771, 778, 790, 0,
250                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC) },
251        /* 0x17 - 1280x768@60Hz */
252        { DRM_MODE("1280x768", DRM_MODE_TYPE_DRIVER, 79500, 1280, 1344,
253                   1472, 1664, 0, 768, 771, 778, 798, 0,
254                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
255        /* 0x18 - 1280x768@75Hz */
256        { DRM_MODE("1280x768", DRM_MODE_TYPE_DRIVER, 102250, 1280, 1360,
257                   1488, 1696, 0, 768, 771, 778, 805, 0,
258                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
259        /* 0x19 - 1280x768@85Hz */
260        { DRM_MODE("1280x768", DRM_MODE_TYPE_DRIVER, 117500, 1280, 1360,
261                   1496, 1712, 0, 768, 771, 778, 809, 0,
262                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
263        /* 0x1a - 1280x768@120Hz RB */
264        { DRM_MODE("1280x768", DRM_MODE_TYPE_DRIVER, 140250, 1280, 1328,
265                   1360, 1440, 0, 768, 771, 778, 813, 0,
266                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC) },
267        /* 0x1b - 1280x800@60Hz RB */
268        { DRM_MODE("1280x800", DRM_MODE_TYPE_DRIVER, 71000, 1280, 1328,
269                   1360, 1440, 0, 800, 803, 809, 823, 0,
270                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC) },
271        /* 0x1c - 1280x800@60Hz */
272        { DRM_MODE("1280x800", DRM_MODE_TYPE_DRIVER, 83500, 1280, 1352,
273                   1480, 1680, 0, 800, 803, 809, 831, 0,
274                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
275        /* 0x1d - 1280x800@75Hz */
276        { DRM_MODE("1280x800", DRM_MODE_TYPE_DRIVER, 106500, 1280, 1360,
277                   1488, 1696, 0, 800, 803, 809, 838, 0,
278                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
279        /* 0x1e - 1280x800@85Hz */
280        { DRM_MODE("1280x800", DRM_MODE_TYPE_DRIVER, 122500, 1280, 1360,
281                   1496, 1712, 0, 800, 803, 809, 843, 0,
282                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
283        /* 0x1f - 1280x800@120Hz RB */
284        { DRM_MODE("1280x800", DRM_MODE_TYPE_DRIVER, 146250, 1280, 1328,
285                   1360, 1440, 0, 800, 803, 809, 847, 0,
286                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC) },
287        /* 0x20 - 1280x960@60Hz */
288        { DRM_MODE("1280x960", DRM_MODE_TYPE_DRIVER, 108000, 1280, 1376,
289                   1488, 1800, 0, 960, 961, 964, 1000, 0,
290                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
291        /* 0x21 - 1280x960@85Hz */
292        { DRM_MODE("1280x960", DRM_MODE_TYPE_DRIVER, 148500, 1280, 1344,
293                   1504, 1728, 0, 960, 961, 964, 1011, 0,
294                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
295        /* 0x22 - 1280x960@120Hz RB */
296        { DRM_MODE("1280x960", DRM_MODE_TYPE_DRIVER, 175500, 1280, 1328,
297                   1360, 1440, 0, 960, 963, 967, 1017, 0,
298                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC) },
299        /* 0x23 - 1280x1024@60Hz */
300        { DRM_MODE("1280x1024", DRM_MODE_TYPE_DRIVER, 108000, 1280, 1328,
301                   1440, 1688, 0, 1024, 1025, 1028, 1066, 0,
302                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
303        /* 0x24 - 1280x1024@75Hz */
304        { DRM_MODE("1280x1024", DRM_MODE_TYPE_DRIVER, 135000, 1280, 1296,
305                   1440, 1688, 0, 1024, 1025, 1028, 1066, 0,
306                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
307        /* 0x25 - 1280x1024@85Hz */
308        { DRM_MODE("1280x1024", DRM_MODE_TYPE_DRIVER, 157500, 1280, 1344,
309                   1504, 1728, 0, 1024, 1025, 1028, 1072, 0,
310                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
311        /* 0x26 - 1280x1024@120Hz RB */
312        { DRM_MODE("1280x1024", DRM_MODE_TYPE_DRIVER, 187250, 1280, 1328,
313                   1360, 1440, 0, 1024, 1027, 1034, 1084, 0,
314                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC) },
315        /* 0x27 - 1360x768@60Hz */
316        { DRM_MODE("1360x768", DRM_MODE_TYPE_DRIVER, 85500, 1360, 1424,
317                   1536, 1792, 0, 768, 771, 777, 795, 0,
318                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
319        /* 0x28 - 1360x768@120Hz RB */
320        { DRM_MODE("1360x768", DRM_MODE_TYPE_DRIVER, 148250, 1360, 1408,
321                   1440, 1520, 0, 768, 771, 776, 813, 0,
322                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC) },
323        /* 0x51 - 1366x768@60Hz */
324        { DRM_MODE("1366x768", DRM_MODE_TYPE_DRIVER, 85500, 1366, 1436,
325                   1579, 1792, 0, 768, 771, 774, 798, 0,
326                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
327        /* 0x56 - 1366x768@60Hz */
328        { DRM_MODE("1366x768", DRM_MODE_TYPE_DRIVER, 72000, 1366, 1380,
329                   1436, 1500, 0, 768, 769, 772, 800, 0,
330                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
331        /* 0x29 - 1400x1050@60Hz RB */
332        { DRM_MODE("1400x1050", DRM_MODE_TYPE_DRIVER, 101000, 1400, 1448,
333                   1480, 1560, 0, 1050, 1053, 1057, 1080, 0,
334                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC) },
335        /* 0x2a - 1400x1050@60Hz */
336        { DRM_MODE("1400x1050", DRM_MODE_TYPE_DRIVER, 121750, 1400, 1488,
337                   1632, 1864, 0, 1050, 1053, 1057, 1089, 0,
338                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
339        /* 0x2b - 1400x1050@75Hz */
340        { DRM_MODE("1400x1050", DRM_MODE_TYPE_DRIVER, 156000, 1400, 1504,
341                   1648, 1896, 0, 1050, 1053, 1057, 1099, 0,
342                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
343        /* 0x2c - 1400x1050@85Hz */
344        { DRM_MODE("1400x1050", DRM_MODE_TYPE_DRIVER, 179500, 1400, 1504,
345                   1656, 1912, 0, 1050, 1053, 1057, 1105, 0,
346                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
347        /* 0x2d - 1400x1050@120Hz RB */
348        { DRM_MODE("1400x1050", DRM_MODE_TYPE_DRIVER, 208000, 1400, 1448,
349                   1480, 1560, 0, 1050, 1053, 1057, 1112, 0,
350                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC) },
351        /* 0x2e - 1440x900@60Hz RB */
352        { DRM_MODE("1440x900", DRM_MODE_TYPE_DRIVER, 88750, 1440, 1488,
353                   1520, 1600, 0, 900, 903, 909, 926, 0,
354                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC) },
355        /* 0x2f - 1440x900@60Hz */
356        { DRM_MODE("1440x900", DRM_MODE_TYPE_DRIVER, 106500, 1440, 1520,
357                   1672, 1904, 0, 900, 903, 909, 934, 0,
358                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
359        /* 0x30 - 1440x900@75Hz */
360        { DRM_MODE("1440x900", DRM_MODE_TYPE_DRIVER, 136750, 1440, 1536,
361                   1688, 1936, 0, 900, 903, 909, 942, 0,
362                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
363        /* 0x31 - 1440x900@85Hz */
364        { DRM_MODE("1440x900", DRM_MODE_TYPE_DRIVER, 157000, 1440, 1544,
365                   1696, 1952, 0, 900, 903, 909, 948, 0,
366                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
367        /* 0x32 - 1440x900@120Hz RB */
368        { DRM_MODE("1440x900", DRM_MODE_TYPE_DRIVER, 182750, 1440, 1488,
369                   1520, 1600, 0, 900, 903, 909, 953, 0,
370                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC) },
371        /* 0x53 - 1600x900@60Hz */
372        { DRM_MODE("1600x900", DRM_MODE_TYPE_DRIVER, 108000, 1600, 1624,
373                   1704, 1800, 0, 900, 901, 904, 1000, 0,
374                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
375        /* 0x33 - 1600x1200@60Hz */
376        { DRM_MODE("1600x1200", DRM_MODE_TYPE_DRIVER, 162000, 1600, 1664,
377                   1856, 2160, 0, 1200, 1201, 1204, 1250, 0,
378                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
379        /* 0x34 - 1600x1200@65Hz */
380        { DRM_MODE("1600x1200", DRM_MODE_TYPE_DRIVER, 175500, 1600, 1664,
381                   1856, 2160, 0, 1200, 1201, 1204, 1250, 0,
382                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
383        /* 0x35 - 1600x1200@70Hz */
384        { DRM_MODE("1600x1200", DRM_MODE_TYPE_DRIVER, 189000, 1600, 1664,
385                   1856, 2160, 0, 1200, 1201, 1204, 1250, 0,
386                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
387        /* 0x36 - 1600x1200@75Hz */
388        { DRM_MODE("1600x1200", DRM_MODE_TYPE_DRIVER, 202500, 1600, 1664,
389                   1856, 2160, 0, 1200, 1201, 1204, 1250, 0,
390                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
391        /* 0x37 - 1600x1200@85Hz */
392        { DRM_MODE("1600x1200", DRM_MODE_TYPE_DRIVER, 229500, 1600, 1664,
393                   1856, 2160, 0, 1200, 1201, 1204, 1250, 0,
394                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
395        /* 0x38 - 1600x1200@120Hz RB */
396        { DRM_MODE("1600x1200", DRM_MODE_TYPE_DRIVER, 268250, 1600, 1648,
397                   1680, 1760, 0, 1200, 1203, 1207, 1271, 0,
398                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC) },
399        /* 0x39 - 1680x1050@60Hz RB */
400        { DRM_MODE("1680x1050", DRM_MODE_TYPE_DRIVER, 119000, 1680, 1728,
401                   1760, 1840, 0, 1050, 1053, 1059, 1080, 0,
402                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC) },
403        /* 0x3a - 1680x1050@60Hz */
404        { DRM_MODE("1680x1050", DRM_MODE_TYPE_DRIVER, 146250, 1680, 1784,
405                   1960, 2240, 0, 1050, 1053, 1059, 1089, 0,
406                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
407        /* 0x3b - 1680x1050@75Hz */
408        { DRM_MODE("1680x1050", DRM_MODE_TYPE_DRIVER, 187000, 1680, 1800,
409                   1976, 2272, 0, 1050, 1053, 1059, 1099, 0,
410                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
411        /* 0x3c - 1680x1050@85Hz */
412        { DRM_MODE("1680x1050", DRM_MODE_TYPE_DRIVER, 214750, 1680, 1808,
413                   1984, 2288, 0, 1050, 1053, 1059, 1105, 0,
414                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
415        /* 0x3d - 1680x1050@120Hz RB */
416        { DRM_MODE("1680x1050", DRM_MODE_TYPE_DRIVER, 245500, 1680, 1728,
417                   1760, 1840, 0, 1050, 1053, 1059, 1112, 0,
418                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC) },
419        /* 0x3e - 1792x1344@60Hz */
420        { DRM_MODE("1792x1344", DRM_MODE_TYPE_DRIVER, 204750, 1792, 1920,
421                   2120, 2448, 0, 1344, 1345, 1348, 1394, 0,
422                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
423        /* 0x3f - 1792x1344@75Hz */
424        { DRM_MODE("1792x1344", DRM_MODE_TYPE_DRIVER, 261000, 1792, 1888,
425                   2104, 2456, 0, 1344, 1345, 1348, 1417, 0,
426                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
427        /* 0x40 - 1792x1344@120Hz RB */
428        { DRM_MODE("1792x1344", DRM_MODE_TYPE_DRIVER, 333250, 1792, 1840,
429                   1872, 1952, 0, 1344, 1347, 1351, 1423, 0,
430                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC) },
431        /* 0x41 - 1856x1392@60Hz */
432        { DRM_MODE("1856x1392", DRM_MODE_TYPE_DRIVER, 218250, 1856, 1952,
433                   2176, 2528, 0, 1392, 1393, 1396, 1439, 0,
434                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
435        /* 0x42 - 1856x1392@75Hz */
436        { DRM_MODE("1856x1392", DRM_MODE_TYPE_DRIVER, 288000, 1856, 1984,
437                   2208, 2560, 0, 1392, 1393, 1396, 1500, 0,
438                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
439        /* 0x43 - 1856x1392@120Hz RB */
440        { DRM_MODE("1856x1392", DRM_MODE_TYPE_DRIVER, 356500, 1856, 1904,
441                   1936, 2016, 0, 1392, 1395, 1399, 1474, 0,
442                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC) },
443        /* 0x52 - 1920x1080@60Hz */
444        { DRM_MODE("1920x1080", DRM_MODE_TYPE_DRIVER, 148500, 1920, 2008,
445                   2052, 2200, 0, 1080, 1084, 1089, 1125, 0,
446                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) },
447        /* 0x44 - 1920x1200@60Hz RB */
448        { DRM_MODE("1920x1200", DRM_MODE_TYPE_DRIVER, 154000, 1920, 1968,
449                   2000, 2080, 0, 1200, 1203, 1209, 1235, 0,
450                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC) },
451        /* 0x45 - 1920x1200@60Hz */
452        { DRM_MODE("1920x1200", DRM_MODE_TYPE_DRIVER, 193250, 1920, 2056,
453                   2256, 2592, 0, 1200, 1203, 1209, 1245, 0,
454                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
455        /* 0x46 - 1920x1200@75Hz */
456        { DRM_MODE("1920x1200", DRM_MODE_TYPE_DRIVER, 245250, 1920, 2056,
457                   2264, 2608, 0, 1200, 1203, 1209, 1255, 0,
458                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
459        /* 0x47 - 1920x1200@85Hz */
460        { DRM_MODE("1920x1200", DRM_MODE_TYPE_DRIVER, 281250, 1920, 2064,
461                   2272, 2624, 0, 1200, 1203, 1209, 1262, 0,
462                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
463        /* 0x48 - 1920x1200@120Hz RB */
464        { DRM_MODE("1920x1200", DRM_MODE_TYPE_DRIVER, 317000, 1920, 1968,
465                   2000, 2080, 0, 1200, 1203, 1209, 1271, 0,
466                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC) },
467        /* 0x49 - 1920x1440@60Hz */
468        { DRM_MODE("1920x1440", DRM_MODE_TYPE_DRIVER, 234000, 1920, 2048,
469                   2256, 2600, 0, 1440, 1441, 1444, 1500, 0,
470                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
471        /* 0x4a - 1920x1440@75Hz */
472        { DRM_MODE("1920x1440", DRM_MODE_TYPE_DRIVER, 297000, 1920, 2064,
473                   2288, 2640, 0, 1440, 1441, 1444, 1500, 0,
474                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
475        /* 0x4b - 1920x1440@120Hz RB */
476        { DRM_MODE("1920x1440", DRM_MODE_TYPE_DRIVER, 380500, 1920, 1968,
477                   2000, 2080, 0, 1440, 1443, 1447, 1525, 0,
478                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC) },
479        /* 0x54 - 2048x1152@60Hz */
480        { DRM_MODE("2048x1152", DRM_MODE_TYPE_DRIVER, 162000, 2048, 2074,
481                   2154, 2250, 0, 1152, 1153, 1156, 1200, 0,
482                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
483        /* 0x4c - 2560x1600@60Hz RB */
484        { DRM_MODE("2560x1600", DRM_MODE_TYPE_DRIVER, 268500, 2560, 2608,
485                   2640, 2720, 0, 1600, 1603, 1609, 1646, 0,
486                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC) },
487        /* 0x4d - 2560x1600@60Hz */
488        { DRM_MODE("2560x1600", DRM_MODE_TYPE_DRIVER, 348500, 2560, 2752,
489                   3032, 3504, 0, 1600, 1603, 1609, 1658, 0,
490                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
491        /* 0x4e - 2560x1600@75Hz */
492        { DRM_MODE("2560x1600", DRM_MODE_TYPE_DRIVER, 443250, 2560, 2768,
493                   3048, 3536, 0, 1600, 1603, 1609, 1672, 0,
494                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
495        /* 0x4f - 2560x1600@85Hz */
496        { DRM_MODE("2560x1600", DRM_MODE_TYPE_DRIVER, 505250, 2560, 2768,
497                   3048, 3536, 0, 1600, 1603, 1609, 1682, 0,
498                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
499        /* 0x50 - 2560x1600@120Hz RB */
500        { DRM_MODE("2560x1600", DRM_MODE_TYPE_DRIVER, 552750, 2560, 2608,
501                   2640, 2720, 0, 1600, 1603, 1609, 1694, 0,
502                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC) },
503        /* 0x57 - 4096x2160@60Hz RB */
504        { DRM_MODE("4096x2160", DRM_MODE_TYPE_DRIVER, 556744, 4096, 4104,
505                   4136, 4176, 0, 2160, 2208, 2216, 2222, 0,
506                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC) },
507        /* 0x58 - 4096x2160@59.94Hz RB */
508        { DRM_MODE("4096x2160", DRM_MODE_TYPE_DRIVER, 556188, 4096, 4104,
509                   4136, 4176, 0, 2160, 2208, 2216, 2222, 0,
510                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC) },
511};
512
513/*
514 * These more or less come from the DMT spec.  The 720x400 modes are
515 * inferred from historical 80x25 practice.  The 640x480@67 and 832x624@75
516 * modes are old-school Mac modes.  The EDID spec says the 1152x864@75 mode
517 * should be 1152x870, again for the Mac, but instead we use the x864 DMT
518 * mode.
519 *
520 * The DMT modes have been fact-checked; the rest are mild guesses.
521 */
522static const struct drm_display_mode edid_est_modes[] = {
523        { DRM_MODE("800x600", DRM_MODE_TYPE_DRIVER, 40000, 800, 840,
524                   968, 1056, 0, 600, 601, 605, 628, 0,
525                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) }, /* 800x600@60Hz */
526        { DRM_MODE("800x600", DRM_MODE_TYPE_DRIVER, 36000, 800, 824,
527                   896, 1024, 0, 600, 601, 603,  625, 0,
528                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) }, /* 800x600@56Hz */
529        { DRM_MODE("640x480", DRM_MODE_TYPE_DRIVER, 31500, 640, 656,
530                   720, 840, 0, 480, 481, 484, 500, 0,
531                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) }, /* 640x480@75Hz */
532        { DRM_MODE("640x480", DRM_MODE_TYPE_DRIVER, 31500, 640, 664,
533                   704,  832, 0, 480, 489, 492, 520, 0,
534                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) }, /* 640x480@72Hz */
535        { DRM_MODE("640x480", DRM_MODE_TYPE_DRIVER, 30240, 640, 704,
536                   768,  864, 0, 480, 483, 486, 525, 0,
537                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) }, /* 640x480@67Hz */
538        { DRM_MODE("640x480", DRM_MODE_TYPE_DRIVER, 25175, 640, 656,
539                   752, 800, 0, 480, 490, 492, 525, 0,
540                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) }, /* 640x480@60Hz */
541        { DRM_MODE("720x400", DRM_MODE_TYPE_DRIVER, 35500, 720, 738,
542                   846, 900, 0, 400, 421, 423,  449, 0,
543                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) }, /* 720x400@88Hz */
544        { DRM_MODE("720x400", DRM_MODE_TYPE_DRIVER, 28320, 720, 738,
545                   846,  900, 0, 400, 412, 414, 449, 0,
546                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) }, /* 720x400@70Hz */
547        { DRM_MODE("1280x1024", DRM_MODE_TYPE_DRIVER, 135000, 1280, 1296,
548                   1440, 1688, 0, 1024, 1025, 1028, 1066, 0,
549                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) }, /* 1280x1024@75Hz */
550        { DRM_MODE("1024x768", DRM_MODE_TYPE_DRIVER, 78750, 1024, 1040,
551                   1136, 1312, 0,  768, 769, 772, 800, 0,
552                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) }, /* 1024x768@75Hz */
553        { DRM_MODE("1024x768", DRM_MODE_TYPE_DRIVER, 75000, 1024, 1048,
554                   1184, 1328, 0,  768, 771, 777, 806, 0,
555                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) }, /* 1024x768@70Hz */
556        { DRM_MODE("1024x768", DRM_MODE_TYPE_DRIVER, 65000, 1024, 1048,
557                   1184, 1344, 0,  768, 771, 777, 806, 0,
558                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) }, /* 1024x768@60Hz */
559        { DRM_MODE("1024x768i", DRM_MODE_TYPE_DRIVER,44900, 1024, 1032,
560                   1208, 1264, 0, 768, 768, 776, 817, 0,
561                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC | DRM_MODE_FLAG_INTERLACE) }, /* 1024x768@43Hz */
562        { DRM_MODE("832x624", DRM_MODE_TYPE_DRIVER, 57284, 832, 864,
563                   928, 1152, 0, 624, 625, 628, 667, 0,
564                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) }, /* 832x624@75Hz */
565        { DRM_MODE("800x600", DRM_MODE_TYPE_DRIVER, 49500, 800, 816,
566                   896, 1056, 0, 600, 601, 604,  625, 0,
567                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) }, /* 800x600@75Hz */
568        { DRM_MODE("800x600", DRM_MODE_TYPE_DRIVER, 50000, 800, 856,
569                   976, 1040, 0, 600, 637, 643, 666, 0,
570                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) }, /* 800x600@72Hz */
571        { DRM_MODE("1152x864", DRM_MODE_TYPE_DRIVER, 108000, 1152, 1216,
572                   1344, 1600, 0,  864, 865, 868, 900, 0,
573                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) }, /* 1152x864@75Hz */
574};
575
576struct minimode {
577        short w;
578        short h;
579        short r;
580        short rb;
581};
582
583static const struct minimode est3_modes[] = {
584        /* byte 6 */
585        { 640, 350, 85, 0 },
586        { 640, 400, 85, 0 },
587        { 720, 400, 85, 0 },
588        { 640, 480, 85, 0 },
589        { 848, 480, 60, 0 },
590        { 800, 600, 85, 0 },
591        { 1024, 768, 85, 0 },
592        { 1152, 864, 75, 0 },
593        /* byte 7 */
594        { 1280, 768, 60, 1 },
595        { 1280, 768, 60, 0 },
596        { 1280, 768, 75, 0 },
597        { 1280, 768, 85, 0 },
598        { 1280, 960, 60, 0 },
599        { 1280, 960, 85, 0 },
600        { 1280, 1024, 60, 0 },
601        { 1280, 1024, 85, 0 },
602        /* byte 8 */
603        { 1360, 768, 60, 0 },
604        { 1440, 900, 60, 1 },
605        { 1440, 900, 60, 0 },
606        { 1440, 900, 75, 0 },
607        { 1440, 900, 85, 0 },
608        { 1400, 1050, 60, 1 },
609        { 1400, 1050, 60, 0 },
610        { 1400, 1050, 75, 0 },
611        /* byte 9 */
612        { 1400, 1050, 85, 0 },
613        { 1680, 1050, 60, 1 },
614        { 1680, 1050, 60, 0 },
615        { 1680, 1050, 75, 0 },
616        { 1680, 1050, 85, 0 },
617        { 1600, 1200, 60, 0 },
618        { 1600, 1200, 65, 0 },
619        { 1600, 1200, 70, 0 },
620        /* byte 10 */
621        { 1600, 1200, 75, 0 },
622        { 1600, 1200, 85, 0 },
623        { 1792, 1344, 60, 0 },
624        { 1792, 1344, 75, 0 },
625        { 1856, 1392, 60, 0 },
626        { 1856, 1392, 75, 0 },
627        { 1920, 1200, 60, 1 },
628        { 1920, 1200, 60, 0 },
629        /* byte 11 */
630        { 1920, 1200, 75, 0 },
631        { 1920, 1200, 85, 0 },
632        { 1920, 1440, 60, 0 },
633        { 1920, 1440, 75, 0 },
634};
635
636static const struct minimode extra_modes[] = {
637        { 1024, 576,  60, 0 },
638        { 1366, 768,  60, 0 },
639        { 1600, 900,  60, 0 },
640        { 1680, 945,  60, 0 },
641        { 1920, 1080, 60, 0 },
642        { 2048, 1152, 60, 0 },
643        { 2048, 1536, 60, 0 },
644};
645
646/*
647 * Probably taken from CEA-861 spec.
648 * This table is converted from xorg's hw/xfree86/modes/xf86EdidModes.c.
649 *
650 * Index using the VIC.
651 */
652static const struct drm_display_mode edid_cea_modes[] = {
653        /* 0 - dummy, VICs start at 1 */
654        { },
655        /* 1 - 640x480@60Hz */
656        { DRM_MODE("640x480", DRM_MODE_TYPE_DRIVER, 25175, 640, 656,
657                   752, 800, 0, 480, 490, 492, 525, 0,
658                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
659          .vrefresh = 60, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_4_3, },
660        /* 2 - 720x480@60Hz */
661        { DRM_MODE("720x480", DRM_MODE_TYPE_DRIVER, 27000, 720, 736,
662                   798, 858, 0, 480, 489, 495, 525, 0,
663                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
664          .vrefresh = 60, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_4_3, },
665        /* 3 - 720x480@60Hz */
666        { DRM_MODE("720x480", DRM_MODE_TYPE_DRIVER, 27000, 720, 736,
667                   798, 858, 0, 480, 489, 495, 525, 0,
668                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
669          .vrefresh = 60, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
670        /* 4 - 1280x720@60Hz */
671        { DRM_MODE("1280x720", DRM_MODE_TYPE_DRIVER, 74250, 1280, 1390,
672                   1430, 1650, 0, 720, 725, 730, 750, 0,
673                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
674          .vrefresh = 60, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
675        /* 5 - 1920x1080i@60Hz */
676        { DRM_MODE("1920x1080i", DRM_MODE_TYPE_DRIVER, 74250, 1920, 2008,
677                   2052, 2200, 0, 1080, 1084, 1094, 1125, 0,
678                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC |
679                        DRM_MODE_FLAG_INTERLACE),
680          .vrefresh = 60, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
681        /* 6 - 720(1440)x480i@60Hz */
682        { DRM_MODE("720x480i", DRM_MODE_TYPE_DRIVER, 13500, 720, 739,
683                   801, 858, 0, 480, 488, 494, 525, 0,
684                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC |
685                        DRM_MODE_FLAG_INTERLACE | DRM_MODE_FLAG_DBLCLK),
686          .vrefresh = 60, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_4_3, },
687        /* 7 - 720(1440)x480i@60Hz */
688        { DRM_MODE("720x480i", DRM_MODE_TYPE_DRIVER, 13500, 720, 739,
689                   801, 858, 0, 480, 488, 494, 525, 0,
690                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC |
691                        DRM_MODE_FLAG_INTERLACE | DRM_MODE_FLAG_DBLCLK),
692          .vrefresh = 60, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
693        /* 8 - 720(1440)x240@60Hz */
694        { DRM_MODE("720x240", DRM_MODE_TYPE_DRIVER, 13500, 720, 739,
695                   801, 858, 0, 240, 244, 247, 262, 0,
696                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC |
697                        DRM_MODE_FLAG_DBLCLK),
698          .vrefresh = 60, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_4_3, },
699        /* 9 - 720(1440)x240@60Hz */
700        { DRM_MODE("720x240", DRM_MODE_TYPE_DRIVER, 13500, 720, 739,
701                   801, 858, 0, 240, 244, 247, 262, 0,
702                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC |
703                        DRM_MODE_FLAG_DBLCLK),
704          .vrefresh = 60, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
705        /* 10 - 2880x480i@60Hz */
706        { DRM_MODE("2880x480i", DRM_MODE_TYPE_DRIVER, 54000, 2880, 2956,
707                   3204, 3432, 0, 480, 488, 494, 525, 0,
708                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC |
709                        DRM_MODE_FLAG_INTERLACE),
710          .vrefresh = 60, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_4_3, },
711        /* 11 - 2880x480i@60Hz */
712        { DRM_MODE("2880x480i", DRM_MODE_TYPE_DRIVER, 54000, 2880, 2956,
713                   3204, 3432, 0, 480, 488, 494, 525, 0,
714                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC |
715                        DRM_MODE_FLAG_INTERLACE),
716          .vrefresh = 60, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
717        /* 12 - 2880x240@60Hz */
718        { DRM_MODE("2880x240", DRM_MODE_TYPE_DRIVER, 54000, 2880, 2956,
719                   3204, 3432, 0, 240, 244, 247, 262, 0,
720                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
721          .vrefresh = 60, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_4_3, },
722        /* 13 - 2880x240@60Hz */
723        { DRM_MODE("2880x240", DRM_MODE_TYPE_DRIVER, 54000, 2880, 2956,
724                   3204, 3432, 0, 240, 244, 247, 262, 0,
725                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
726          .vrefresh = 60, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
727        /* 14 - 1440x480@60Hz */
728        { DRM_MODE("1440x480", DRM_MODE_TYPE_DRIVER, 54000, 1440, 1472,
729                   1596, 1716, 0, 480, 489, 495, 525, 0,
730                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
731          .vrefresh = 60, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_4_3, },
732        /* 15 - 1440x480@60Hz */
733        { DRM_MODE("1440x480", DRM_MODE_TYPE_DRIVER, 54000, 1440, 1472,
734                   1596, 1716, 0, 480, 489, 495, 525, 0,
735                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
736          .vrefresh = 60, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
737        /* 16 - 1920x1080@60Hz */
738        { DRM_MODE("1920x1080", DRM_MODE_TYPE_DRIVER, 148500, 1920, 2008,
739                   2052, 2200, 0, 1080, 1084, 1089, 1125, 0,
740                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
741          .vrefresh = 60, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
742        /* 17 - 720x576@50Hz */
743        { DRM_MODE("720x576", DRM_MODE_TYPE_DRIVER, 27000, 720, 732,
744                   796, 864, 0, 576, 581, 586, 625, 0,
745                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
746          .vrefresh = 50, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_4_3, },
747        /* 18 - 720x576@50Hz */
748        { DRM_MODE("720x576", DRM_MODE_TYPE_DRIVER, 27000, 720, 732,
749                   796, 864, 0, 576, 581, 586, 625, 0,
750                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
751          .vrefresh = 50, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
752        /* 19 - 1280x720@50Hz */
753        { DRM_MODE("1280x720", DRM_MODE_TYPE_DRIVER, 74250, 1280, 1720,
754                   1760, 1980, 0, 720, 725, 730, 750, 0,
755                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
756          .vrefresh = 50, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
757        /* 20 - 1920x1080i@50Hz */
758        { DRM_MODE("1920x1080i", DRM_MODE_TYPE_DRIVER, 74250, 1920, 2448,
759                   2492, 2640, 0, 1080, 1084, 1094, 1125, 0,
760                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC |
761                        DRM_MODE_FLAG_INTERLACE),
762          .vrefresh = 50, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
763        /* 21 - 720(1440)x576i@50Hz */
764        { DRM_MODE("720x576i", DRM_MODE_TYPE_DRIVER, 13500, 720, 732,
765                   795, 864, 0, 576, 580, 586, 625, 0,
766                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC |
767                        DRM_MODE_FLAG_INTERLACE | DRM_MODE_FLAG_DBLCLK),
768          .vrefresh = 50, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_4_3, },
769        /* 22 - 720(1440)x576i@50Hz */
770        { DRM_MODE("720x576i", DRM_MODE_TYPE_DRIVER, 13500, 720, 732,
771                   795, 864, 0, 576, 580, 586, 625, 0,
772                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC |
773                        DRM_MODE_FLAG_INTERLACE | DRM_MODE_FLAG_DBLCLK),
774          .vrefresh = 50, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
775        /* 23 - 720(1440)x288@50Hz */
776        { DRM_MODE("720x288", DRM_MODE_TYPE_DRIVER, 13500, 720, 732,
777                   795, 864, 0, 288, 290, 293, 312, 0,
778                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC |
779                        DRM_MODE_FLAG_DBLCLK),
780          .vrefresh = 50, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_4_3, },
781        /* 24 - 720(1440)x288@50Hz */
782        { DRM_MODE("720x288", DRM_MODE_TYPE_DRIVER, 13500, 720, 732,
783                   795, 864, 0, 288, 290, 293, 312, 0,
784                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC |
785                        DRM_MODE_FLAG_DBLCLK),
786          .vrefresh = 50, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
787        /* 25 - 2880x576i@50Hz */
788        { DRM_MODE("2880x576i", DRM_MODE_TYPE_DRIVER, 54000, 2880, 2928,
789                   3180, 3456, 0, 576, 580, 586, 625, 0,
790                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC |
791                        DRM_MODE_FLAG_INTERLACE),
792          .vrefresh = 50, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_4_3, },
793        /* 26 - 2880x576i@50Hz */
794        { DRM_MODE("2880x576i", DRM_MODE_TYPE_DRIVER, 54000, 2880, 2928,
795                   3180, 3456, 0, 576, 580, 586, 625, 0,
796                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC |
797                        DRM_MODE_FLAG_INTERLACE),
798          .vrefresh = 50, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
799        /* 27 - 2880x288@50Hz */
800        { DRM_MODE("2880x288", DRM_MODE_TYPE_DRIVER, 54000, 2880, 2928,
801                   3180, 3456, 0, 288, 290, 293, 312, 0,
802                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
803          .vrefresh = 50, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_4_3, },
804        /* 28 - 2880x288@50Hz */
805        { DRM_MODE("2880x288", DRM_MODE_TYPE_DRIVER, 54000, 2880, 2928,
806                   3180, 3456, 0, 288, 290, 293, 312, 0,
807                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
808          .vrefresh = 50, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
809        /* 29 - 1440x576@50Hz */
810        { DRM_MODE("1440x576", DRM_MODE_TYPE_DRIVER, 54000, 1440, 1464,
811                   1592, 1728, 0, 576, 581, 586, 625, 0,
812                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
813          .vrefresh = 50, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_4_3, },
814        /* 30 - 1440x576@50Hz */
815        { DRM_MODE("1440x576", DRM_MODE_TYPE_DRIVER, 54000, 1440, 1464,
816                   1592, 1728, 0, 576, 581, 586, 625, 0,
817                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
818          .vrefresh = 50, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
819        /* 31 - 1920x1080@50Hz */
820        { DRM_MODE("1920x1080", DRM_MODE_TYPE_DRIVER, 148500, 1920, 2448,
821                   2492, 2640, 0, 1080, 1084, 1089, 1125, 0,
822                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
823          .vrefresh = 50, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
824        /* 32 - 1920x1080@24Hz */
825        { DRM_MODE("1920x1080", DRM_MODE_TYPE_DRIVER, 74250, 1920, 2558,
826                   2602, 2750, 0, 1080, 1084, 1089, 1125, 0,
827                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
828          .vrefresh = 24, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
829        /* 33 - 1920x1080@25Hz */
830        { DRM_MODE("1920x1080", DRM_MODE_TYPE_DRIVER, 74250, 1920, 2448,
831                   2492, 2640, 0, 1080, 1084, 1089, 1125, 0,
832                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
833          .vrefresh = 25, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
834        /* 34 - 1920x1080@30Hz */
835        { DRM_MODE("1920x1080", DRM_MODE_TYPE_DRIVER, 74250, 1920, 2008,
836                   2052, 2200, 0, 1080, 1084, 1089, 1125, 0,
837                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
838          .vrefresh = 30, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
839        /* 35 - 2880x480@60Hz */
840        { DRM_MODE("2880x480", DRM_MODE_TYPE_DRIVER, 108000, 2880, 2944,
841                   3192, 3432, 0, 480, 489, 495, 525, 0,
842                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
843          .vrefresh = 60, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_4_3, },
844        /* 36 - 2880x480@60Hz */
845        { DRM_MODE("2880x480", DRM_MODE_TYPE_DRIVER, 108000, 2880, 2944,
846                   3192, 3432, 0, 480, 489, 495, 525, 0,
847                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
848          .vrefresh = 60, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
849        /* 37 - 2880x576@50Hz */
850        { DRM_MODE("2880x576", DRM_MODE_TYPE_DRIVER, 108000, 2880, 2928,
851                   3184, 3456, 0, 576, 581, 586, 625, 0,
852                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
853          .vrefresh = 50, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_4_3, },
854        /* 38 - 2880x576@50Hz */
855        { DRM_MODE("2880x576", DRM_MODE_TYPE_DRIVER, 108000, 2880, 2928,
856                   3184, 3456, 0, 576, 581, 586, 625, 0,
857                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
858          .vrefresh = 50, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
859        /* 39 - 1920x1080i@50Hz */
860        { DRM_MODE("1920x1080i", DRM_MODE_TYPE_DRIVER, 72000, 1920, 1952,
861                   2120, 2304, 0, 1080, 1126, 1136, 1250, 0,
862                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC |
863                        DRM_MODE_FLAG_INTERLACE),
864          .vrefresh = 50, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
865        /* 40 - 1920x1080i@100Hz */
866        { DRM_MODE("1920x1080i", DRM_MODE_TYPE_DRIVER, 148500, 1920, 2448,
867                   2492, 2640, 0, 1080, 1084, 1094, 1125, 0,
868                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC |
869                        DRM_MODE_FLAG_INTERLACE),
870          .vrefresh = 100, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
871        /* 41 - 1280x720@100Hz */
872        { DRM_MODE("1280x720", DRM_MODE_TYPE_DRIVER, 148500, 1280, 1720,
873                   1760, 1980, 0, 720, 725, 730, 750, 0,
874                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
875          .vrefresh = 100, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
876        /* 42 - 720x576@100Hz */
877        { DRM_MODE("720x576", DRM_MODE_TYPE_DRIVER, 54000, 720, 732,
878                   796, 864, 0, 576, 581, 586, 625, 0,
879                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
880          .vrefresh = 100, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_4_3, },
881        /* 43 - 720x576@100Hz */
882        { DRM_MODE("720x576", DRM_MODE_TYPE_DRIVER, 54000, 720, 732,
883                   796, 864, 0, 576, 581, 586, 625, 0,
884                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
885          .vrefresh = 100, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
886        /* 44 - 720(1440)x576i@100Hz */
887        { DRM_MODE("720x576i", DRM_MODE_TYPE_DRIVER, 27000, 720, 732,
888                   795, 864, 0, 576, 580, 586, 625, 0,
889                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC |
890                        DRM_MODE_FLAG_INTERLACE | DRM_MODE_FLAG_DBLCLK),
891          .vrefresh = 100, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_4_3, },
892        /* 45 - 720(1440)x576i@100Hz */
893        { DRM_MODE("720x576i", DRM_MODE_TYPE_DRIVER, 27000, 720, 732,
894                   795, 864, 0, 576, 580, 586, 625, 0,
895                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC |
896                        DRM_MODE_FLAG_INTERLACE | DRM_MODE_FLAG_DBLCLK),
897          .vrefresh = 100, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
898        /* 46 - 1920x1080i@120Hz */
899        { DRM_MODE("1920x1080i", DRM_MODE_TYPE_DRIVER, 148500, 1920, 2008,
900                   2052, 2200, 0, 1080, 1084, 1094, 1125, 0,
901                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC |
902                        DRM_MODE_FLAG_INTERLACE),
903          .vrefresh = 120, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
904        /* 47 - 1280x720@120Hz */
905        { DRM_MODE("1280x720", DRM_MODE_TYPE_DRIVER, 148500, 1280, 1390,
906                   1430, 1650, 0, 720, 725, 730, 750, 0,
907                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
908          .vrefresh = 120, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
909        /* 48 - 720x480@120Hz */
910        { DRM_MODE("720x480", DRM_MODE_TYPE_DRIVER, 54000, 720, 736,
911                   798, 858, 0, 480, 489, 495, 525, 0,
912                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
913          .vrefresh = 120, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_4_3, },
914        /* 49 - 720x480@120Hz */
915        { DRM_MODE("720x480", DRM_MODE_TYPE_DRIVER, 54000, 720, 736,
916                   798, 858, 0, 480, 489, 495, 525, 0,
917                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
918          .vrefresh = 120, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
919        /* 50 - 720(1440)x480i@120Hz */
920        { DRM_MODE("720x480i", DRM_MODE_TYPE_DRIVER, 27000, 720, 739,
921                   801, 858, 0, 480, 488, 494, 525, 0,
922                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC |
923                        DRM_MODE_FLAG_INTERLACE | DRM_MODE_FLAG_DBLCLK),
924          .vrefresh = 120, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_4_3, },
925        /* 51 - 720(1440)x480i@120Hz */
926        { DRM_MODE("720x480i", DRM_MODE_TYPE_DRIVER, 27000, 720, 739,
927                   801, 858, 0, 480, 488, 494, 525, 0,
928                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC |
929                        DRM_MODE_FLAG_INTERLACE | DRM_MODE_FLAG_DBLCLK),
930          .vrefresh = 120, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
931        /* 52 - 720x576@200Hz */
932        { DRM_MODE("720x576", DRM_MODE_TYPE_DRIVER, 108000, 720, 732,
933                   796, 864, 0, 576, 581, 586, 625, 0,
934                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
935          .vrefresh = 200, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_4_3, },
936        /* 53 - 720x576@200Hz */
937        { DRM_MODE("720x576", DRM_MODE_TYPE_DRIVER, 108000, 720, 732,
938                   796, 864, 0, 576, 581, 586, 625, 0,
939                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
940          .vrefresh = 200, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
941        /* 54 - 720(1440)x576i@200Hz */
942        { DRM_MODE("720x576i", DRM_MODE_TYPE_DRIVER, 54000, 720, 732,
943                   795, 864, 0, 576, 580, 586, 625, 0,
944                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC |
945                        DRM_MODE_FLAG_INTERLACE | DRM_MODE_FLAG_DBLCLK),
946          .vrefresh = 200, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_4_3, },
947        /* 55 - 720(1440)x576i@200Hz */
948        { DRM_MODE("720x576i", DRM_MODE_TYPE_DRIVER, 54000, 720, 732,
949                   795, 864, 0, 576, 580, 586, 625, 0,
950                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC |
951                        DRM_MODE_FLAG_INTERLACE | DRM_MODE_FLAG_DBLCLK),
952          .vrefresh = 200, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
953        /* 56 - 720x480@240Hz */
954        { DRM_MODE("720x480", DRM_MODE_TYPE_DRIVER, 108000, 720, 736,
955                   798, 858, 0, 480, 489, 495, 525, 0,
956                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
957          .vrefresh = 240, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_4_3, },
958        /* 57 - 720x480@240Hz */
959        { DRM_MODE("720x480", DRM_MODE_TYPE_DRIVER, 108000, 720, 736,
960                   798, 858, 0, 480, 489, 495, 525, 0,
961                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
962          .vrefresh = 240, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
963        /* 58 - 720(1440)x480i@240 */
964        { DRM_MODE("720x480i", DRM_MODE_TYPE_DRIVER, 54000, 720, 739,
965                   801, 858, 0, 480, 488, 494, 525, 0,
966                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC |
967                        DRM_MODE_FLAG_INTERLACE | DRM_MODE_FLAG_DBLCLK),
968          .vrefresh = 240, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_4_3, },
969        /* 59 - 720(1440)x480i@240 */
970        { DRM_MODE("720x480i", DRM_MODE_TYPE_DRIVER, 54000, 720, 739,
971                   801, 858, 0, 480, 488, 494, 525, 0,
972                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC |
973                        DRM_MODE_FLAG_INTERLACE | DRM_MODE_FLAG_DBLCLK),
974          .vrefresh = 240, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
975        /* 60 - 1280x720@24Hz */
976        { DRM_MODE("1280x720", DRM_MODE_TYPE_DRIVER, 59400, 1280, 3040,
977                   3080, 3300, 0, 720, 725, 730, 750, 0,
978                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
979          .vrefresh = 24, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
980        /* 61 - 1280x720@25Hz */
981        { DRM_MODE("1280x720", DRM_MODE_TYPE_DRIVER, 74250, 1280, 3700,
982                   3740, 3960, 0, 720, 725, 730, 750, 0,
983                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
984          .vrefresh = 25, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
985        /* 62 - 1280x720@30Hz */
986        { DRM_MODE("1280x720", DRM_MODE_TYPE_DRIVER, 74250, 1280, 3040,
987                   3080, 3300, 0, 720, 725, 730, 750, 0,
988                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
989          .vrefresh = 30, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
990        /* 63 - 1920x1080@120Hz */
991        { DRM_MODE("1920x1080", DRM_MODE_TYPE_DRIVER, 297000, 1920, 2008,
992                   2052, 2200, 0, 1080, 1084, 1089, 1125, 0,
993                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
994         .vrefresh = 120, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
995        /* 64 - 1920x1080@100Hz */
996        { DRM_MODE("1920x1080", DRM_MODE_TYPE_DRIVER, 297000, 1920, 2448,
997                   2492, 2640, 0, 1080, 1084, 1089, 1125, 0,
998                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
999         .vrefresh = 100, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
1000};
1001
1002/*
1003 * HDMI 1.4 4k modes. Index using the VIC.
1004 */
1005static const struct drm_display_mode edid_4k_modes[] = {
1006        /* 0 - dummy, VICs start at 1 */
1007        { },
1008        /* 1 - 3840x2160@30Hz */
1009        { DRM_MODE("3840x2160", DRM_MODE_TYPE_DRIVER, 297000,
1010                   3840, 4016, 4104, 4400, 0,
1011                   2160, 2168, 2178, 2250, 0,
1012                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
1013          .vrefresh = 30, },
1014        /* 2 - 3840x2160@25Hz */
1015        { DRM_MODE("3840x2160", DRM_MODE_TYPE_DRIVER, 297000,
1016                   3840, 4896, 4984, 5280, 0,
1017                   2160, 2168, 2178, 2250, 0,
1018                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
1019          .vrefresh = 25, },
1020        /* 3 - 3840x2160@24Hz */
1021        { DRM_MODE("3840x2160", DRM_MODE_TYPE_DRIVER, 297000,
1022                   3840, 5116, 5204, 5500, 0,
1023                   2160, 2168, 2178, 2250, 0,
1024                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
1025          .vrefresh = 24, },
1026        /* 4 - 4096x2160@24Hz (SMPTE) */
1027        { DRM_MODE("4096x2160", DRM_MODE_TYPE_DRIVER, 297000,
1028                   4096, 5116, 5204, 5500, 0,
1029                   2160, 2168, 2178, 2250, 0,
1030                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
1031          .vrefresh = 24, },
1032};
1033
1034/*** DDC fetch and block validation ***/
1035
1036static const u8 edid_header[] = {
1037        0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00
1038};
1039
1040/**
1041 * drm_edid_header_is_valid - sanity check the header of the base EDID block
1042 * @raw_edid: pointer to raw base EDID block
1043 *
1044 * Sanity check the header of the base EDID block.
1045 *
1046 * Return: 8 if the header is perfect, down to 0 if it's totally wrong.
1047 */
1048int drm_edid_header_is_valid(const u8 *raw_edid)
1049{
1050        int i, score = 0;
1051
1052        for (i = 0; i < sizeof(edid_header); i++)
1053                if (raw_edid[i] == edid_header[i])
1054                        score++;
1055
1056        return score;
1057}
1058EXPORT_SYMBOL(drm_edid_header_is_valid);
1059
1060static int edid_fixup __read_mostly = 6;
1061module_param_named(edid_fixup, edid_fixup, int, 0400);
1062MODULE_PARM_DESC(edid_fixup,
1063                 "Minimum number of valid EDID header bytes (0-8, default 6)");
1064
1065static void drm_get_displayid(struct drm_connector *connector,
1066                              struct edid *edid);
1067
1068static int drm_edid_block_checksum(const u8 *raw_edid)
1069{
1070        int i;
1071        u8 csum = 0;
1072        for (i = 0; i < EDID_LENGTH; i++)
1073                csum += raw_edid[i];
1074
1075        return csum;
1076}
1077
1078static bool drm_edid_is_zero(const u8 *in_edid, int length)
1079{
1080        if (memchr_inv(in_edid, 0, length))
1081                return false;
1082
1083        return true;
1084}
1085
1086/**
1087 * drm_edid_block_valid - Sanity check the EDID block (base or extension)
1088 * @raw_edid: pointer to raw EDID block
1089 * @block: type of block to validate (0 for base, extension otherwise)
1090 * @print_bad_edid: if true, dump bad EDID blocks to the console
1091 * @edid_corrupt: if true, the header or checksum is invalid
1092 *
1093 * Validate a base or extension EDID block and optionally dump bad blocks to
1094 * the console.
1095 *
1096 * Return: True if the block is valid, false otherwise.
1097 */
1098bool drm_edid_block_valid(u8 *raw_edid, int block, bool print_bad_edid,
1099                          bool *edid_corrupt)
1100{
1101        u8 csum;
1102        struct edid *edid = (struct edid *)raw_edid;
1103
1104        if (WARN_ON(!raw_edid))
1105                return false;
1106
1107        if (edid_fixup > 8 || edid_fixup < 0)
1108                edid_fixup = 6;
1109
1110        if (block == 0) {
1111                int score = drm_edid_header_is_valid(raw_edid);
1112                if (score == 8) {
1113                        if (edid_corrupt)
1114                                *edid_corrupt = false;
1115                } else if (score >= edid_fixup) {
1116                        /* Displayport Link CTS Core 1.2 rev1.1 test 4.2.2.6
1117                         * The corrupt flag needs to be set here otherwise, the
1118                         * fix-up code here will correct the problem, the
1119                         * checksum is correct and the test fails
1120                         */
1121                        if (edid_corrupt)
1122                                *edid_corrupt = true;
1123                        DRM_DEBUG("Fixing EDID header, your hardware may be failing\n");
1124                        memcpy(raw_edid, edid_header, sizeof(edid_header));
1125                } else {
1126                        if (edid_corrupt)
1127                                *edid_corrupt = true;
1128                        goto bad;
1129                }
1130        }
1131
1132        csum = drm_edid_block_checksum(raw_edid);
1133        if (csum) {
1134                if (print_bad_edid) {
1135                        DRM_ERROR("EDID checksum is invalid, remainder is %d\n", csum);
1136                }
1137
1138                if (edid_corrupt)
1139                        *edid_corrupt = true;
1140
1141                /* allow CEA to slide through, switches mangle this */
1142                if (raw_edid[0] != 0x02)
1143                        goto bad;
1144        }
1145
1146        /* per-block-type checks */
1147        switch (raw_edid[0]) {
1148        case 0: /* base */
1149                if (edid->version != 1) {
1150                        DRM_ERROR("EDID has major version %d, instead of 1\n", edid->version);
1151                        goto bad;
1152                }
1153
1154                if (edid->revision > 4)
1155                        DRM_DEBUG("EDID minor > 4, assuming backward compatibility\n");
1156                break;
1157
1158        default:
1159                break;
1160        }
1161
1162        return true;
1163
1164bad:
1165        if (print_bad_edid) {
1166                if (drm_edid_is_zero(raw_edid, EDID_LENGTH)) {
1167                        printk(KERN_ERR "EDID block is all zeroes\n");
1168                } else {
1169                        printk(KERN_ERR "Raw EDID:\n");
1170                        print_hex_dump(KERN_ERR, " \t", DUMP_PREFIX_NONE, 16, 1,
1171                               raw_edid, EDID_LENGTH, false);
1172                }
1173        }
1174        return false;
1175}
1176EXPORT_SYMBOL(drm_edid_block_valid);
1177
1178/**
1179 * drm_edid_is_valid - sanity check EDID data
1180 * @edid: EDID data
1181 *
1182 * Sanity-check an entire EDID record (including extensions)
1183 *
1184 * Return: True if the EDID data is valid, false otherwise.
1185 */
1186bool drm_edid_is_valid(struct edid *edid)
1187{
1188        int i;
1189        u8 *raw = (u8 *)edid;
1190
1191        if (!edid)
1192                return false;
1193
1194        for (i = 0; i <= edid->extensions; i++)
1195                if (!drm_edid_block_valid(raw + i * EDID_LENGTH, i, true, NULL))
1196                        return false;
1197
1198        return true;
1199}
1200EXPORT_SYMBOL(drm_edid_is_valid);
1201
1202#define DDC_SEGMENT_ADDR 0x30
1203/**
1204 * drm_do_probe_ddc_edid() - get EDID information via I2C
1205 * @data: I2C device adapter
1206 * @buf: EDID data buffer to be filled
1207 * @block: 128 byte EDID block to start fetching from
1208 * @len: EDID data buffer length to fetch
1209 *
1210 * Try to fetch EDID information by calling I2C driver functions.
1211 *
1212 * Return: 0 on success or -1 on failure.
1213 */
1214static int
1215drm_do_probe_ddc_edid(void *data, u8 *buf, unsigned int block, size_t len)
1216{
1217        struct i2c_adapter *adapter = data;
1218        unsigned char start = block * EDID_LENGTH;
1219        unsigned char segment = block >> 1;
1220        unsigned char xfers = segment ? 3 : 2;
1221        int ret, retries = 5;
1222
1223        /*
1224         * The core I2C driver will automatically retry the transfer if the
1225         * adapter reports EAGAIN. However, we find that bit-banging transfers
1226         * are susceptible to errors under a heavily loaded machine and
1227         * generate spurious NAKs and timeouts. Retrying the transfer
1228         * of the individual block a few times seems to overcome this.
1229         */
1230        do {
1231                struct i2c_msg msgs[] = {
1232                        {
1233                                .addr   = DDC_SEGMENT_ADDR,
1234                                .flags  = 0,
1235                                .len    = 1,
1236                                .buf    = &segment,
1237                        }, {
1238                                .addr   = DDC_ADDR,
1239                                .flags  = 0,
1240                                .len    = 1,
1241                                .buf    = &start,
1242                        }, {
1243                                .addr   = DDC_ADDR,
1244                                .flags  = I2C_M_RD,
1245                                .len    = len,
1246                                .buf    = buf,
1247                        }
1248                };
1249
1250                /*
1251                 * Avoid sending the segment addr to not upset non-compliant
1252                 * DDC monitors.
1253                 */
1254                ret = i2c_transfer(adapter, &msgs[3 - xfers], xfers);
1255
1256                if (ret == -ENXIO) {
1257                        DRM_DEBUG_KMS("drm: skipping non-existent adapter %s\n",
1258                                        adapter->name);
1259                        break;
1260                }
1261        } while (ret != xfers && --retries);
1262
1263        return ret == xfers ? 0 : -1;
1264}
1265
1266/**
1267 * drm_do_get_edid - get EDID data using a custom EDID block read function
1268 * @connector: connector we're probing
1269 * @get_edid_block: EDID block read function
1270 * @data: private data passed to the block read function
1271 *
1272 * When the I2C adapter connected to the DDC bus is hidden behind a device that
1273 * exposes a different interface to read EDID blocks this function can be used
1274 * to get EDID data using a custom block read function.
1275 *
1276 * As in the general case the DDC bus is accessible by the kernel at the I2C
1277 * level, drivers must make all reasonable efforts to expose it as an I2C
1278 * adapter and use drm_get_edid() instead of abusing this function.
1279 *
1280 * Return: Pointer to valid EDID or NULL if we couldn't find any.
1281 */
1282struct edid *drm_do_get_edid(struct drm_connector *connector,
1283        int (*get_edid_block)(void *data, u8 *buf, unsigned int block,
1284                              size_t len),
1285        void *data)
1286{
1287        int i, j = 0, valid_extensions = 0;
1288        u8 *block, *new;
1289        bool print_bad_edid = !connector->bad_edid_counter || (drm_debug & DRM_UT_KMS);
1290
1291        if ((block = kmalloc(EDID_LENGTH, GFP_KERNEL)) == NULL)
1292                return NULL;
1293
1294        /* base block fetch */
1295        for (i = 0; i < 4; i++) {
1296                if (get_edid_block(data, block, 0, EDID_LENGTH))
1297                        goto out;
1298                if (drm_edid_block_valid(block, 0, print_bad_edid,
1299                                         &connector->edid_corrupt))
1300                        break;
1301                if (i == 0 && drm_edid_is_zero(block, EDID_LENGTH)) {
1302                        connector->null_edid_counter++;
1303                        goto carp;
1304                }
1305        }
1306        if (i == 4)
1307                goto carp;
1308
1309        /* if there's no extensions, we're done */
1310        if (block[0x7e] == 0)
1311                return (struct edid *)block;
1312
1313        new = krealloc(block, (block[0x7e] + 1) * EDID_LENGTH, GFP_KERNEL);
1314        if (!new)
1315                goto out;
1316        block = new;
1317
1318        for (j = 1; j <= block[0x7e]; j++) {
1319                for (i = 0; i < 4; i++) {
1320                        if (get_edid_block(data,
1321                                  block + (valid_extensions + 1) * EDID_LENGTH,
1322                                  j, EDID_LENGTH))
1323                                goto out;
1324                        if (drm_edid_block_valid(block + (valid_extensions + 1)
1325                                                 * EDID_LENGTH, j,
1326                                                 print_bad_edid,
1327                                                 NULL)) {
1328                                valid_extensions++;
1329                                break;
1330                        }
1331                }
1332
1333                if (i == 4 && print_bad_edid) {
1334                        dev_warn(connector->dev->dev,
1335                         "%s: Ignoring invalid EDID block %d.\n",
1336                         connector->name, j);
1337
1338                        connector->bad_edid_counter++;
1339                }
1340        }
1341
1342        if (valid_extensions != block[0x7e]) {
1343                block[EDID_LENGTH-1] += block[0x7e] - valid_extensions;
1344                block[0x7e] = valid_extensions;
1345                new = krealloc(block, (valid_extensions + 1) * EDID_LENGTH, GFP_KERNEL);
1346                if (!new)
1347                        goto out;
1348                block = new;
1349        }
1350
1351        return (struct edid *)block;
1352
1353carp:
1354        if (print_bad_edid) {
1355                dev_warn(connector->dev->dev, "%s: EDID block %d invalid.\n",
1356                         connector->name, j);
1357        }
1358        connector->bad_edid_counter++;
1359
1360out:
1361        kfree(block);
1362        return NULL;
1363}
1364EXPORT_SYMBOL_GPL(drm_do_get_edid);
1365
1366/**
1367 * drm_probe_ddc() - probe DDC presence
1368 * @adapter: I2C adapter to probe
1369 *
1370 * Return: True on success, false on failure.
1371 */
1372bool
1373drm_probe_ddc(struct i2c_adapter *adapter)
1374{
1375        unsigned char out;
1376
1377        return (drm_do_probe_ddc_edid(adapter, &out, 0, 1) == 0);
1378}
1379EXPORT_SYMBOL(drm_probe_ddc);
1380
1381/**
1382 * drm_get_edid - get EDID data, if available
1383 * @connector: connector we're probing
1384 * @adapter: I2C adapter to use for DDC
1385 *
1386 * Poke the given I2C channel to grab EDID data if possible.  If found,
1387 * attach it to the connector.
1388 *
1389 * Return: Pointer to valid EDID or NULL if we couldn't find any.
1390 */
1391struct edid *drm_get_edid(struct drm_connector *connector,
1392                          struct i2c_adapter *adapter)
1393{
1394        struct edid *edid;
1395
1396        if (!drm_probe_ddc(adapter))
1397                return NULL;
1398
1399        edid = drm_do_get_edid(connector, drm_do_probe_ddc_edid, adapter);
1400        if (edid)
1401                drm_get_displayid(connector, edid);
1402        return edid;
1403}
1404EXPORT_SYMBOL(drm_get_edid);
1405
1406/**
1407 * drm_get_edid_switcheroo - get EDID data for a vga_switcheroo output
1408 * @connector: connector we're probing
1409 * @adapter: I2C adapter to use for DDC
1410 *
1411 * Wrapper around drm_get_edid() for laptops with dual GPUs using one set of
1412 * outputs. The wrapper adds the requisite vga_switcheroo calls to temporarily
1413 * switch DDC to the GPU which is retrieving EDID.
1414 *
1415 * Return: Pointer to valid EDID or %NULL if we couldn't find any.
1416 */
1417struct edid *drm_get_edid_switcheroo(struct drm_connector *connector,
1418                                     struct i2c_adapter *adapter)
1419{
1420        struct pci_dev *pdev = connector->dev->pdev;
1421        struct edid *edid;
1422
1423        vga_switcheroo_lock_ddc(pdev);
1424        edid = drm_get_edid(connector, adapter);
1425        vga_switcheroo_unlock_ddc(pdev);
1426
1427        return edid;
1428}
1429EXPORT_SYMBOL(drm_get_edid_switcheroo);
1430
1431/**
1432 * drm_edid_duplicate - duplicate an EDID and the extensions
1433 * @edid: EDID to duplicate
1434 *
1435 * Return: Pointer to duplicated EDID or NULL on allocation failure.
1436 */
1437struct edid *drm_edid_duplicate(const struct edid *edid)
1438{
1439        return kmemdup(edid, (edid->extensions + 1) * EDID_LENGTH, GFP_KERNEL);
1440}
1441EXPORT_SYMBOL(drm_edid_duplicate);
1442
1443/*** EDID parsing ***/
1444
1445/**
1446 * edid_vendor - match a string against EDID's obfuscated vendor field
1447 * @edid: EDID to match
1448 * @vendor: vendor string
1449 *
1450 * Returns true if @vendor is in @edid, false otherwise
1451 */
1452static bool edid_vendor(struct edid *edid, const char *vendor)
1453{
1454        char edid_vendor[3];
1455
1456        edid_vendor[0] = ((edid->mfg_id[0] & 0x7c) >> 2) + '@';
1457        edid_vendor[1] = (((edid->mfg_id[0] & 0x3) << 3) |
1458                          ((edid->mfg_id[1] & 0xe0) >> 5)) + '@';
1459        edid_vendor[2] = (edid->mfg_id[1] & 0x1f) + '@';
1460
1461        return !strncmp(edid_vendor, vendor, 3);
1462}
1463
1464/**
1465 * edid_get_quirks - return quirk flags for a given EDID
1466 * @edid: EDID to process
1467 *
1468 * This tells subsequent routines what fixes they need to apply.
1469 */
1470static u32 edid_get_quirks(struct edid *edid)
1471{
1472        const struct edid_quirk *quirk;
1473        int i;
1474
1475        for (i = 0; i < ARRAY_SIZE(edid_quirk_list); i++) {
1476                quirk = &edid_quirk_list[i];
1477
1478                if (edid_vendor(edid, quirk->vendor) &&
1479                    (EDID_PRODUCT_ID(edid) == quirk->product_id))
1480                        return quirk->quirks;
1481        }
1482
1483        return 0;
1484}
1485
1486#define MODE_SIZE(m) ((m)->hdisplay * (m)->vdisplay)
1487#define MODE_REFRESH_DIFF(c,t) (abs((c) - (t)))
1488
1489/**
1490 * edid_fixup_preferred - set preferred modes based on quirk list
1491 * @connector: has mode list to fix up
1492 * @quirks: quirks list
1493 *
1494 * Walk the mode list for @connector, clearing the preferred status
1495 * on existing modes and setting it anew for the right mode ala @quirks.
1496 */
1497static void edid_fixup_preferred(struct drm_connector *connector,
1498                                 u32 quirks)
1499{
1500        struct drm_display_mode *t, *cur_mode, *preferred_mode;
1501        int target_refresh = 0;
1502        int cur_vrefresh, preferred_vrefresh;
1503
1504        if (list_empty(&connector->probed_modes))
1505                return;
1506
1507        if (quirks & EDID_QUIRK_PREFER_LARGE_60)
1508                target_refresh = 60;
1509        if (quirks & EDID_QUIRK_PREFER_LARGE_75)
1510                target_refresh = 75;
1511
1512        preferred_mode = list_first_entry(&connector->probed_modes,
1513                                          struct drm_display_mode, head);
1514
1515        list_for_each_entry_safe(cur_mode, t, &connector->probed_modes, head) {
1516                cur_mode->type &= ~DRM_MODE_TYPE_PREFERRED;
1517
1518                if (cur_mode == preferred_mode)
1519                        continue;
1520
1521                /* Largest mode is preferred */
1522                if (MODE_SIZE(cur_mode) > MODE_SIZE(preferred_mode))
1523                        preferred_mode = cur_mode;
1524
1525                cur_vrefresh = cur_mode->vrefresh ?
1526                        cur_mode->vrefresh : drm_mode_vrefresh(cur_mode);
1527                preferred_vrefresh = preferred_mode->vrefresh ?
1528                        preferred_mode->vrefresh : drm_mode_vrefresh(preferred_mode);
1529                /* At a given size, try to get closest to target refresh */
1530                if ((MODE_SIZE(cur_mode) == MODE_SIZE(preferred_mode)) &&
1531                    MODE_REFRESH_DIFF(cur_vrefresh, target_refresh) <
1532                    MODE_REFRESH_DIFF(preferred_vrefresh, target_refresh)) {
1533                        preferred_mode = cur_mode;
1534                }
1535        }
1536
1537        preferred_mode->type |= DRM_MODE_TYPE_PREFERRED;
1538}
1539
1540static bool
1541mode_is_rb(const struct drm_display_mode *mode)
1542{
1543        return (mode->htotal - mode->hdisplay == 160) &&
1544               (mode->hsync_end - mode->hdisplay == 80) &&
1545               (mode->hsync_end - mode->hsync_start == 32) &&
1546               (mode->vsync_start - mode->vdisplay == 3);
1547}
1548
1549/*
1550 * drm_mode_find_dmt - Create a copy of a mode if present in DMT
1551 * @dev: Device to duplicate against
1552 * @hsize: Mode width
1553 * @vsize: Mode height
1554 * @fresh: Mode refresh rate
1555 * @rb: Mode reduced-blanking-ness
1556 *
1557 * Walk the DMT mode list looking for a match for the given parameters.
1558 *
1559 * Return: A newly allocated copy of the mode, or NULL if not found.
1560 */
1561struct drm_display_mode *drm_mode_find_dmt(struct drm_device *dev,
1562                                           int hsize, int vsize, int fresh,
1563                                           bool rb)
1564{
1565        int i;
1566
1567        for (i = 0; i < ARRAY_SIZE(drm_dmt_modes); i++) {
1568                const struct drm_display_mode *ptr = &drm_dmt_modes[i];
1569                if (hsize != ptr->hdisplay)
1570                        continue;
1571                if (vsize != ptr->vdisplay)
1572                        continue;
1573                if (fresh != drm_mode_vrefresh(ptr))
1574                        continue;
1575                if (rb != mode_is_rb(ptr))
1576                        continue;
1577
1578                return drm_mode_duplicate(dev, ptr);
1579        }
1580
1581        return NULL;
1582}
1583EXPORT_SYMBOL(drm_mode_find_dmt);
1584
1585typedef void detailed_cb(struct detailed_timing *timing, void *closure);
1586
1587static void
1588cea_for_each_detailed_block(u8 *ext, detailed_cb *cb, void *closure)
1589{
1590        int i, n = 0;
1591        u8 d = ext[0x02];
1592        u8 *det_base = ext + d;
1593
1594        n = (127 - d) / 18;
1595        for (i = 0; i < n; i++)
1596                cb((struct detailed_timing *)(det_base + 18 * i), closure);
1597}
1598
1599static void
1600vtb_for_each_detailed_block(u8 *ext, detailed_cb *cb, void *closure)
1601{
1602        unsigned int i, n = min((int)ext[0x02], 6);
1603        u8 *det_base = ext + 5;
1604
1605        if (ext[0x01] != 1)
1606                return; /* unknown version */
1607
1608        for (i = 0; i < n; i++)
1609                cb((struct detailed_timing *)(det_base + 18 * i), closure);
1610}
1611
1612static void
1613drm_for_each_detailed_block(u8 *raw_edid, detailed_cb *cb, void *closure)
1614{
1615        int i;
1616        struct edid *edid = (struct edid *)raw_edid;
1617
1618        if (edid == NULL)
1619                return;
1620
1621        for (i = 0; i < EDID_DETAILED_TIMINGS; i++)
1622                cb(&(edid->detailed_timings[i]), closure);
1623
1624        for (i = 1; i <= raw_edid[0x7e]; i++) {
1625                u8 *ext = raw_edid + (i * EDID_LENGTH);
1626                switch (*ext) {
1627                case CEA_EXT:
1628                        cea_for_each_detailed_block(ext, cb, closure);
1629                        break;
1630                case VTB_EXT:
1631                        vtb_for_each_detailed_block(ext, cb, closure);
1632                        break;
1633                default:
1634                        break;
1635                }
1636        }
1637}
1638
1639static void
1640is_rb(struct detailed_timing *t, void *data)
1641{
1642        u8 *r = (u8 *)t;
1643        if (r[3] == EDID_DETAIL_MONITOR_RANGE)
1644                if (r[15] & 0x10)
1645                        *(bool *)data = true;
1646}
1647
1648/* EDID 1.4 defines this explicitly.  For EDID 1.3, we guess, badly. */
1649static bool
1650drm_monitor_supports_rb(struct edid *edid)
1651{
1652        if (edid->revision >= 4) {
1653                bool ret = false;
1654                drm_for_each_detailed_block((u8 *)edid, is_rb, &ret);
1655                return ret;
1656        }
1657
1658        return ((edid->input & DRM_EDID_INPUT_DIGITAL) != 0);
1659}
1660
1661static void
1662find_gtf2(struct detailed_timing *t, void *data)
1663{
1664        u8 *r = (u8 *)t;
1665        if (r[3] == EDID_DETAIL_MONITOR_RANGE && r[10] == 0x02)
1666                *(u8 **)data = r;
1667}
1668
1669/* Secondary GTF curve kicks in above some break frequency */
1670static int
1671drm_gtf2_hbreak(struct edid *edid)
1672{
1673        u8 *r = NULL;
1674        drm_for_each_detailed_block((u8 *)edid, find_gtf2, &r);
1675        return r ? (r[12] * 2) : 0;
1676}
1677
1678static int
1679drm_gtf2_2c(struct edid *edid)
1680{
1681        u8 *r = NULL;
1682        drm_for_each_detailed_block((u8 *)edid, find_gtf2, &r);
1683        return r ? r[13] : 0;
1684}
1685
1686static int
1687drm_gtf2_m(struct edid *edid)
1688{
1689        u8 *r = NULL;
1690        drm_for_each_detailed_block((u8 *)edid, find_gtf2, &r);
1691        return r ? (r[15] << 8) + r[14] : 0;
1692}
1693
1694static int
1695drm_gtf2_k(struct edid *edid)
1696{
1697        u8 *r = NULL;
1698        drm_for_each_detailed_block((u8 *)edid, find_gtf2, &r);
1699        return r ? r[16] : 0;
1700}
1701
1702static int
1703drm_gtf2_2j(struct edid *edid)
1704{
1705        u8 *r = NULL;
1706        drm_for_each_detailed_block((u8 *)edid, find_gtf2, &r);
1707        return r ? r[17] : 0;
1708}
1709
1710/**
1711 * standard_timing_level - get std. timing level(CVT/GTF/DMT)
1712 * @edid: EDID block to scan
1713 */
1714static int standard_timing_level(struct edid *edid)
1715{
1716        if (edid->revision >= 2) {
1717                if (edid->revision >= 4 && (edid->features & DRM_EDID_FEATURE_DEFAULT_GTF))
1718                        return LEVEL_CVT;
1719                if (drm_gtf2_hbreak(edid))
1720                        return LEVEL_GTF2;
1721                return LEVEL_GTF;
1722        }
1723        return LEVEL_DMT;
1724}
1725
1726/*
1727 * 0 is reserved.  The spec says 0x01 fill for unused timings.  Some old
1728 * monitors fill with ascii space (0x20) instead.
1729 */
1730static int
1731bad_std_timing(u8 a, u8 b)
1732{
1733        return (a == 0x00 && b == 0x00) ||
1734               (a == 0x01 && b == 0x01) ||
1735               (a == 0x20 && b == 0x20);
1736}
1737
1738/**
1739 * drm_mode_std - convert standard mode info (width, height, refresh) into mode
1740 * @connector: connector of for the EDID block
1741 * @edid: EDID block to scan
1742 * @t: standard timing params
1743 *
1744 * Take the standard timing params (in this case width, aspect, and refresh)
1745 * and convert them into a real mode using CVT/GTF/DMT.
1746 */
1747static struct drm_display_mode *
1748drm_mode_std(struct drm_connector *connector, struct edid *edid,
1749             struct std_timing *t)
1750{
1751        struct drm_device *dev = connector->dev;
1752        struct drm_display_mode *m, *mode = NULL;
1753        int hsize, vsize;
1754        int vrefresh_rate;
1755        unsigned aspect_ratio = (t->vfreq_aspect & EDID_TIMING_ASPECT_MASK)
1756                >> EDID_TIMING_ASPECT_SHIFT;
1757        unsigned vfreq = (t->vfreq_aspect & EDID_TIMING_VFREQ_MASK)
1758                >> EDID_TIMING_VFREQ_SHIFT;
1759        int timing_level = standard_timing_level(edid);
1760
1761        if (bad_std_timing(t->hsize, t->vfreq_aspect))
1762                return NULL;
1763
1764        /* According to the EDID spec, the hdisplay = hsize * 8 + 248 */
1765        hsize = t->hsize * 8 + 248;
1766        /* vrefresh_rate = vfreq + 60 */
1767        vrefresh_rate = vfreq + 60;
1768        /* the vdisplay is calculated based on the aspect ratio */
1769        if (aspect_ratio == 0) {
1770                if (edid->revision < 3)
1771                        vsize = hsize;
1772                else
1773                        vsize = (hsize * 10) / 16;
1774        } else if (aspect_ratio == 1)
1775                vsize = (hsize * 3) / 4;
1776        else if (aspect_ratio == 2)
1777                vsize = (hsize * 4) / 5;
1778        else
1779                vsize = (hsize * 9) / 16;
1780
1781        /* HDTV hack, part 1 */
1782        if (vrefresh_rate == 60 &&
1783            ((hsize == 1360 && vsize == 765) ||
1784             (hsize == 1368 && vsize == 769))) {
1785                hsize = 1366;
1786                vsize = 768;
1787        }
1788
1789        /*
1790         * If this connector already has a mode for this size and refresh
1791         * rate (because it came from detailed or CVT info), use that
1792         * instead.  This way we don't have to guess at interlace or
1793         * reduced blanking.
1794         */
1795        list_for_each_entry(m, &connector->probed_modes, head)
1796                if (m->hdisplay == hsize && m->vdisplay == vsize &&
1797                    drm_mode_vrefresh(m) == vrefresh_rate)
1798                        return NULL;
1799
1800        /* HDTV hack, part 2 */
1801        if (hsize == 1366 && vsize == 768 && vrefresh_rate == 60) {
1802                mode = drm_cvt_mode(dev, 1366, 768, vrefresh_rate, 0, 0,
1803                                    false);
1804                mode->hdisplay = 1366;
1805                mode->hsync_start = mode->hsync_start - 1;
1806                mode->hsync_end = mode->hsync_end - 1;
1807                return mode;
1808        }
1809
1810        /* check whether it can be found in default mode table */
1811        if (drm_monitor_supports_rb(edid)) {
1812                mode = drm_mode_find_dmt(dev, hsize, vsize, vrefresh_rate,
1813                                         true);
1814                if (mode)
1815                        return mode;
1816        }
1817        mode = drm_mode_find_dmt(dev, hsize, vsize, vrefresh_rate, false);
1818        if (mode)
1819                return mode;
1820
1821        /* okay, generate it */
1822        switch (timing_level) {
1823        case LEVEL_DMT:
1824                break;
1825        case LEVEL_GTF:
1826                mode = drm_gtf_mode(dev, hsize, vsize, vrefresh_rate, 0, 0);
1827                break;
1828        case LEVEL_GTF2:
1829                /*
1830                 * This is potentially wrong if there's ever a monitor with
1831                 * more than one ranges section, each claiming a different
1832                 * secondary GTF curve.  Please don't do that.
1833                 */
1834                mode = drm_gtf_mode(dev, hsize, vsize, vrefresh_rate, 0, 0);
1835                if (!mode)
1836                        return NULL;
1837                if (drm_mode_hsync(mode) > drm_gtf2_hbreak(edid)) {
1838                        drm_mode_destroy(dev, mode);
1839                        mode = drm_gtf_mode_complex(dev, hsize, vsize,
1840                                                    vrefresh_rate, 0, 0,
1841                                                    drm_gtf2_m(edid),
1842                                                    drm_gtf2_2c(edid),
1843                                                    drm_gtf2_k(edid),
1844                                                    drm_gtf2_2j(edid));
1845                }
1846                break;
1847        case LEVEL_CVT:
1848                mode = drm_cvt_mode(dev, hsize, vsize, vrefresh_rate, 0, 0,
1849                                    false);
1850                break;
1851        }
1852        return mode;
1853}
1854
1855/*
1856 * EDID is delightfully ambiguous about how interlaced modes are to be
1857 * encoded.  Our internal representation is of frame height, but some
1858 * HDTV detailed timings are encoded as field height.
1859 *
1860 * The format list here is from CEA, in frame size.  Technically we
1861 * should be checking refresh rate too.  Whatever.
1862 */
1863static void
1864drm_mode_do_interlace_quirk(struct drm_display_mode *mode,
1865                            struct detailed_pixel_timing *pt)
1866{
1867        int i;
1868        static const struct {
1869                int w, h;
1870        } cea_interlaced[] = {
1871                { 1920, 1080 },
1872                {  720,  480 },
1873                { 1440,  480 },
1874                { 2880,  480 },
1875                {  720,  576 },
1876                { 1440,  576 },
1877                { 2880,  576 },
1878        };
1879
1880        if (!(pt->misc & DRM_EDID_PT_INTERLACED))
1881                return;
1882
1883        for (i = 0; i < ARRAY_SIZE(cea_interlaced); i++) {
1884                if ((mode->hdisplay == cea_interlaced[i].w) &&
1885                    (mode->vdisplay == cea_interlaced[i].h / 2)) {
1886                        mode->vdisplay *= 2;
1887                        mode->vsync_start *= 2;
1888                        mode->vsync_end *= 2;
1889                        mode->vtotal *= 2;
1890                        mode->vtotal |= 1;
1891                }
1892        }
1893
1894        mode->flags |= DRM_MODE_FLAG_INTERLACE;
1895}
1896
1897/**
1898 * drm_mode_detailed - create a new mode from an EDID detailed timing section
1899 * @dev: DRM device (needed to create new mode)
1900 * @edid: EDID block
1901 * @timing: EDID detailed timing info
1902 * @quirks: quirks to apply
1903 *
1904 * An EDID detailed timing block contains enough info for us to create and
1905 * return a new struct drm_display_mode.
1906 */
1907static struct drm_display_mode *drm_mode_detailed(struct drm_device *dev,
1908                                                  struct edid *edid,
1909                                                  struct detailed_timing *timing,
1910                                                  u32 quirks)
1911{
1912        struct drm_display_mode *mode;
1913        struct detailed_pixel_timing *pt = &timing->data.pixel_data;
1914        unsigned hactive = (pt->hactive_hblank_hi & 0xf0) << 4 | pt->hactive_lo;
1915        unsigned vactive = (pt->vactive_vblank_hi & 0xf0) << 4 | pt->vactive_lo;
1916        unsigned hblank = (pt->hactive_hblank_hi & 0xf) << 8 | pt->hblank_lo;
1917        unsigned vblank = (pt->vactive_vblank_hi & 0xf) << 8 | pt->vblank_lo;
1918        unsigned hsync_offset = (pt->hsync_vsync_offset_pulse_width_hi & 0xc0) << 2 | pt->hsync_offset_lo;
1919        unsigned hsync_pulse_width = (pt->hsync_vsync_offset_pulse_width_hi & 0x30) << 4 | pt->hsync_pulse_width_lo;
1920        unsigned vsync_offset = (pt->hsync_vsync_offset_pulse_width_hi & 0xc) << 2 | pt->vsync_offset_pulse_width_lo >> 4;
1921        unsigned vsync_pulse_width = (pt->hsync_vsync_offset_pulse_width_hi & 0x3) << 4 | (pt->vsync_offset_pulse_width_lo & 0xf);
1922
1923        /* ignore tiny modes */
1924        if (hactive < 64 || vactive < 64)
1925                return NULL;
1926
1927        if (pt->misc & DRM_EDID_PT_STEREO) {
1928                DRM_DEBUG_KMS("stereo mode not supported\n");
1929                return NULL;
1930        }
1931        if (!(pt->misc & DRM_EDID_PT_SEPARATE_SYNC)) {
1932                DRM_DEBUG_KMS("composite sync not supported\n");
1933        }
1934
1935        /* it is incorrect if hsync/vsync width is zero */
1936        if (!hsync_pulse_width || !vsync_pulse_width) {
1937                DRM_DEBUG_KMS("Incorrect Detailed timing. "
1938                                "Wrong Hsync/Vsync pulse width\n");
1939                return NULL;
1940        }
1941
1942        if (quirks & EDID_QUIRK_FORCE_REDUCED_BLANKING) {
1943                mode = drm_cvt_mode(dev, hactive, vactive, 60, true, false, false);
1944                if (!mode)
1945                        return NULL;
1946
1947                goto set_size;
1948        }
1949
1950        mode = drm_mode_create(dev);
1951        if (!mode)
1952                return NULL;
1953
1954        if (quirks & EDID_QUIRK_135_CLOCK_TOO_HIGH)
1955                timing->pixel_clock = cpu_to_le16(1088);
1956
1957        mode->clock = le16_to_cpu(timing->pixel_clock) * 10;
1958
1959        mode->hdisplay = hactive;
1960        mode->hsync_start = mode->hdisplay + hsync_offset;
1961        mode->hsync_end = mode->hsync_start + hsync_pulse_width;
1962        mode->htotal = mode->hdisplay + hblank;
1963
1964        mode->vdisplay = vactive;
1965        mode->vsync_start = mode->vdisplay + vsync_offset;
1966        mode->vsync_end = mode->vsync_start + vsync_pulse_width;
1967        mode->vtotal = mode->vdisplay + vblank;
1968
1969        /* Some EDIDs have bogus h/vtotal values */
1970        if (mode->hsync_end > mode->htotal)
1971                mode->htotal = mode->hsync_end + 1;
1972        if (mode->vsync_end > mode->vtotal)
1973                mode->vtotal = mode->vsync_end + 1;
1974
1975        drm_mode_do_interlace_quirk(mode, pt);
1976
1977        if (quirks & EDID_QUIRK_DETAILED_SYNC_PP) {
1978                pt->misc |= DRM_EDID_PT_HSYNC_POSITIVE | DRM_EDID_PT_VSYNC_POSITIVE;
1979        }
1980
1981        mode->flags |= (pt->misc & DRM_EDID_PT_HSYNC_POSITIVE) ?
1982                DRM_MODE_FLAG_PHSYNC : DRM_MODE_FLAG_NHSYNC;
1983        mode->flags |= (pt->misc & DRM_EDID_PT_VSYNC_POSITIVE) ?
1984                DRM_MODE_FLAG_PVSYNC : DRM_MODE_FLAG_NVSYNC;
1985
1986set_size:
1987        mode->width_mm = pt->width_mm_lo | (pt->width_height_mm_hi & 0xf0) << 4;
1988        mode->height_mm = pt->height_mm_lo | (pt->width_height_mm_hi & 0xf) << 8;
1989
1990        if (quirks & EDID_QUIRK_DETAILED_IN_CM) {
1991                mode->width_mm *= 10;
1992                mode->height_mm *= 10;
1993        }
1994
1995        if (quirks & EDID_QUIRK_DETAILED_USE_MAXIMUM_SIZE) {
1996                mode->width_mm = edid->width_cm * 10;
1997                mode->height_mm = edid->height_cm * 10;
1998        }
1999
2000        mode->type = DRM_MODE_TYPE_DRIVER;
2001        mode->vrefresh = drm_mode_vrefresh(mode);
2002        drm_mode_set_name(mode);
2003
2004        return mode;
2005}
2006
2007static bool
2008mode_in_hsync_range(const struct drm_display_mode *mode,
2009                    struct edid *edid, u8 *t)
2010{
2011        int hsync, hmin, hmax;
2012
2013        hmin = t[7];
2014        if (edid->revision >= 4)
2015            hmin += ((t[4] & 0x04) ? 255 : 0);
2016        hmax = t[8];
2017        if (edid->revision >= 4)
2018            hmax += ((t[4] & 0x08) ? 255 : 0);
2019        hsync = drm_mode_hsync(mode);
2020
2021        return (hsync <= hmax && hsync >= hmin);
2022}
2023
2024static bool
2025mode_in_vsync_range(const struct drm_display_mode *mode,
2026                    struct edid *edid, u8 *t)
2027{
2028        int vsync, vmin, vmax;
2029
2030        vmin = t[5];
2031        if (edid->revision >= 4)
2032            vmin += ((t[4] & 0x01) ? 255 : 0);
2033        vmax = t[6];
2034        if (edid->revision >= 4)
2035            vmax += ((t[4] & 0x02) ? 255 : 0);
2036        vsync = drm_mode_vrefresh(mode);
2037
2038        return (vsync <= vmax && vsync >= vmin);
2039}
2040
2041static u32
2042range_pixel_clock(struct edid *edid, u8 *t)
2043{
2044        /* unspecified */
2045        if (t[9] == 0 || t[9] == 255)
2046                return 0;
2047
2048        /* 1.4 with CVT support gives us real precision, yay */
2049        if (edid->revision >= 4 && t[10] == 0x04)
2050                return (t[9] * 10000) - ((t[12] >> 2) * 250);
2051
2052        /* 1.3 is pathetic, so fuzz up a bit */
2053        return t[9] * 10000 + 5001;
2054}
2055
2056static bool
2057mode_in_range(const struct drm_display_mode *mode, struct edid *edid,
2058              struct detailed_timing *timing)
2059{
2060        u32 max_clock;
2061        u8 *t = (u8 *)timing;
2062
2063        if (!mode_in_hsync_range(mode, edid, t))
2064                return false;
2065
2066        if (!mode_in_vsync_range(mode, edid, t))
2067                return false;
2068
2069        if ((max_clock = range_pixel_clock(edid, t)))
2070                if (mode->clock > max_clock)
2071                        return false;
2072
2073        /* 1.4 max horizontal check */
2074        if (edid->revision >= 4 && t[10] == 0x04)
2075                if (t[13] && mode->hdisplay > 8 * (t[13] + (256 * (t[12]&0x3))))
2076                        return false;
2077
2078        if (mode_is_rb(mode) && !drm_monitor_supports_rb(edid))
2079                return false;
2080
2081        return true;
2082}
2083
2084static bool valid_inferred_mode(const struct drm_connector *connector,
2085                                const struct drm_display_mode *mode)
2086{
2087        const struct drm_display_mode *m;
2088        bool ok = false;
2089
2090        list_for_each_entry(m, &connector->probed_modes, head) {
2091                if (mode->hdisplay == m->hdisplay &&
2092                    mode->vdisplay == m->vdisplay &&
2093                    drm_mode_vrefresh(mode) == drm_mode_vrefresh(m))
2094                        return false; /* duplicated */
2095                if (mode->hdisplay <= m->hdisplay &&
2096                    mode->vdisplay <= m->vdisplay)
2097                        ok = true;
2098        }
2099        return ok;
2100}
2101
2102static int
2103drm_dmt_modes_for_range(struct drm_connector *connector, struct edid *edid,
2104                        struct detailed_timing *timing)
2105{
2106        int i, modes = 0;
2107        struct drm_display_mode *newmode;
2108        struct drm_device *dev = connector->dev;
2109
2110        for (i = 0; i < ARRAY_SIZE(drm_dmt_modes); i++) {
2111                if (mode_in_range(drm_dmt_modes + i, edid, timing) &&
2112                    valid_inferred_mode(connector, drm_dmt_modes + i)) {
2113                        newmode = drm_mode_duplicate(dev, &drm_dmt_modes[i]);
2114                        if (newmode) {
2115                                drm_mode_probed_add(connector, newmode);
2116                                modes++;
2117                        }
2118                }
2119        }
2120
2121        return modes;
2122}
2123
2124/* fix up 1366x768 mode from 1368x768;
2125 * GFT/CVT can't express 1366 width which isn't dividable by 8
2126 */
2127static void fixup_mode_1366x768(struct drm_display_mode *mode)
2128{
2129        if (mode->hdisplay == 1368 && mode->vdisplay == 768) {
2130                mode->hdisplay = 1366;
2131                mode->hsync_start--;
2132                mode->hsync_end--;
2133                drm_mode_set_name(mode);
2134        }
2135}
2136
2137static int
2138drm_gtf_modes_for_range(struct drm_connector *connector, struct edid *edid,
2139                        struct detailed_timing *timing)
2140{
2141        int i, modes = 0;
2142        struct drm_display_mode *newmode;
2143        struct drm_device *dev = connector->dev;
2144
2145        for (i = 0; i < ARRAY_SIZE(extra_modes); i++) {
2146                const struct minimode *m = &extra_modes[i];
2147                newmode = drm_gtf_mode(dev, m->w, m->h, m->r, 0, 0);
2148                if (!newmode)
2149                        return modes;
2150
2151                fixup_mode_1366x768(newmode);
2152                if (!mode_in_range(newmode, edid, timing) ||
2153                    !valid_inferred_mode(connector, newmode)) {
2154                        drm_mode_destroy(dev, newmode);
2155                        continue;
2156                }
2157
2158                drm_mode_probed_add(connector, newmode);
2159                modes++;
2160        }
2161
2162        return modes;
2163}
2164
2165static int
2166drm_cvt_modes_for_range(struct drm_connector *connector, struct edid *edid,
2167                        struct detailed_timing *timing)
2168{
2169        int i, modes = 0;
2170        struct drm_display_mode *newmode;
2171        struct drm_device *dev = connector->dev;
2172        bool rb = drm_monitor_supports_rb(edid);
2173
2174        for (i = 0; i < ARRAY_SIZE(extra_modes); i++) {
2175                const struct minimode *m = &extra_modes[i];
2176                newmode = drm_cvt_mode(dev, m->w, m->h, m->r, rb, 0, 0);
2177                if (!newmode)
2178                        return modes;
2179
2180                fixup_mode_1366x768(newmode);
2181                if (!mode_in_range(newmode, edid, timing) ||
2182                    !valid_inferred_mode(connector, newmode)) {
2183                        drm_mode_destroy(dev, newmode);
2184                        continue;
2185                }
2186
2187                drm_mode_probed_add(connector, newmode);
2188                modes++;
2189        }
2190
2191        return modes;
2192}
2193
2194static void
2195do_inferred_modes(struct detailed_timing *timing, void *c)
2196{
2197        struct detailed_mode_closure *closure = c;
2198        struct detailed_non_pixel *data = &timing->data.other_data;
2199        struct detailed_data_monitor_range *range = &data->data.range;
2200
2201        if (data->type != EDID_DETAIL_MONITOR_RANGE)
2202                return;
2203
2204        closure->modes += drm_dmt_modes_for_range(closure->connector,
2205                                                  closure->edid,
2206                                                  timing);
2207       
2208        if (!version_greater(closure->edid, 1, 1))
2209                return; /* GTF not defined yet */
2210
2211        switch (range->flags) {
2212        case 0x02: /* secondary gtf, XXX could do more */
2213        case 0x00: /* default gtf */
2214                closure->modes += drm_gtf_modes_for_range(closure->connector,
2215                                                          closure->edid,
2216                                                          timing);
2217                break;
2218        case 0x04: /* cvt, only in 1.4+ */
2219                if (!version_greater(closure->edid, 1, 3))
2220                        break;
2221
2222                closure->modes += drm_cvt_modes_for_range(closure->connector,
2223                                                          closure->edid,
2224                                                          timing);
2225                break;
2226        case 0x01: /* just the ranges, no formula */
2227        default:
2228                break;
2229        }
2230}
2231
2232static int
2233add_inferred_modes(struct drm_connector *connector, struct edid *edid)
2234{
2235        struct detailed_mode_closure closure = {
2236                .connector = connector,
2237                .edid = edid,
2238        };
2239
2240        if (version_greater(edid, 1, 0))
2241                drm_for_each_detailed_block((u8 *)edid, do_inferred_modes,
2242                                            &closure);
2243
2244        return closure.modes;
2245}
2246
2247static int
2248drm_est3_modes(struct drm_connector *connector, struct detailed_timing *timing)
2249{
2250        int i, j, m, modes = 0;
2251        struct drm_display_mode *mode;
2252        u8 *est = ((u8 *)timing) + 6;
2253
2254        for (i = 0; i < 6; i++) {
2255                for (j = 7; j >= 0; j--) {
2256                        m = (i * 8) + (7 - j);
2257                        if (m >= ARRAY_SIZE(est3_modes))
2258                                break;
2259                        if (est[i] & (1 << j)) {
2260                                mode = drm_mode_find_dmt(connector->dev,
2261                                                         est3_modes[m].w,
2262                                                         est3_modes[m].h,
2263                                                         est3_modes[m].r,
2264                                                         est3_modes[m].rb);
2265                                if (mode) {
2266                                        drm_mode_probed_add(connector, mode);
2267                                        modes++;
2268                                }
2269                        }
2270                }
2271        }
2272
2273        return modes;
2274}
2275
2276static void
2277do_established_modes(struct detailed_timing *timing, void *c)
2278{
2279        struct detailed_mode_closure *closure = c;
2280        struct detailed_non_pixel *data = &timing->data.other_data;
2281
2282        if (data->type == EDID_DETAIL_EST_TIMINGS)
2283                closure->modes += drm_est3_modes(closure->connector, timing);
2284}
2285
2286/**
2287 * add_established_modes - get est. modes from EDID and add them
2288 * @connector: connector to add mode(s) to
2289 * @edid: EDID block to scan
2290 *
2291 * Each EDID block contains a bitmap of the supported "established modes" list
2292 * (defined above).  Tease them out and add them to the global modes list.
2293 */
2294static int
2295add_established_modes(struct drm_connector *connector, struct edid *edid)
2296{
2297        struct drm_device *dev = connector->dev;
2298        unsigned long est_bits = edid->established_timings.t1 |
2299                (edid->established_timings.t2 << 8) |
2300                ((edid->established_timings.mfg_rsvd & 0x80) << 9);
2301        int i, modes = 0;
2302        struct detailed_mode_closure closure = {
2303                .connector = connector,
2304                .edid = edid,
2305        };
2306
2307        for (i = 0; i <= EDID_EST_TIMINGS; i++) {
2308                if (est_bits & (1<<i)) {
2309                        struct drm_display_mode *newmode;
2310                        newmode = drm_mode_duplicate(dev, &edid_est_modes[i]);
2311                        if (newmode) {
2312                                drm_mode_probed_add(connector, newmode);
2313                                modes++;
2314                        }
2315                }
2316        }
2317
2318        if (version_greater(edid, 1, 0))
2319                    drm_for_each_detailed_block((u8 *)edid,
2320                                                do_established_modes, &closure);
2321
2322        return modes + closure.modes;
2323}
2324
2325static void
2326do_standard_modes(struct detailed_timing *timing, void *c)
2327{
2328        struct detailed_mode_closure *closure = c;
2329        struct detailed_non_pixel *data = &timing->data.other_data;
2330        struct drm_connector *connector = closure->connector;
2331        struct edid *edid = closure->edid;
2332
2333        if (data->type == EDID_DETAIL_STD_MODES) {
2334                int i;
2335                for (i = 0; i < 6; i++) {
2336                        struct std_timing *std;
2337                        struct drm_display_mode *newmode;
2338
2339                        std = &data->data.timings[i];
2340                        newmode = drm_mode_std(connector, edid, std);
2341                        if (newmode) {
2342                                drm_mode_probed_add(connector, newmode);
2343                                closure->modes++;
2344                        }
2345                }
2346        }
2347}
2348
2349/**
2350 * add_standard_modes - get std. modes from EDID and add them
2351 * @connector: connector to add mode(s) to
2352 * @edid: EDID block to scan
2353 *
2354 * Standard modes can be calculated using the appropriate standard (DMT,
2355 * GTF or CVT. Grab them from @edid and add them to the list.
2356 */
2357static int
2358add_standard_modes(struct drm_connector *connector, struct edid *edid)
2359{
2360        int i, modes = 0;
2361        struct detailed_mode_closure closure = {
2362                .connector = connector,
2363                .edid = edid,
2364        };
2365
2366        for (i = 0; i < EDID_STD_TIMINGS; i++) {
2367                struct drm_display_mode *newmode;
2368
2369                newmode = drm_mode_std(connector, edid,
2370                                       &edid->standard_timings[i]);
2371                if (newmode) {
2372                        drm_mode_probed_add(connector, newmode);
2373                        modes++;
2374                }
2375        }
2376
2377        if (version_greater(edid, 1, 0))
2378                drm_for_each_detailed_block((u8 *)edid, do_standard_modes,
2379                                            &closure);
2380
2381        /* XXX should also look for standard codes in VTB blocks */
2382
2383        return modes + closure.modes;
2384}
2385
2386static int drm_cvt_modes(struct drm_connector *connector,
2387                         struct detailed_timing *timing)
2388{
2389        int i, j, modes = 0;
2390        struct drm_display_mode *newmode;
2391        struct drm_device *dev = connector->dev;
2392        struct cvt_timing *cvt;
2393        const int rates[] = { 60, 85, 75, 60, 50 };
2394        const u8 empty[3] = { 0, 0, 0 };
2395
2396        for (i = 0; i < 4; i++) {
2397                int uninitialized_var(width), height;
2398                cvt = &(timing->data.other_data.data.cvt[i]);
2399
2400                if (!memcmp(cvt->code, empty, 3))
2401                        continue;
2402
2403                height = (cvt->code[0] + ((cvt->code[1] & 0xf0) << 4) + 1) * 2;
2404                switch (cvt->code[1] & 0x0c) {
2405                case 0x00:
2406                        width = height * 4 / 3;
2407                        break;
2408                case 0x04:
2409                        width = height * 16 / 9;
2410                        break;
2411                case 0x08:
2412                        width = height * 16 / 10;
2413                        break;
2414                case 0x0c:
2415                        width = height * 15 / 9;
2416                        break;
2417                }
2418
2419                for (j = 1; j < 5; j++) {
2420                        if (cvt->code[2] & (1 << j)) {
2421                                newmode = drm_cvt_mode(dev, width, height,
2422                                                       rates[j], j == 0,
2423                                                       false, false);
2424                                if (newmode) {
2425                                        drm_mode_probed_add(connector, newmode);
2426                                        modes++;
2427                                }
2428                        }
2429                }
2430        }
2431
2432        return modes;
2433}
2434
2435static void
2436do_cvt_mode(struct detailed_timing *timing, void *c)
2437{
2438        struct detailed_mode_closure *closure = c;
2439        struct detailed_non_pixel *data = &timing->data.other_data;
2440
2441        if (data->type == EDID_DETAIL_CVT_3BYTE)
2442                closure->modes += drm_cvt_modes(closure->connector, timing);
2443}
2444
2445static int
2446add_cvt_modes(struct drm_connector *connector, struct edid *edid)
2447{       
2448        struct detailed_mode_closure closure = {
2449                .connector = connector,
2450                .edid = edid,
2451        };
2452
2453        if (version_greater(edid, 1, 2))
2454                drm_for_each_detailed_block((u8 *)edid, do_cvt_mode, &closure);
2455
2456        /* XXX should also look for CVT codes in VTB blocks */
2457
2458        return closure.modes;
2459}
2460
2461static void fixup_detailed_cea_mode_clock(struct drm_display_mode *mode);
2462
2463static void
2464do_detailed_mode(struct detailed_timing *timing, void *c)
2465{
2466        struct detailed_mode_closure *closure = c;
2467        struct drm_display_mode *newmode;
2468
2469        if (timing->pixel_clock) {
2470                newmode = drm_mode_detailed(closure->connector->dev,
2471                                            closure->edid, timing,
2472                                            closure->quirks);
2473                if (!newmode)
2474                        return;
2475
2476                if (closure->preferred)
2477                        newmode->type |= DRM_MODE_TYPE_PREFERRED;
2478
2479                /*
2480                 * Detailed modes are limited to 10kHz pixel clock resolution,
2481                 * so fix up anything that looks like CEA/HDMI mode, but the clock
2482                 * is just slightly off.
2483                 */
2484                fixup_detailed_cea_mode_clock(newmode);
2485
2486                drm_mode_probed_add(closure->connector, newmode);
2487                closure->modes++;
2488                closure->preferred = 0;
2489        }
2490}
2491
2492/*
2493 * add_detailed_modes - Add modes from detailed timings
2494 * @connector: attached connector
2495 * @edid: EDID block to scan
2496 * @quirks: quirks to apply
2497 */
2498static int
2499add_detailed_modes(struct drm_connector *connector, struct edid *edid,
2500                   u32 quirks)
2501{
2502        struct detailed_mode_closure closure = {
2503                .connector = connector,
2504                .edid = edid,
2505                .preferred = 1,
2506                .quirks = quirks,
2507        };
2508
2509        if (closure.preferred && !version_greater(edid, 1, 3))
2510                closure.preferred =
2511                    (edid->features & DRM_EDID_FEATURE_PREFERRED_TIMING);
2512
2513        drm_for_each_detailed_block((u8 *)edid, do_detailed_mode, &closure);
2514
2515        return closure.modes;
2516}
2517
2518#define AUDIO_BLOCK     0x01
2519#define VIDEO_BLOCK     0x02
2520#define VENDOR_BLOCK    0x03
2521#define SPEAKER_BLOCK   0x04
2522#define VIDEO_CAPABILITY_BLOCK  0x07
2523#define EDID_BASIC_AUDIO        (1 << 6)
2524#define EDID_CEA_YCRCB444       (1 << 5)
2525#define EDID_CEA_YCRCB422       (1 << 4)
2526#define EDID_CEA_VCDB_QS        (1 << 6)
2527
2528/*
2529 * Search EDID for CEA extension block.
2530 */
2531static u8 *drm_find_edid_extension(struct edid *edid, int ext_id)
2532{
2533        u8 *edid_ext = NULL;
2534        int i;
2535
2536        /* No EDID or EDID extensions */
2537        if (edid == NULL || edid->extensions == 0)
2538                return NULL;
2539
2540        /* Find CEA extension */
2541        for (i = 0; i < edid->extensions; i++) {
2542                edid_ext = (u8 *)edid + EDID_LENGTH * (i + 1);
2543                if (edid_ext[0] == ext_id)
2544                        break;
2545        }
2546
2547        if (i == edid->extensions)
2548                return NULL;
2549
2550        return edid_ext;
2551}
2552
2553static u8 *drm_find_cea_extension(struct edid *edid)
2554{
2555        return drm_find_edid_extension(edid, CEA_EXT);
2556}
2557
2558static u8 *drm_find_displayid_extension(struct edid *edid)
2559{
2560        return drm_find_edid_extension(edid, DISPLAYID_EXT);
2561}
2562
2563/*
2564 * Calculate the alternate clock for the CEA mode
2565 * (60Hz vs. 59.94Hz etc.)
2566 */
2567static unsigned int
2568cea_mode_alternate_clock(const struct drm_display_mode *cea_mode)
2569{
2570        unsigned int clock = cea_mode->clock;
2571
2572        if (cea_mode->vrefresh % 6 != 0)
2573                return clock;
2574
2575        /*
2576         * edid_cea_modes contains the 59.94Hz
2577         * variant for 240 and 480 line modes,
2578         * and the 60Hz variant otherwise.
2579         */
2580        if (cea_mode->vdisplay == 240 || cea_mode->vdisplay == 480)
2581                clock = DIV_ROUND_CLOSEST(clock * 1001, 1000);
2582        else
2583                clock = DIV_ROUND_CLOSEST(clock * 1000, 1001);
2584
2585        return clock;
2586}
2587
2588static u8 drm_match_cea_mode_clock_tolerance(const struct drm_display_mode *to_match,
2589                                             unsigned int clock_tolerance)
2590{
2591        u8 vic;
2592
2593        if (!to_match->clock)
2594                return 0;
2595
2596        for (vic = 1; vic < ARRAY_SIZE(edid_cea_modes); vic++) {
2597                const struct drm_display_mode *cea_mode = &edid_cea_modes[vic];
2598                unsigned int clock1, clock2;
2599
2600                /* Check both 60Hz and 59.94Hz */
2601                clock1 = cea_mode->clock;
2602                clock2 = cea_mode_alternate_clock(cea_mode);
2603
2604                if (abs(to_match->clock - clock1) > clock_tolerance &&
2605                    abs(to_match->clock - clock2) > clock_tolerance)
2606                        continue;
2607
2608                if (drm_mode_equal_no_clocks(to_match, cea_mode))
2609                        return vic;
2610        }
2611
2612        return 0;
2613}
2614
2615/**
2616 * drm_match_cea_mode - look for a CEA mode matching given mode
2617 * @to_match: display mode
2618 *
2619 * Return: The CEA Video ID (VIC) of the mode or 0 if it isn't a CEA-861
2620 * mode.
2621 */
2622u8 drm_match_cea_mode(const struct drm_display_mode *to_match)
2623{
2624        u8 vic;
2625
2626        if (!to_match->clock)
2627                return 0;
2628
2629        for (vic = 1; vic < ARRAY_SIZE(edid_cea_modes); vic++) {
2630                const struct drm_display_mode *cea_mode = &edid_cea_modes[vic];
2631                unsigned int clock1, clock2;
2632
2633                /* Check both 60Hz and 59.94Hz */
2634                clock1 = cea_mode->clock;
2635                clock2 = cea_mode_alternate_clock(cea_mode);
2636
2637                if ((KHZ2PICOS(to_match->clock) == KHZ2PICOS(clock1) ||
2638                     KHZ2PICOS(to_match->clock) == KHZ2PICOS(clock2)) &&
2639                    drm_mode_equal_no_clocks_no_stereo(to_match, cea_mode))
2640                        return vic;
2641        }
2642        return 0;
2643}
2644EXPORT_SYMBOL(drm_match_cea_mode);
2645
2646static bool drm_valid_cea_vic(u8 vic)
2647{
2648        return vic > 0 && vic < ARRAY_SIZE(edid_cea_modes);
2649}
2650
2651/**
2652 * drm_get_cea_aspect_ratio - get the picture aspect ratio corresponding to
2653 * the input VIC from the CEA mode list
2654 * @video_code: ID given to each of the CEA modes
2655 *
2656 * Returns picture aspect ratio
2657 */
2658enum hdmi_picture_aspect drm_get_cea_aspect_ratio(const u8 video_code)
2659{
2660        return edid_cea_modes[video_code].picture_aspect_ratio;
2661}
2662EXPORT_SYMBOL(drm_get_cea_aspect_ratio);
2663
2664/*
2665 * Calculate the alternate clock for HDMI modes (those from the HDMI vendor
2666 * specific block).
2667 *
2668 * It's almost like cea_mode_alternate_clock(), we just need to add an
2669 * exception for the VIC 4 mode (4096x2160@24Hz): no alternate clock for this
2670 * one.
2671 */
2672static unsigned int
2673hdmi_mode_alternate_clock(const struct drm_display_mode *hdmi_mode)
2674{
2675        if (hdmi_mode->vdisplay == 4096 && hdmi_mode->hdisplay == 2160)
2676                return hdmi_mode->clock;
2677
2678        return cea_mode_alternate_clock(hdmi_mode);
2679}
2680
2681static u8 drm_match_hdmi_mode_clock_tolerance(const struct drm_display_mode *to_match,
2682                                              unsigned int clock_tolerance)
2683{
2684        u8 vic;
2685
2686        if (!to_match->clock)
2687                return 0;
2688
2689        for (vic = 1; vic < ARRAY_SIZE(edid_4k_modes); vic++) {
2690                const struct drm_display_mode *hdmi_mode = &edid_4k_modes[vic];
2691                unsigned int clock1, clock2;
2692
2693                /* Make sure to also match alternate clocks */
2694                clock1 = hdmi_mode->clock;
2695                clock2 = hdmi_mode_alternate_clock(hdmi_mode);
2696
2697                if (abs(to_match->clock - clock1) > clock_tolerance &&
2698                    abs(to_match->clock - clock2) > clock_tolerance)
2699                        continue;
2700
2701                if (drm_mode_equal_no_clocks(to_match, hdmi_mode))
2702                        return vic;
2703        }
2704
2705        return 0;
2706}
2707
2708/*
2709 * drm_match_hdmi_mode - look for a HDMI mode matching given mode
2710 * @to_match: display mode
2711 *
2712 * An HDMI mode is one defined in the HDMI vendor specific block.
2713 *
2714 * Returns the HDMI Video ID (VIC) of the mode or 0 if it isn't one.
2715 */
2716static u8 drm_match_hdmi_mode(const struct drm_display_mode *to_match)
2717{
2718        u8 vic;
2719
2720        if (!to_match->clock)
2721                return 0;
2722
2723        for (vic = 1; vic < ARRAY_SIZE(edid_4k_modes); vic++) {
2724                const struct drm_display_mode *hdmi_mode = &edid_4k_modes[vic];
2725                unsigned int clock1, clock2;
2726
2727                /* Make sure to also match alternate clocks */
2728                clock1 = hdmi_mode->clock;
2729                clock2 = hdmi_mode_alternate_clock(hdmi_mode);
2730
2731                if ((KHZ2PICOS(to_match->clock) == KHZ2PICOS(clock1) ||
2732                     KHZ2PICOS(to_match->clock) == KHZ2PICOS(clock2)) &&
2733                    drm_mode_equal_no_clocks_no_stereo(to_match, hdmi_mode))
2734                        return vic;
2735        }
2736        return 0;
2737}
2738
2739static bool drm_valid_hdmi_vic(u8 vic)
2740{
2741        return vic > 0 && vic < ARRAY_SIZE(edid_4k_modes);
2742}
2743
2744static int
2745add_alternate_cea_modes(struct drm_connector *connector, struct edid *edid)
2746{
2747        struct drm_device *dev = connector->dev;
2748        struct drm_display_mode *mode, *tmp;
2749        LIST_HEAD(list);
2750        int modes = 0;
2751
2752        /* Don't add CEA modes if the CEA extension block is missing */
2753        if (!drm_find_cea_extension(edid))
2754                return 0;
2755
2756        /*
2757         * Go through all probed modes and create a new mode
2758         * with the alternate clock for certain CEA modes.
2759         */
2760        list_for_each_entry(mode, &connector->probed_modes, head) {
2761                const struct drm_display_mode *cea_mode = NULL;
2762                struct drm_display_mode *newmode;
2763                u8 vic = drm_match_cea_mode(mode);
2764                unsigned int clock1, clock2;
2765
2766                if (drm_valid_cea_vic(vic)) {
2767                        cea_mode = &edid_cea_modes[vic];
2768                        clock2 = cea_mode_alternate_clock(cea_mode);
2769                } else {
2770                        vic = drm_match_hdmi_mode(mode);
2771                        if (drm_valid_hdmi_vic(vic)) {
2772                                cea_mode = &edid_4k_modes[vic];
2773                                clock2 = hdmi_mode_alternate_clock(cea_mode);
2774                        }
2775                }
2776
2777                if (!cea_mode)
2778                        continue;
2779
2780                clock1 = cea_mode->clock;
2781
2782                if (clock1 == clock2)
2783                        continue;
2784
2785                if (mode->clock != clock1 && mode->clock != clock2)
2786                        continue;
2787
2788                newmode = drm_mode_duplicate(dev, cea_mode);
2789                if (!newmode)
2790                        continue;
2791
2792                /* Carry over the stereo flags */
2793                newmode->flags |= mode->flags & DRM_MODE_FLAG_3D_MASK;
2794
2795                /*
2796                 * The current mode could be either variant. Make
2797                 * sure to pick the "other" clock for the new mode.
2798                 */
2799                if (mode->clock != clock1)
2800                        newmode->clock = clock1;
2801                else
2802                        newmode->clock = clock2;
2803
2804                list_add_tail(&newmode->head, &list);
2805        }
2806
2807        list_for_each_entry_safe(mode, tmp, &list, head) {
2808                list_del(&mode->head);
2809                drm_mode_probed_add(connector, mode);
2810                modes++;
2811        }
2812
2813        return modes;
2814}
2815
2816static struct drm_display_mode *
2817drm_display_mode_from_vic_index(struct drm_connector *connector,
2818                                const u8 *video_db, u8 video_len,
2819                                u8 video_index)
2820{
2821        struct drm_device *dev = connector->dev;
2822        struct drm_display_mode *newmode;
2823        u8 vic;
2824
2825        if (video_db == NULL || video_index >= video_len)
2826                return NULL;
2827
2828        /* CEA modes are numbered 1..127 */
2829        vic = (video_db[video_index] & 127);
2830        if (!drm_valid_cea_vic(vic))
2831                return NULL;
2832
2833        newmode = drm_mode_duplicate(dev, &edid_cea_modes[vic]);
2834        if (!newmode)
2835                return NULL;
2836
2837        newmode->vrefresh = 0;
2838
2839        return newmode;
2840}
2841
2842static int
2843do_cea_modes(struct drm_connector *connector, const u8 *db, u8 len)
2844{
2845        int i, modes = 0;
2846
2847        for (i = 0; i < len; i++) {
2848                struct drm_display_mode *mode;
2849                mode = drm_display_mode_from_vic_index(connector, db, len, i);
2850                if (mode) {
2851                        drm_mode_probed_add(connector, mode);
2852                        modes++;
2853                }
2854        }
2855
2856        return modes;
2857}
2858
2859struct stereo_mandatory_mode {
2860        int width, height, vrefresh;
2861        unsigned int flags;
2862};
2863
2864static const struct stereo_mandatory_mode stereo_mandatory_modes[] = {
2865        { 1920, 1080, 24, DRM_MODE_FLAG_3D_TOP_AND_BOTTOM },
2866        { 1920, 1080, 24, DRM_MODE_FLAG_3D_FRAME_PACKING },
2867        { 1920, 1080, 50,
2868          DRM_MODE_FLAG_INTERLACE | DRM_MODE_FLAG_3D_SIDE_BY_SIDE_HALF },
2869        { 1920, 1080, 60,
2870          DRM_MODE_FLAG_INTERLACE | DRM_MODE_FLAG_3D_SIDE_BY_SIDE_HALF },
2871        { 1280, 720,  50, DRM_MODE_FLAG_3D_TOP_AND_BOTTOM },
2872        { 1280, 720,  50, DRM_MODE_FLAG_3D_FRAME_PACKING },
2873        { 1280, 720,  60, DRM_MODE_FLAG_3D_TOP_AND_BOTTOM },
2874        { 1280, 720,  60, DRM_MODE_FLAG_3D_FRAME_PACKING }
2875};
2876
2877static bool
2878stereo_match_mandatory(const struct drm_display_mode *mode,
2879                       const struct stereo_mandatory_mode *stereo_mode)
2880{
2881        unsigned int interlaced = mode->flags & DRM_MODE_FLAG_INTERLACE;
2882
2883        return mode->hdisplay == stereo_mode->width &&
2884               mode->vdisplay == stereo_mode->height &&
2885               interlaced == (stereo_mode->flags & DRM_MODE_FLAG_INTERLACE) &&
2886               drm_mode_vrefresh(mode) == stereo_mode->vrefresh;
2887}
2888
2889static int add_hdmi_mandatory_stereo_modes(struct drm_connector *connector)
2890{
2891        struct drm_device *dev = connector->dev;
2892        const struct drm_display_mode *mode;
2893        struct list_head stereo_modes;
2894        int modes = 0, i;
2895
2896        INIT_LIST_HEAD(&stereo_modes);
2897
2898        list_for_each_entry(mode, &connector->probed_modes, head) {
2899                for (i = 0; i < ARRAY_SIZE(stereo_mandatory_modes); i++) {
2900                        const struct stereo_mandatory_mode *mandatory;
2901                        struct drm_display_mode *new_mode;
2902
2903                        if (!stereo_match_mandatory(mode,
2904                                                    &stereo_mandatory_modes[i]))
2905                                continue;
2906
2907                        mandatory = &stereo_mandatory_modes[i];
2908                        new_mode = drm_mode_duplicate(dev, mode);
2909                        if (!new_mode)
2910                                continue;
2911
2912                        new_mode->flags |= mandatory->flags;
2913                        list_add_tail(&new_mode->head, &stereo_modes);
2914                        modes++;
2915                }
2916        }
2917
2918        list_splice_tail(&stereo_modes, &connector->probed_modes);
2919
2920        return modes;
2921}
2922
2923static int add_hdmi_mode(struct drm_connector *connector, u8 vic)
2924{
2925        struct drm_device *dev = connector->dev;
2926        struct drm_display_mode *newmode;
2927
2928        if (!drm_valid_hdmi_vic(vic)) {
2929                DRM_ERROR("Unknown HDMI VIC: %d\n", vic);
2930                return 0;
2931        }
2932
2933        newmode = drm_mode_duplicate(dev, &edid_4k_modes[vic]);
2934        if (!newmode)
2935                return 0;
2936
2937        drm_mode_probed_add(connector, newmode);
2938
2939        return 1;
2940}
2941
2942static int add_3d_struct_modes(struct drm_connector *connector, u16 structure,
2943                               const u8 *video_db, u8 video_len, u8 video_index)
2944{
2945        struct drm_display_mode *newmode;
2946        int modes = 0;
2947
2948        if (structure & (1 << 0)) {
2949                newmode = drm_display_mode_from_vic_index(connector, video_db,
2950                                                          video_len,
2951                                                          video_index);
2952                if (newmode) {
2953                        newmode->flags |= DRM_MODE_FLAG_3D_FRAME_PACKING;
2954                        drm_mode_probed_add(connector, newmode);
2955                        modes++;
2956                }
2957        }
2958        if (structure & (1 << 6)) {
2959                newmode = drm_display_mode_from_vic_index(connector, video_db,
2960                                                          video_len,
2961                                                          video_index);
2962                if (newmode) {
2963                        newmode->flags |= DRM_MODE_FLAG_3D_TOP_AND_BOTTOM;
2964                        drm_mode_probed_add(connector, newmode);
2965                        modes++;
2966                }
2967        }
2968        if (structure & (1 << 8)) {
2969                newmode = drm_display_mode_from_vic_index(connector, video_db,
2970                                                          video_len,
2971                                                          video_index);
2972                if (newmode) {
2973                        newmode->flags |= DRM_MODE_FLAG_3D_SIDE_BY_SIDE_HALF;
2974                        drm_mode_probed_add(connector, newmode);
2975                        modes++;
2976                }
2977        }
2978
2979        return modes;
2980}
2981
2982/*
2983 * do_hdmi_vsdb_modes - Parse the HDMI Vendor Specific data block
2984 * @connector: connector corresponding to the HDMI sink
2985 * @db: start of the CEA vendor specific block
2986 * @len: length of the CEA block payload, ie. one can access up to db[len]
2987 *
2988 * Parses the HDMI VSDB looking for modes to add to @connector. This function
2989 * also adds the stereo 3d modes when applicable.
2990 */
2991static int
2992do_hdmi_vsdb_modes(struct drm_connector *connector, const u8 *db, u8 len,
2993                   const u8 *video_db, u8 video_len)
2994{
2995        int modes = 0, offset = 0, i, multi_present = 0, multi_len;
2996        u8 vic_len, hdmi_3d_len = 0;
2997        u16 mask;
2998        u16 structure_all;
2999
3000        if (len < 8)
3001                goto out;
3002
3003        /* no HDMI_Video_Present */
3004        if (!(db[8] & (1 << 5)))
3005                goto out;
3006
3007        /* Latency_Fields_Present */
3008        if (db[8] & (1 << 7))
3009                offset += 2;
3010
3011        /* I_Latency_Fields_Present */
3012        if (db[8] & (1 << 6))
3013                offset += 2;
3014
3015        /* the declared length is not long enough for the 2 first bytes
3016         * of additional video format capabilities */
3017        if (len < (8 + offset + 2))
3018                goto out;
3019
3020        /* 3D_Present */
3021        offset++;
3022        if (db[8 + offset] & (1 << 7)) {
3023                modes += add_hdmi_mandatory_stereo_modes(connector);
3024
3025                /* 3D_Multi_present */
3026                multi_present = (db[8 + offset] & 0x60) >> 5;
3027        }
3028
3029        offset++;
3030        vic_len = db[8 + offset] >> 5;
3031        hdmi_3d_len = db[8 + offset] & 0x1f;
3032
3033        for (i = 0; i < vic_len && len >= (9 + offset + i); i++) {
3034                u8 vic;
3035
3036                vic = db[9 + offset + i];
3037                modes += add_hdmi_mode(connector, vic);
3038        }
3039        offset += 1 + vic_len;
3040
3041        if (multi_present == 1)
3042                multi_len = 2;
3043        else if (multi_present == 2)
3044                multi_len = 4;
3045        else
3046                multi_len = 0;
3047
3048        if (len < (8 + offset + hdmi_3d_len - 1))
3049                goto out;
3050
3051        if (hdmi_3d_len < multi_len)
3052                goto out;
3053
3054        if (multi_present == 1 || multi_present == 2) {
3055                /* 3D_Structure_ALL */
3056                structure_all = (db[8 + offset] << 8) | db[9 + offset];
3057
3058                /* check if 3D_MASK is present */
3059                if (multi_present == 2)
3060                        mask = (db[10 + offset] << 8) | db[11 + offset];
3061                else
3062                        mask = 0xffff;
3063
3064                for (i = 0; i < 16; i++) {
3065                        if (mask & (1 << i))
3066                                modes += add_3d_struct_modes(connector,
3067                                                structure_all,
3068                                                video_db,
3069                                                video_len, i);
3070                }
3071        }
3072
3073        offset += multi_len;
3074
3075        for (i = 0; i < (hdmi_3d_len - multi_len); i++) {
3076                int vic_index;
3077                struct drm_display_mode *newmode = NULL;
3078                unsigned int newflag = 0;
3079                bool detail_present;
3080
3081                detail_present = ((db[8 + offset + i] & 0x0f) > 7);
3082
3083                if (detail_present && (i + 1 == hdmi_3d_len - multi_len))
3084                        break;
3085
3086                /* 2D_VIC_order_X */
3087                vic_index = db[8 + offset + i] >> 4;
3088
3089                /* 3D_Structure_X */
3090                switch (db[8 + offset + i] & 0x0f) {
3091                case 0:
3092                        newflag = DRM_MODE_FLAG_3D_FRAME_PACKING;
3093                        break;
3094                case 6:
3095                        newflag = DRM_MODE_FLAG_3D_TOP_AND_BOTTOM;
3096                        break;
3097                case 8:
3098                        /* 3D_Detail_X */
3099                        if ((db[9 + offset + i] >> 4) == 1)
3100                                newflag = DRM_MODE_FLAG_3D_SIDE_BY_SIDE_HALF;
3101                        break;
3102                }
3103
3104                if (newflag != 0) {
3105                        newmode = drm_display_mode_from_vic_index(connector,
3106                                                                  video_db,
3107                                                                  video_len,
3108                                                                  vic_index);
3109
3110                        if (newmode) {
3111                                newmode->flags |= newflag;
3112                                drm_mode_probed_add(connector, newmode);
3113                                modes++;
3114                        }
3115                }
3116
3117                if (detail_present)
3118                        i++;
3119        }
3120
3121out:
3122        return modes;
3123}
3124
3125static int
3126cea_db_payload_len(const u8 *db)
3127{
3128        return db[0] & 0x1f;
3129}
3130
3131static int
3132cea_db_tag(const u8 *db)
3133{
3134        return db[0] >> 5;
3135}
3136
3137static int
3138cea_revision(const u8 *cea)
3139{
3140        return cea[1];
3141}
3142
3143static int
3144cea_db_offsets(const u8 *cea, int *start, int *end)
3145{
3146        /* Data block offset in CEA extension block */
3147        *start = 4;
3148        *end = cea[2];
3149        if (*end == 0)
3150                *end = 127;
3151        if (*end < 4 || *end > 127)
3152                return -ERANGE;
3153        return 0;
3154}
3155
3156static bool cea_db_is_hdmi_vsdb(const u8 *db)
3157{
3158        int hdmi_id;
3159
3160        if (cea_db_tag(db) != VENDOR_BLOCK)
3161                return false;
3162
3163        if (cea_db_payload_len(db) < 5)
3164                return false;
3165
3166        hdmi_id = db[1] | (db[2] << 8) | (db[3] << 16);
3167
3168        return hdmi_id == HDMI_IEEE_OUI;
3169}
3170
3171#define for_each_cea_db(cea, i, start, end) \
3172        for ((i) = (start); (i) < (end) && (i) + cea_db_payload_len(&(cea)[(i)]) < (end); (i) += cea_db_payload_len(&(cea)[(i)]) + 1)
3173
3174static int
3175add_cea_modes(struct drm_connector *connector, struct edid *edid)
3176{
3177        const u8 *cea = drm_find_cea_extension(edid);
3178        const u8 *db, *hdmi = NULL, *video = NULL;
3179        u8 dbl, hdmi_len, video_len = 0;
3180        int modes = 0;
3181
3182        if (cea && cea_revision(cea) >= 3) {
3183                int i, start, end;
3184
3185                if (cea_db_offsets(cea, &start, &end))
3186                        return 0;
3187
3188                for_each_cea_db(cea, i, start, end) {
3189                        db = &cea[i];
3190                        dbl = cea_db_payload_len(db);
3191
3192                        if (cea_db_tag(db) == VIDEO_BLOCK) {
3193                                video = db + 1;
3194                                video_len = dbl;
3195                                modes += do_cea_modes(connector, video, dbl);
3196                        }
3197                        else if (cea_db_is_hdmi_vsdb(db)) {
3198                                hdmi = db;
3199                                hdmi_len = dbl;
3200                        }
3201                }
3202        }
3203
3204        /*
3205         * We parse the HDMI VSDB after having added the cea modes as we will
3206         * be patching their flags when the sink supports stereo 3D.
3207         */
3208        if (hdmi)
3209                modes += do_hdmi_vsdb_modes(connector, hdmi, hdmi_len, video,
3210                                            video_len);
3211
3212        return modes;
3213}
3214
3215static void fixup_detailed_cea_mode_clock(struct drm_display_mode *mode)
3216{
3217        const struct drm_display_mode *cea_mode;
3218        int clock1, clock2, clock;
3219        u8 vic;
3220        const char *type;
3221
3222        /*
3223         * allow 5kHz clock difference either way to account for
3224         * the 10kHz clock resolution limit of detailed timings.
3225         */
3226        vic = drm_match_cea_mode_clock_tolerance(mode, 5);
3227        if (drm_valid_cea_vic(vic)) {
3228                type = "CEA";
3229                cea_mode = &edid_cea_modes[vic];
3230                clock1 = cea_mode->clock;
3231                clock2 = cea_mode_alternate_clock(cea_mode);
3232        } else {
3233                vic = drm_match_hdmi_mode_clock_tolerance(mode, 5);
3234                if (drm_valid_hdmi_vic(vic)) {
3235                        type = "HDMI";
3236                        cea_mode = &edid_4k_modes[vic];
3237                        clock1 = cea_mode->clock;
3238                        clock2 = hdmi_mode_alternate_clock(cea_mode);
3239                } else {
3240                        return;
3241                }
3242        }
3243
3244        /* pick whichever is closest */
3245        if (abs(mode->clock - clock1) < abs(mode->clock - clock2))
3246                clock = clock1;
3247        else
3248                clock = clock2;
3249
3250        if (mode->clock == clock)
3251                return;
3252
3253        DRM_DEBUG("detailed mode matches %s VIC %d, adjusting clock %d -> %d\n",
3254                  type, vic, mode->clock, clock);
3255        mode->clock = clock;
3256}
3257
3258static void
3259drm_parse_hdmi_vsdb_audio(struct drm_connector *connector, const u8 *db)
3260{
3261        u8 len = cea_db_payload_len(db);
3262
3263        if (len >= 6)
3264                connector->eld[5] |= (db[6] >> 7) << 1;  /* Supports_AI */
3265        if (len >= 8) {
3266                connector->latency_present[0] = db[8] >> 7;
3267                connector->latency_present[1] = (db[8] >> 6) & 1;
3268        }
3269        if (len >= 9)
3270                connector->video_latency[0] = db[9];
3271        if (len >= 10)
3272                connector->audio_latency[0] = db[10];
3273        if (len >= 11)
3274                connector->video_latency[1] = db[11];
3275        if (len >= 12)
3276                connector->audio_latency[1] = db[12];
3277
3278        DRM_DEBUG_KMS("HDMI: latency present %d %d, "
3279                      "video latency %d %d, "
3280                      "audio latency %d %d\n",
3281                      connector->latency_present[0],
3282                      connector->latency_present[1],
3283                      connector->video_latency[0],
3284                      connector->video_latency[1],
3285                      connector->audio_latency[0],
3286                      connector->audio_latency[1]);
3287}
3288
3289static void
3290monitor_name(struct detailed_timing *t, void *data)
3291{
3292        if (t->data.other_data.type == EDID_DETAIL_MONITOR_NAME)
3293                *(u8 **)data = t->data.other_data.data.str.str;
3294}
3295
3296static int get_monitor_name(struct edid *edid, char name[13])
3297{
3298        char *edid_name = NULL;
3299        int mnl;
3300
3301        if (!edid || !name)
3302                return 0;
3303
3304        drm_for_each_detailed_block((u8 *)edid, monitor_name, &edid_name);
3305        for (mnl = 0; edid_name && mnl < 13; mnl++) {
3306                if (edid_name[mnl] == 0x0a)
3307                        break;
3308
3309                name[mnl] = edid_name[mnl];
3310        }
3311
3312        return mnl;
3313}
3314
3315/**
3316 * drm_edid_get_monitor_name - fetch the monitor name from the edid
3317 * @edid: monitor EDID information
3318 * @name: pointer to a character array to hold the name of the monitor
3319 * @bufsize: The size of the name buffer (should be at least 14 chars.)
3320 *
3321 */
3322void drm_edid_get_monitor_name(struct edid *edid, char *name, int bufsize)
3323{
3324        int name_length;
3325        char buf[13];
3326       
3327        if (bufsize <= 0)
3328                return;
3329
3330        name_length = min(get_monitor_name(edid, buf), bufsize - 1);
3331        memcpy(name, buf, name_length);
3332        name[name_length] = '\0';
3333}
3334EXPORT_SYMBOL(drm_edid_get_monitor_name);
3335
3336/**
3337 * drm_edid_to_eld - build ELD from EDID
3338 * @connector: connector corresponding to the HDMI/DP sink
3339 * @edid: EDID to parse
3340 *
3341 * Fill the ELD (EDID-Like Data) buffer for passing to the audio driver. The
3342 * Conn_Type, HDCP and Port_ID ELD fields are left for the graphics driver to
3343 * fill in.
3344 */
3345void drm_edid_to_eld(struct drm_connector *connector, struct edid *edid)
3346{
3347        uint8_t *eld = connector->eld;
3348        u8 *cea;
3349        u8 *db;
3350        int total_sad_count = 0;
3351        int mnl;
3352        int dbl;
3353
3354        memset(eld, 0, sizeof(connector->eld));
3355
3356        connector->latency_present[0] = false;
3357        connector->latency_present[1] = false;
3358        connector->video_latency[0] = 0;
3359        connector->audio_latency[0] = 0;
3360        connector->video_latency[1] = 0;
3361        connector->audio_latency[1] = 0;
3362
3363        cea = drm_find_cea_extension(edid);
3364        if (!cea) {
3365                DRM_DEBUG_KMS("ELD: no CEA Extension found\n");
3366                return;
3367        }
3368
3369        mnl = get_monitor_name(edid, eld + 20);
3370
3371        eld[4] = (cea[1] << 5) | mnl;
3372        DRM_DEBUG_KMS("ELD monitor %s\n", eld + 20);
3373
3374        eld[0] = 2 << 3;                /* ELD version: 2 */
3375
3376        eld[16] = edid->mfg_id[0];
3377        eld[17] = edid->mfg_id[1];
3378        eld[18] = edid->prod_code[0];
3379        eld[19] = edid->prod_code[1];
3380
3381        if (cea_revision(cea) >= 3) {
3382                int i, start, end;
3383
3384                if (cea_db_offsets(cea, &start, &end)) {
3385                        start = 0;
3386                        end = 0;
3387                }
3388
3389                for_each_cea_db(cea, i, start, end) {
3390                        db = &cea[i];
3391                        dbl = cea_db_payload_len(db);
3392
3393                        switch (cea_db_tag(db)) {
3394                                int sad_count;
3395
3396                        case AUDIO_BLOCK:
3397                                /* Audio Data Block, contains SADs */
3398                                sad_count = min(dbl / 3, 15 - total_sad_count);
3399                                if (sad_count >= 1)
3400                                        memcpy(eld + 20 + mnl + total_sad_count * 3,
3401                                               &db[1], sad_count * 3);
3402                                total_sad_count += sad_count;
3403                                break;
3404                        case SPEAKER_BLOCK:
3405                                /* Speaker Allocation Data Block */
3406                                if (dbl >= 1)
3407                                        eld[7] = db[1];
3408                                break;
3409                        case VENDOR_BLOCK:
3410                                /* HDMI Vendor-Specific Data Block */
3411                                if (cea_db_is_hdmi_vsdb(db))
3412                                        drm_parse_hdmi_vsdb_audio(connector, db);
3413                                break;
3414                        default:
3415                                break;
3416                        }
3417                }
3418        }
3419        eld[5] |= total_sad_count << 4;
3420
3421        eld[DRM_ELD_BASELINE_ELD_LEN] =
3422                DIV_ROUND_UP(drm_eld_calc_baseline_block_size(eld), 4);
3423
3424        DRM_DEBUG_KMS("ELD size %d, SAD count %d\n",
3425                      drm_eld_size(eld), total_sad_count);
3426}
3427EXPORT_SYMBOL(drm_edid_to_eld);
3428
3429/**
3430 * drm_edid_to_sad - extracts SADs from EDID
3431 * @edid: EDID to parse
3432 * @sads: pointer that will be set to the extracted SADs
3433 *
3434 * Looks for CEA EDID block and extracts SADs (Short Audio Descriptors) from it.
3435 *
3436 * Note: The returned pointer needs to be freed using kfree().
3437 *
3438 * Return: The number of found SADs or negative number on error.
3439 */
3440int drm_edid_to_sad(struct edid *edid, struct cea_sad **sads)
3441{
3442        int count = 0;
3443        int i, start, end, dbl;
3444        u8 *cea;
3445
3446        cea = drm_find_cea_extension(edid);
3447        if (!cea) {
3448                DRM_DEBUG_KMS("SAD: no CEA Extension found\n");
3449                return -ENOENT;
3450        }
3451
3452        if (cea_revision(cea) < 3) {
3453                DRM_DEBUG_KMS("SAD: wrong CEA revision\n");
3454                return -ENOTSUPP;
3455        }
3456
3457        if (cea_db_offsets(cea, &start, &end)) {
3458                DRM_DEBUG_KMS("SAD: invalid data block offsets\n");
3459                return -EPROTO;
3460        }
3461
3462        for_each_cea_db(cea, i, start, end) {
3463                u8 *db = &cea[i];
3464
3465                if (cea_db_tag(db) == AUDIO_BLOCK) {
3466                        int j;
3467                        dbl = cea_db_payload_len(db);
3468
3469                        count = dbl / 3; /* SAD is 3B */
3470                        *sads = kcalloc(count, sizeof(**sads), GFP_KERNEL);
3471                        if (!*sads)
3472                                return -ENOMEM;
3473                        for (j = 0; j < count; j++) {
3474                                u8 *sad = &db[1 + j * 3];
3475
3476                                (*sads)[j].format = (sad[0] & 0x78) >> 3;
3477                                (*sads)[j].channels = sad[0] & 0x7;
3478                                (*sads)[j].freq = sad[1] & 0x7F;
3479                                (*sads)[j].byte2 = sad[2];
3480                        }
3481                        break;
3482                }
3483        }
3484
3485        return count;
3486}
3487EXPORT_SYMBOL(drm_edid_to_sad);
3488
3489/**
3490 * drm_edid_to_speaker_allocation - extracts Speaker Allocation Data Blocks from EDID
3491 * @edid: EDID to parse
3492 * @sadb: pointer to the speaker block
3493 *
3494 * Looks for CEA EDID block and extracts the Speaker Allocation Data Block from it.
3495 *
3496 * Note: The returned pointer needs to be freed using kfree().
3497 *
3498 * Return: The number of found Speaker Allocation Blocks or negative number on
3499 * error.
3500 */
3501int drm_edid_to_speaker_allocation(struct edid *edid, u8 **sadb)
3502{
3503        int count = 0;
3504        int i, start, end, dbl;
3505        const u8 *cea;
3506
3507        cea = drm_find_cea_extension(edid);
3508        if (!cea) {
3509                DRM_DEBUG_KMS("SAD: no CEA Extension found\n");
3510                return -ENOENT;
3511        }
3512
3513        if (cea_revision(cea) < 3) {
3514                DRM_DEBUG_KMS("SAD: wrong CEA revision\n");
3515                return -ENOTSUPP;
3516        }
3517
3518        if (cea_db_offsets(cea, &start, &end)) {
3519                DRM_DEBUG_KMS("SAD: invalid data block offsets\n");
3520                return -EPROTO;
3521        }
3522
3523        for_each_cea_db(cea, i, start, end) {
3524                const u8 *db = &cea[i];
3525
3526                if (cea_db_tag(db) == SPEAKER_BLOCK) {
3527                        dbl = cea_db_payload_len(db);
3528
3529                        /* Speaker Allocation Data Block */
3530                        if (dbl == 3) {
3531                                *sadb = kmemdup(&db[1], dbl, GFP_KERNEL);
3532                                if (!*sadb)
3533                                        return -ENOMEM;
3534                                count = dbl;
3535                                break;
3536                        }
3537                }
3538        }
3539
3540        return count;
3541}
3542EXPORT_SYMBOL(drm_edid_to_speaker_allocation);
3543
3544/**
3545 * drm_av_sync_delay - compute the HDMI/DP sink audio-video sync delay
3546 * @connector: connector associated with the HDMI/DP sink
3547 * @mode: the display mode
3548 *
3549 * Return: The HDMI/DP sink's audio-video sync delay in milliseconds or 0 if
3550 * the sink doesn't support audio or video.
3551 */
3552int drm_av_sync_delay(struct drm_connector *connector,
3553                      const struct drm_display_mode *mode)
3554{
3555        int i = !!(mode->flags & DRM_MODE_FLAG_INTERLACE);
3556        int a, v;
3557
3558        if (!connector->latency_present[0])
3559                return 0;
3560        if (!connector->latency_present[1])
3561                i = 0;
3562
3563        a = connector->audio_latency[i];
3564        v = connector->video_latency[i];
3565
3566        /*
3567         * HDMI/DP sink doesn't support audio or video?
3568         */
3569        if (a == 255 || v == 255)
3570                return 0;
3571
3572        /*
3573         * Convert raw EDID values to millisecond.
3574         * Treat unknown latency as 0ms.
3575         */
3576        if (a)
3577                a = min(2 * (a - 1), 500);
3578        if (v)
3579                v = min(2 * (v - 1), 500);
3580
3581        return max(v - a, 0);
3582}
3583EXPORT_SYMBOL(drm_av_sync_delay);
3584
3585/**
3586 * drm_select_eld - select one ELD from multiple HDMI/DP sinks
3587 * @encoder: the encoder just changed display mode
3588 *
3589 * It's possible for one encoder to be associated with multiple HDMI/DP sinks.
3590 * The policy is now hard coded to simply use the first HDMI/DP sink's ELD.
3591 *
3592 * Return: The connector associated with the first HDMI/DP sink that has ELD
3593 * attached to it.
3594 */
3595struct drm_connector *drm_select_eld(struct drm_encoder *encoder)
3596{
3597        struct drm_connector *connector;
3598        struct drm_device *dev = encoder->dev;
3599
3600        WARN_ON(!mutex_is_locked(&dev->mode_config.mutex));
3601        WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex));
3602
3603        drm_for_each_connector(connector, dev)
3604                if (connector->encoder == encoder && connector->eld[0])
3605                        return connector;
3606
3607        return NULL;
3608}
3609EXPORT_SYMBOL(drm_select_eld);
3610
3611/**
3612 * drm_detect_hdmi_monitor - detect whether monitor is HDMI
3613 * @edid: monitor EDID information
3614 *
3615 * Parse the CEA extension according to CEA-861-B.
3616 *
3617 * Return: True if the monitor is HDMI, false if not or unknown.
3618 */
3619bool drm_detect_hdmi_monitor(struct edid *edid)
3620{
3621        u8 *edid_ext;
3622        int i;
3623        int start_offset, end_offset;
3624
3625        edid_ext = drm_find_cea_extension(edid);
3626        if (!edid_ext)
3627                return false;
3628
3629        if (cea_db_offsets(edid_ext, &start_offset, &end_offset))
3630                return false;
3631
3632        /*
3633         * Because HDMI identifier is in Vendor Specific Block,
3634         * search it from all data blocks of CEA extension.
3635         */
3636        for_each_cea_db(edid_ext, i, start_offset, end_offset) {
3637                if (cea_db_is_hdmi_vsdb(&edid_ext[i]))
3638                        return true;
3639        }
3640
3641        return false;
3642}
3643EXPORT_SYMBOL(drm_detect_hdmi_monitor);
3644
3645/**
3646 * drm_detect_monitor_audio - check monitor audio capability
3647 * @edid: EDID block to scan
3648 *
3649 * Monitor should have CEA extension block.
3650 * If monitor has 'basic audio', but no CEA audio blocks, it's 'basic
3651 * audio' only. If there is any audio extension block and supported
3652 * audio format, assume at least 'basic audio' support, even if 'basic
3653 * audio' is not defined in EDID.
3654 *
3655 * Return: True if the monitor supports audio, false otherwise.
3656 */
3657bool drm_detect_monitor_audio(struct edid *edid)
3658{
3659        u8 *edid_ext;
3660        int i, j;
3661        bool has_audio = false;
3662        int start_offset, end_offset;
3663
3664        edid_ext = drm_find_cea_extension(edid);
3665        if (!edid_ext)
3666                goto end;
3667
3668        has_audio = ((edid_ext[3] & EDID_BASIC_AUDIO) != 0);
3669
3670        if (has_audio) {
3671                DRM_DEBUG_KMS("Monitor has basic audio support\n");
3672                goto end;
3673        }
3674
3675        if (cea_db_offsets(edid_ext, &start_offset, &end_offset))
3676                goto end;
3677
3678        for_each_cea_db(edid_ext, i, start_offset, end_offset) {
3679                if (cea_db_tag(&edid_ext[i]) == AUDIO_BLOCK) {
3680                        has_audio = true;
3681                        for (j = 1; j < cea_db_payload_len(&edid_ext[i]) + 1; j += 3)
3682                                DRM_DEBUG_KMS("CEA audio format %d\n",
3683                                              (edid_ext[i + j] >> 3) & 0xf);
3684                        goto end;
3685                }
3686        }
3687end:
3688        return has_audio;
3689}
3690EXPORT_SYMBOL(drm_detect_monitor_audio);
3691
3692/**
3693 * drm_rgb_quant_range_selectable - is RGB quantization range selectable?
3694 * @edid: EDID block to scan
3695 *
3696 * Check whether the monitor reports the RGB quantization range selection
3697 * as supported. The AVI infoframe can then be used to inform the monitor
3698 * which quantization range (full or limited) is used.
3699 *
3700 * Return: True if the RGB quantization range is selectable, false otherwise.
3701 */
3702bool drm_rgb_quant_range_selectable(struct edid *edid)
3703{
3704        u8 *edid_ext;
3705        int i, start, end;
3706
3707        edid_ext = drm_find_cea_extension(edid);
3708        if (!edid_ext)
3709                return false;
3710
3711        if (cea_db_offsets(edid_ext, &start, &end))
3712                return false;
3713
3714        for_each_cea_db(edid_ext, i, start, end) {
3715                if (cea_db_tag(&edid_ext[i]) == VIDEO_CAPABILITY_BLOCK &&
3716                    cea_db_payload_len(&edid_ext[i]) == 2) {
3717                        DRM_DEBUG_KMS("CEA VCDB 0x%02x\n", edid_ext[i + 2]);
3718                        return edid_ext[i + 2] & EDID_CEA_VCDB_QS;
3719                }
3720        }
3721
3722        return false;
3723}
3724EXPORT_SYMBOL(drm_rgb_quant_range_selectable);
3725
3726static void drm_parse_hdmi_deep_color_info(struct drm_connector *connector,
3727                                           const u8 *hdmi)
3728{
3729        struct drm_display_info *info = &connector->display_info;
3730        unsigned int dc_bpc = 0;
3731
3732        /* HDMI supports at least 8 bpc */
3733        info->bpc = 8;
3734
3735        if (cea_db_payload_len(hdmi) < 6)
3736                return;
3737
3738        if (hdmi[6] & DRM_EDID_HDMI_DC_30) {
3739                dc_bpc = 10;
3740                info->edid_hdmi_dc_modes |= DRM_EDID_HDMI_DC_30;
3741                DRM_DEBUG("%s: HDMI sink does deep color 30.\n",
3742                          connector->name);
3743        }
3744
3745        if (hdmi[6] & DRM_EDID_HDMI_DC_36) {
3746                dc_bpc = 12;
3747                info->edid_hdmi_dc_modes |= DRM_EDID_HDMI_DC_36;
3748                DRM_DEBUG("%s: HDMI sink does deep color 36.\n",
3749                          connector->name);
3750        }
3751
3752        if (hdmi[6] & DRM_EDID_HDMI_DC_48) {
3753                dc_bpc = 16;
3754                info->edid_hdmi_dc_modes |= DRM_EDID_HDMI_DC_48;
3755                DRM_DEBUG("%s: HDMI sink does deep color 48.\n",
3756                          connector->name);
3757        }
3758
3759        if (dc_bpc == 0) {
3760                DRM_DEBUG("%s: No deep color support on this HDMI sink.\n",
3761                          connector->name);
3762                return;
3763        }
3764
3765        DRM_DEBUG("%s: Assigning HDMI sink color depth as %d bpc.\n",
3766                  connector->name, dc_bpc);
3767        info->bpc = dc_bpc;
3768
3769        /*
3770         * Deep color support mandates RGB444 support for all video
3771         * modes and forbids YCRCB422 support for all video modes per
3772         * HDMI 1.3 spec.
3773         */
3774        info->color_formats = DRM_COLOR_FORMAT_RGB444;
3775
3776        /* YCRCB444 is optional according to spec. */
3777        if (hdmi[6] & DRM_EDID_HDMI_DC_Y444) {
3778                info->color_formats |= DRM_COLOR_FORMAT_YCRCB444;
3779                DRM_DEBUG("%s: HDMI sink does YCRCB444 in deep color.\n",
3780                          connector->name);
3781        }
3782
3783        /*
3784         * Spec says that if any deep color mode is supported at all,
3785         * then deep color 36 bit must be supported.
3786         */
3787        if (!(hdmi[6] & DRM_EDID_HDMI_DC_36)) {
3788                DRM_DEBUG("%s: HDMI sink should do DC_36, but does not!\n",
3789                          connector->name);
3790        }
3791}
3792
3793static void
3794drm_parse_hdmi_vsdb_video(struct drm_connector *connector, const u8 *db)
3795{
3796        struct drm_display_info *info = &connector->display_info;
3797        u8 len = cea_db_payload_len(db);
3798
3799        if (len >= 6)
3800                info->dvi_dual = db[6] & 1;
3801        if (len >= 7)
3802                info->max_tmds_clock = db[7] * 5000;
3803
3804        DRM_DEBUG_KMS("HDMI: DVI dual %d, "
3805                      "max TMDS clock %d kHz\n",
3806                      info->dvi_dual,
3807                      info->max_tmds_clock);
3808
3809        drm_parse_hdmi_deep_color_info(connector, db);
3810}
3811
3812static void drm_parse_cea_ext(struct drm_connector *connector,
3813                              struct edid *edid)
3814{
3815        struct drm_display_info *info = &connector->display_info;
3816        const u8 *edid_ext;
3817        int i, start, end;
3818
3819        edid_ext = drm_find_cea_extension(edid);
3820        if (!edid_ext)
3821                return;
3822
3823        info->cea_rev = edid_ext[1];
3824
3825        /* The existence of a CEA block should imply RGB support */
3826        info->color_formats = DRM_COLOR_FORMAT_RGB444;
3827        if (edid_ext[3] & EDID_CEA_YCRCB444)
3828                info->color_formats |= DRM_COLOR_FORMAT_YCRCB444;
3829        if (edid_ext[3] & EDID_CEA_YCRCB422)
3830                info->color_formats |= DRM_COLOR_FORMAT_YCRCB422;
3831
3832        if (cea_db_offsets(edid_ext, &start, &end))
3833                return;
3834
3835        for_each_cea_db(edid_ext, i, start, end) {
3836                const u8 *db = &edid_ext[i];
3837
3838                if (cea_db_is_hdmi_vsdb(db))
3839                        drm_parse_hdmi_vsdb_video(connector, db);
3840        }
3841}
3842
3843static void drm_add_display_info(struct drm_connector *connector,
3844                                 struct edid *edid)
3845{
3846        struct drm_display_info *info = &connector->display_info;
3847
3848        info->width_mm = edid->width_cm * 10;
3849        info->height_mm = edid->height_cm * 10;
3850
3851        /* driver figures it out in this case */
3852        info->bpc = 0;
3853        info->color_formats = 0;
3854        info->cea_rev = 0;
3855        info->max_tmds_clock = 0;
3856        info->dvi_dual = false;
3857
3858        if (edid->revision < 3)
3859                return;
3860
3861        if (!(edid->input & DRM_EDID_INPUT_DIGITAL))
3862                return;
3863
3864        drm_parse_cea_ext(connector, edid);
3865
3866        /*
3867         * Digital sink with "DFP 1.x compliant TMDS" according to EDID 1.3?
3868         *
3869         * For such displays, the DFP spec 1.0, section 3.10 "EDID support"
3870         * tells us to assume 8 bpc color depth if the EDID doesn't have
3871         * extensions which tell otherwise.
3872         */
3873        if ((info->bpc == 0) && (edid->revision < 4) &&
3874            (edid->input & DRM_EDID_DIGITAL_TYPE_DVI)) {
3875                info->bpc = 8;
3876                DRM_DEBUG("%s: Assigning DFP sink color depth as %d bpc.\n",
3877                          connector->name, info->bpc);
3878        }
3879
3880        /* Only defined for 1.4 with digital displays */
3881        if (edid->revision < 4)
3882                return;
3883
3884        switch (edid->input & DRM_EDID_DIGITAL_DEPTH_MASK) {
3885        case DRM_EDID_DIGITAL_DEPTH_6:
3886                info->bpc = 6;
3887                break;
3888        case DRM_EDID_DIGITAL_DEPTH_8:
3889                info->bpc = 8;
3890                break;
3891        case DRM_EDID_DIGITAL_DEPTH_10:
3892                info->bpc = 10;
3893                break;
3894        case DRM_EDID_DIGITAL_DEPTH_12:
3895                info->bpc = 12;
3896                break;
3897        case DRM_EDID_DIGITAL_DEPTH_14:
3898                info->bpc = 14;
3899                break;
3900        case DRM_EDID_DIGITAL_DEPTH_16:
3901                info->bpc = 16;
3902                break;
3903        case DRM_EDID_DIGITAL_DEPTH_UNDEF:
3904        default:
3905                info->bpc = 0;
3906                break;
3907        }
3908
3909        DRM_DEBUG("%s: Assigning EDID-1.4 digital sink color depth as %d bpc.\n",
3910                          connector->name, info->bpc);
3911
3912        info->color_formats |= DRM_COLOR_FORMAT_RGB444;
3913        if (edid->features & DRM_EDID_FEATURE_RGB_YCRCB444)
3914                info->color_formats |= DRM_COLOR_FORMAT_YCRCB444;
3915        if (edid->features & DRM_EDID_FEATURE_RGB_YCRCB422)
3916                info->color_formats |= DRM_COLOR_FORMAT_YCRCB422;
3917}
3918
3919static int validate_displayid(u8 *displayid, int length, int idx)
3920{
3921        int i;
3922        u8 csum = 0;
3923        struct displayid_hdr *base;
3924
3925        base = (struct displayid_hdr *)&displayid[idx];
3926
3927        DRM_DEBUG_KMS("base revision 0x%x, length %d, %d %d\n",
3928                      base->rev, base->bytes, base->prod_id, base->ext_count);
3929
3930        if (base->bytes + 5 > length - idx)
3931                return -EINVAL;
3932        for (i = idx; i <= base->bytes + 5; i++) {
3933                csum += displayid[i];
3934        }
3935        if (csum) {
3936                DRM_ERROR("DisplayID checksum invalid, remainder is %d\n", csum);
3937                return -EINVAL;
3938        }
3939        return 0;
3940}
3941
3942static struct drm_display_mode *drm_mode_displayid_detailed(struct drm_device *dev,
3943                                                            struct displayid_detailed_timings_1 *timings)
3944{
3945        struct drm_display_mode *mode;
3946        unsigned pixel_clock = (timings->pixel_clock[0] |
3947                                (timings->pixel_clock[1] << 8) |
3948                                (timings->pixel_clock[2] << 16));
3949        unsigned hactive = (timings->hactive[0] | timings->hactive[1] << 8) + 1;
3950        unsigned hblank = (timings->hblank[0] | timings->hblank[1] << 8) + 1;
3951        unsigned hsync = (timings->hsync[0] | (timings->hsync[1] & 0x7f) << 8) + 1;
3952        unsigned hsync_width = (timings->hsw[0] | timings->hsw[1] << 8) + 1;
3953        unsigned vactive = (timings->vactive[0] | timings->vactive[1] << 8) + 1;
3954        unsigned vblank = (timings->vblank[0] | timings->vblank[1] << 8) + 1;
3955        unsigned vsync = (timings->vsync[0] | (timings->vsync[1] & 0x7f) << 8) + 1;
3956        unsigned vsync_width = (timings->vsw[0] | timings->vsw[1] << 8) + 1;
3957        bool hsync_positive = (timings->hsync[1] >> 7) & 0x1;
3958        bool vsync_positive = (timings->vsync[1] >> 7) & 0x1;
3959        mode = drm_mode_create(dev);
3960        if (!mode)
3961                return NULL;
3962
3963        mode->clock = pixel_clock * 10;
3964        mode->hdisplay = hactive;
3965        mode->hsync_start = mode->hdisplay + hsync;
3966        mode->hsync_end = mode->hsync_start + hsync_width;
3967        mode->htotal = mode->hdisplay + hblank;
3968
3969        mode->vdisplay = vactive;
3970        mode->vsync_start = mode->vdisplay + vsync;
3971        mode->vsync_end = mode->vsync_start + vsync_width;
3972        mode->vtotal = mode->vdisplay + vblank;
3973
3974        mode->flags = 0;
3975        mode->flags |= hsync_positive ? DRM_MODE_FLAG_PHSYNC : DRM_MODE_FLAG_NHSYNC;
3976        mode->flags |= vsync_positive ? DRM_MODE_FLAG_PVSYNC : DRM_MODE_FLAG_NVSYNC;
3977        mode->type = DRM_MODE_TYPE_DRIVER;
3978
3979        if (timings->flags & 0x80)
3980                mode->type |= DRM_MODE_TYPE_PREFERRED;
3981        mode->vrefresh = drm_mode_vrefresh(mode);
3982        drm_mode_set_name(mode);
3983
3984        return mode;
3985}
3986
3987static int add_displayid_detailed_1_modes(struct drm_connector *connector,
3988                                          struct displayid_block *block)
3989{
3990        struct displayid_detailed_timing_block *det = (struct displayid_detailed_timing_block *)block;
3991        int i;
3992        int num_timings;
3993        struct drm_display_mode *newmode;
3994        int num_modes = 0;
3995        /* blocks must be multiple of 20 bytes length */
3996        if (block->num_bytes % 20)
3997                return 0;
3998
3999        num_timings = block->num_bytes / 20;
4000        for (i = 0; i < num_timings; i++) {
4001                struct displayid_detailed_timings_1 *timings = &det->timings[i];
4002
4003                newmode = drm_mode_displayid_detailed(connector->dev, timings);
4004                if (!newmode)
4005                        continue;
4006
4007                drm_mode_probed_add(connector, newmode);
4008                num_modes++;
4009        }
4010        return num_modes;
4011}
4012
4013static int add_displayid_detailed_modes(struct drm_connector *connector,
4014                                        struct edid *edid)
4015{
4016        u8 *displayid;
4017        int ret;
4018        int idx = 1;
4019        int length = EDID_LENGTH;
4020        struct displayid_block *block;
4021        int num_modes = 0;
4022
4023        displayid = drm_find_displayid_extension(edid);
4024        if (!displayid)
4025                return 0;
4026
4027        ret = validate_displayid(displayid, length, idx);
4028        if (ret)
4029                return 0;
4030
4031        idx += sizeof(struct displayid_hdr);
4032        while (block = (struct displayid_block *)&displayid[idx],
4033               idx + sizeof(struct displayid_block) <= length &&
4034               idx + sizeof(struct displayid_block) + block->num_bytes <= length &&
4035               block->num_bytes > 0) {
4036                idx += block->num_bytes + sizeof(struct displayid_block);
4037                switch (block->tag) {
4038                case DATA_BLOCK_TYPE_1_DETAILED_TIMING:
4039                        num_modes += add_displayid_detailed_1_modes(connector, block);
4040                        break;
4041                }
4042        }
4043        return num_modes;
4044}
4045
4046/**
4047 * drm_add_edid_modes - add modes from EDID data, if available
4048 * @connector: connector we're probing
4049 * @edid: EDID data
4050 *
4051 * Add the specified modes to the connector's mode list. Also fills out the
4052 * &drm_display_info structure in @connector with any information which can be
4053 * derived from the edid.
4054 *
4055 * Return: The number of modes added or 0 if we couldn't find any.
4056 */
4057int drm_add_edid_modes(struct drm_connector *connector, struct edid *edid)
4058{
4059        int num_modes = 0;
4060        u32 quirks;
4061
4062        if (edid == NULL) {
4063                return 0;
4064        }
4065        if (!drm_edid_is_valid(edid)) {
4066                dev_warn(connector->dev->dev, "%s: EDID invalid.\n",
4067                         connector->name);
4068                return 0;
4069        }
4070
4071        quirks = edid_get_quirks(edid);
4072
4073        /*
4074         * EDID spec says modes should be preferred in this order:
4075         * - preferred detailed mode
4076         * - other detailed modes from base block
4077         * - detailed modes from extension blocks
4078         * - CVT 3-byte code modes
4079         * - standard timing codes
4080         * - established timing codes
4081         * - modes inferred from GTF or CVT range information
4082         *
4083         * We get this pretty much right.
4084         *
4085         * XXX order for additional mode types in extension blocks?
4086         */
4087        num_modes += add_detailed_modes(connector, edid, quirks);
4088        num_modes += add_cvt_modes(connector, edid);
4089        num_modes += add_standard_modes(connector, edid);
4090        num_modes += add_established_modes(connector, edid);
4091        num_modes += add_cea_modes(connector, edid);
4092        num_modes += add_alternate_cea_modes(connector, edid);
4093        num_modes += add_displayid_detailed_modes(connector, edid);
4094        if (edid->features & DRM_EDID_FEATURE_DEFAULT_GTF)
4095                num_modes += add_inferred_modes(connector, edid);
4096
4097        if (quirks & (EDID_QUIRK_PREFER_LARGE_60 | EDID_QUIRK_PREFER_LARGE_75))
4098                edid_fixup_preferred(connector, quirks);
4099
4100        drm_add_display_info(connector, edid);
4101
4102        if (quirks & EDID_QUIRK_FORCE_6BPC)
4103                connector->display_info.bpc = 6;
4104
4105        if (quirks & EDID_QUIRK_FORCE_8BPC)
4106                connector->display_info.bpc = 8;
4107
4108        if (quirks & EDID_QUIRK_FORCE_12BPC)
4109                connector->display_info.bpc = 12;
4110
4111        return num_modes;
4112}
4113EXPORT_SYMBOL(drm_add_edid_modes);
4114
4115/**
4116 * drm_add_modes_noedid - add modes for the connectors without EDID
4117 * @connector: connector we're probing
4118 * @hdisplay: the horizontal display limit
4119 * @vdisplay: the vertical display limit
4120 *
4121 * Add the specified modes to the connector's mode list. Only when the
4122 * hdisplay/vdisplay is not beyond the given limit, it will be added.
4123 *
4124 * Return: The number of modes added or 0 if we couldn't find any.
4125 */
4126int drm_add_modes_noedid(struct drm_connector *connector,
4127                        int hdisplay, int vdisplay)
4128{
4129        int i, count, num_modes = 0;
4130        struct drm_display_mode *mode;
4131        struct drm_device *dev = connector->dev;
4132
4133        count = ARRAY_SIZE(drm_dmt_modes);
4134        if (hdisplay < 0)
4135                hdisplay = 0;
4136        if (vdisplay < 0)
4137                vdisplay = 0;
4138
4139        for (i = 0; i < count; i++) {
4140                const struct drm_display_mode *ptr = &drm_dmt_modes[i];
4141                if (hdisplay && vdisplay) {
4142                        /*
4143                         * Only when two are valid, they will be used to check
4144                         * whether the mode should be added to the mode list of
4145                         * the connector.
4146                         */
4147                        if (ptr->hdisplay > hdisplay ||
4148                                        ptr->vdisplay > vdisplay)
4149                                continue;
4150                }
4151                if (drm_mode_vrefresh(ptr) > 61)
4152                        continue;
4153                mode = drm_mode_duplicate(dev, ptr);
4154                if (mode) {
4155                        drm_mode_probed_add(connector, mode);
4156                        num_modes++;
4157                }
4158        }
4159        return num_modes;
4160}
4161EXPORT_SYMBOL(drm_add_modes_noedid);
4162
4163/**
4164 * drm_set_preferred_mode - Sets the preferred mode of a connector
4165 * @connector: connector whose mode list should be processed
4166 * @hpref: horizontal resolution of preferred mode
4167 * @vpref: vertical resolution of preferred mode
4168 *
4169 * Marks a mode as preferred if it matches the resolution specified by @hpref
4170 * and @vpref.
4171 */
4172void drm_set_preferred_mode(struct drm_connector *connector,
4173                           int hpref, int vpref)
4174{
4175        struct drm_display_mode *mode;
4176
4177        list_for_each_entry(mode, &connector->probed_modes, head) {
4178                if (mode->hdisplay == hpref &&
4179                    mode->vdisplay == vpref)
4180                        mode->type |= DRM_MODE_TYPE_PREFERRED;
4181        }
4182}
4183EXPORT_SYMBOL(drm_set_preferred_mode);
4184
4185/**
4186 * drm_hdmi_avi_infoframe_from_display_mode() - fill an HDMI AVI infoframe with
4187 *                                              data from a DRM display mode
4188 * @frame: HDMI AVI infoframe
4189 * @mode: DRM display mode
4190 *
4191 * Return: 0 on success or a negative error code on failure.
4192 */
4193int
4194drm_hdmi_avi_infoframe_from_display_mode(struct hdmi_avi_infoframe *frame,
4195                                         const struct drm_display_mode *mode)
4196{
4197        int err;
4198
4199        if (!frame || !mode)
4200                return -EINVAL;
4201
4202        err = hdmi_avi_infoframe_init(frame);
4203        if (err < 0)
4204                return err;
4205
4206        if (mode->flags & DRM_MODE_FLAG_DBLCLK)
4207                frame->pixel_repeat = 1;
4208
4209        frame->video_code = drm_match_cea_mode(mode);
4210
4211        frame->picture_aspect = HDMI_PICTURE_ASPECT_NONE;
4212
4213        /*
4214         * Populate picture aspect ratio from either
4215         * user input (if specified) or from the CEA mode list.
4216         */
4217        if (mode->picture_aspect_ratio == HDMI_PICTURE_ASPECT_4_3 ||
4218                mode->picture_aspect_ratio == HDMI_PICTURE_ASPECT_16_9)
4219                frame->picture_aspect = mode->picture_aspect_ratio;
4220        else if (frame->video_code > 0)
4221                frame->picture_aspect = drm_get_cea_aspect_ratio(
4222                                                frame->video_code);
4223
4224        frame->active_aspect = HDMI_ACTIVE_ASPECT_PICTURE;
4225        frame->scan_mode = HDMI_SCAN_MODE_UNDERSCAN;
4226
4227        return 0;
4228}
4229EXPORT_SYMBOL(drm_hdmi_avi_infoframe_from_display_mode);
4230
4231static enum hdmi_3d_structure
4232s3d_structure_from_display_mode(const struct drm_display_mode *mode)
4233{
4234        u32 layout = mode->flags & DRM_MODE_FLAG_3D_MASK;
4235
4236        switch (layout) {
4237        case DRM_MODE_FLAG_3D_FRAME_PACKING:
4238                return HDMI_3D_STRUCTURE_FRAME_PACKING;
4239        case DRM_MODE_FLAG_3D_FIELD_ALTERNATIVE:
4240                return HDMI_3D_STRUCTURE_FIELD_ALTERNATIVE;
4241        case DRM_MODE_FLAG_3D_LINE_ALTERNATIVE:
4242                return HDMI_3D_STRUCTURE_LINE_ALTERNATIVE;
4243        case DRM_MODE_FLAG_3D_SIDE_BY_SIDE_FULL:
4244                return HDMI_3D_STRUCTURE_SIDE_BY_SIDE_FULL;
4245        case DRM_MODE_FLAG_3D_L_DEPTH:
4246                return HDMI_3D_STRUCTURE_L_DEPTH;
4247        case DRM_MODE_FLAG_3D_L_DEPTH_GFX_GFX_DEPTH:
4248                return HDMI_3D_STRUCTURE_L_DEPTH_GFX_GFX_DEPTH;
4249        case DRM_MODE_FLAG_3D_TOP_AND_BOTTOM:
4250                return HDMI_3D_STRUCTURE_TOP_AND_BOTTOM;
4251        case DRM_MODE_FLAG_3D_SIDE_BY_SIDE_HALF:
4252                return HDMI_3D_STRUCTURE_SIDE_BY_SIDE_HALF;
4253        default:
4254                return HDMI_3D_STRUCTURE_INVALID;
4255        }
4256}
4257
4258/**
4259 * drm_hdmi_vendor_infoframe_from_display_mode() - fill an HDMI infoframe with
4260 * data from a DRM display mode
4261 * @frame: HDMI vendor infoframe
4262 * @mode: DRM display mode
4263 *
4264 * Note that there's is a need to send HDMI vendor infoframes only when using a
4265 * 4k or stereoscopic 3D mode. So when giving any other mode as input this
4266 * function will return -EINVAL, error that can be safely ignored.
4267 *
4268 * Return: 0 on success or a negative error code on failure.
4269 */
4270int
4271drm_hdmi_vendor_infoframe_from_display_mode(struct hdmi_vendor_infoframe *frame,
4272                                            const struct drm_display_mode *mode)
4273{
4274        int err;
4275        u32 s3d_flags;
4276        u8 vic;
4277
4278        if (!frame || !mode)
4279                return -EINVAL;
4280
4281        vic = drm_match_hdmi_mode(mode);
4282        s3d_flags = mode->flags & DRM_MODE_FLAG_3D_MASK;
4283
4284        if (!vic && !s3d_flags)
4285                return -EINVAL;
4286
4287        if (vic && s3d_flags)
4288                return -EINVAL;
4289
4290        err = hdmi_vendor_infoframe_init(frame);
4291        if (err < 0)
4292                return err;
4293
4294        if (vic)
4295                frame->vic = vic;
4296        else
4297                frame->s3d_struct = s3d_structure_from_display_mode(mode);
4298
4299        return 0;
4300}
4301EXPORT_SYMBOL(drm_hdmi_vendor_infoframe_from_display_mode);
4302
4303static int drm_parse_tiled_block(struct drm_connector *connector,
4304                                 struct displayid_block *block)
4305{
4306        struct displayid_tiled_block *tile = (struct displayid_tiled_block *)block;
4307        u16 w, h;
4308        u8 tile_v_loc, tile_h_loc;
4309        u8 num_v_tile, num_h_tile;
4310        struct drm_tile_group *tg;
4311
4312        w = tile->tile_size[0] | tile->tile_size[1] << 8;
4313        h = tile->tile_size[2] | tile->tile_size[3] << 8;
4314
4315        num_v_tile = (tile->topo[0] & 0xf) | (tile->topo[2] & 0x30);
4316        num_h_tile = (tile->topo[0] >> 4) | ((tile->topo[2] >> 2) & 0x30);
4317        tile_v_loc = (tile->topo[1] & 0xf) | ((tile->topo[2] & 0x3) << 4);
4318        tile_h_loc = (tile->topo[1] >> 4) | (((tile->topo[2] >> 2) & 0x3) << 4);
4319
4320        connector->has_tile = true;
4321        if (tile->tile_cap & 0x80)
4322                connector->tile_is_single_monitor = true;
4323
4324        connector->num_h_tile = num_h_tile + 1;
4325        connector->num_v_tile = num_v_tile + 1;
4326        connector->tile_h_loc = tile_h_loc;
4327        connector->tile_v_loc = tile_v_loc;
4328        connector->tile_h_size = w + 1;
4329        connector->tile_v_size = h + 1;
4330
4331        DRM_DEBUG_KMS("tile cap 0x%x\n", tile->tile_cap);
4332        DRM_DEBUG_KMS("tile_size %d x %d\n", w + 1, h + 1);
4333        DRM_DEBUG_KMS("topo num tiles %dx%d, location %dx%d\n",
4334                      num_h_tile + 1, num_v_tile + 1, tile_h_loc, tile_v_loc);
4335        DRM_DEBUG_KMS("vend %c%c%c\n", tile->topology_id[0], tile->topology_id[1], tile->topology_id[2]);
4336
4337        tg = drm_mode_get_tile_group(connector->dev, tile->topology_id);
4338        if (!tg) {
4339                tg = drm_mode_create_tile_group(connector->dev, tile->topology_id);
4340        }
4341        if (!tg)
4342                return -ENOMEM;
4343
4344        if (connector->tile_group != tg) {
4345                /* if we haven't got a pointer,
4346                   take the reference, drop ref to old tile group */
4347                if (connector->tile_group) {
4348                        drm_mode_put_tile_group(connector->dev, connector->tile_group);
4349                }
4350                connector->tile_group = tg;
4351        } else
4352                /* if same tile group, then release the ref we just took. */
4353                drm_mode_put_tile_group(connector->dev, tg);
4354        return 0;
4355}
4356
4357static int drm_parse_display_id(struct drm_connector *connector,
4358                                u8 *displayid, int length,
4359                                bool is_edid_extension)
4360{
4361        /* if this is an EDID extension the first byte will be 0x70 */
4362        int idx = 0;
4363        struct displayid_block *block;
4364        int ret;
4365
4366        if (is_edid_extension)
4367                idx = 1;
4368
4369        ret = validate_displayid(displayid, length, idx);
4370        if (ret)
4371                return ret;
4372
4373        idx += sizeof(struct displayid_hdr);
4374        while (block = (struct displayid_block *)&displayid[idx],
4375               idx + sizeof(struct displayid_block) <= length &&
4376               idx + sizeof(struct displayid_block) + block->num_bytes <= length &&
4377               block->num_bytes > 0) {
4378                idx += block->num_bytes + sizeof(struct displayid_block);
4379                DRM_DEBUG_KMS("block id 0x%x, rev %d, len %d\n",
4380                              block->tag, block->rev, block->num_bytes);
4381
4382                switch (block->tag) {
4383                case DATA_BLOCK_TILED_DISPLAY:
4384                        ret = drm_parse_tiled_block(connector, block);
4385                        if (ret)
4386                                return ret;
4387                        break;
4388                case DATA_BLOCK_TYPE_1_DETAILED_TIMING:
4389                        /* handled in mode gathering code. */
4390                        break;
4391                default:
4392                        DRM_DEBUG_KMS("found DisplayID tag 0x%x, unhandled\n", block->tag);
4393                        break;
4394                }
4395        }
4396        return 0;
4397}
4398
4399static void drm_get_displayid(struct drm_connector *connector,
4400                              struct edid *edid)
4401{
4402        void *displayid = NULL;
4403        int ret;
4404        connector->has_tile = false;
4405        displayid = drm_find_displayid_extension(edid);
4406        if (!displayid) {
4407                /* drop reference to any tile group we had */
4408                goto out_drop_ref;
4409        }
4410
4411        ret = drm_parse_display_id(connector, displayid, EDID_LENGTH, true);
4412        if (ret < 0)
4413                goto out_drop_ref;
4414        if (!connector->has_tile)
4415                goto out_drop_ref;
4416        return;
4417out_drop_ref:
4418        if (connector->tile_group) {
4419                drm_mode_put_tile_group(connector->dev, connector->tile_group);
4420                connector->tile_group = NULL;
4421        }
4422        return;
4423}
Note: See TracBrowser for help on using the repository browser.