4 * This work is licensed under the terms of the GNU GPL, version 2 or later.
5 * See the COPYING file in the top-level directory.
7 #include "qemu/osdep.h"
8 #include "qemu/bswap.h"
9 #include "hw/display/edid.h"
11 static const struct edid_mode
{
19 /* dea/dta extension timings (all @ 50 Hz) */
20 { .xres
= 5120, .yres
= 2160, .dta
= 125 },
21 { .xres
= 4096, .yres
= 2160, .dta
= 101 },
22 { .xres
= 3840, .yres
= 2160, .dta
= 96 },
23 { .xres
= 2560, .yres
= 1080, .dta
= 89 },
24 { .xres
= 2048, .yres
= 1152 },
25 { .xres
= 1920, .yres
= 1080, .dta
= 31 },
27 /* additional standard timings 3 (all @ 60Hz) */
28 { .xres
= 1920, .yres
= 1200, .xtra3
= 10, .bit
= 0 },
29 { .xres
= 1600, .yres
= 1200, .xtra3
= 9, .bit
= 2 },
30 { .xres
= 1680, .yres
= 1050, .xtra3
= 9, .bit
= 5 },
31 { .xres
= 1440, .yres
= 900, .xtra3
= 8, .bit
= 5 },
32 { .xres
= 1280, .yres
= 1024, .xtra3
= 7, .bit
= 1 },
33 { .xres
= 1280, .yres
= 960, .xtra3
= 7, .bit
= 3 },
34 { .xres
= 1280, .yres
= 768, .xtra3
= 7, .bit
= 6 },
36 { .xres
= 1920, .yres
= 1440, .xtra3
= 11, .bit
= 5 },
37 { .xres
= 1856, .yres
= 1392, .xtra3
= 10, .bit
= 3 },
38 { .xres
= 1792, .yres
= 1344, .xtra3
= 10, .bit
= 5 },
39 { .xres
= 1440, .yres
= 1050, .xtra3
= 8, .bit
= 1 },
40 { .xres
= 1360, .yres
= 768, .xtra3
= 8, .bit
= 7 },
42 /* established timings (all @ 60Hz) */
43 { .xres
= 1024, .yres
= 768, .byte
= 36, .bit
= 3 },
44 { .xres
= 800, .yres
= 600, .byte
= 35, .bit
= 0 },
45 { .xres
= 640, .yres
= 480, .byte
= 35, .bit
= 5 },
48 static void edid_ext_dta(uint8_t *dta
)
55 /* video data block */
59 static void edid_ext_dta_mode(uint8_t *dta
, uint8_t nr
)
66 static int edid_std_mode(uint8_t *mode
, uint32_t xres
, uint32_t yres
)
70 if (xres
== 0 || yres
== 0) {
75 } else if (xres
* 10 == yres
* 16) {
77 } else if (xres
* 3 == yres
* 4) {
79 } else if (xres
* 4 == yres
* 5) {
81 } else if (xres
* 9 == yres
* 16) {
87 if ((xres
/ 8) - 31 > 255) {
91 mode
[0] = (xres
/ 8) - 31;
92 mode
[1] = ((aspect
<< 6) | (60 - 60));
96 static void edid_fill_modes(uint8_t *edid
, uint8_t *xtra3
, uint8_t *dta
,
97 uint32_t maxx
, uint32_t maxy
)
99 const struct edid_mode
*mode
;
103 for (i
= 0; i
< ARRAY_SIZE(modes
); i
++) {
106 if ((maxx
&& mode
->xres
> maxx
) ||
107 (maxy
&& mode
->yres
> maxy
)) {
112 edid
[mode
->byte
] |= (1 << mode
->bit
);
113 } else if (std
< 54) {
114 rc
= edid_std_mode(edid
+ std
, mode
->xres
, mode
->yres
);
118 } else if (mode
->xtra3
&& xtra3
) {
119 xtra3
[mode
->xtra3
] |= (1 << mode
->bit
);
122 if (dta
&& mode
->dta
) {
123 edid_ext_dta_mode(dta
, mode
->dta
);
128 edid_std_mode(edid
+ std
, 0, 0);
133 static void edid_checksum(uint8_t *edid
)
138 for (i
= 0; i
< 127; i
++) {
143 edid
[127] = 0x100 - sum
;
147 static uint8_t *edid_desc_next(uint8_t *edid
, uint8_t *dta
, uint8_t *desc
)
152 if (desc
+ 18 + 18 < edid
+ 127) {
156 if (desc
< edid
+ 127) {
159 if (desc
+ 18 + 18 < dta
+ 127) {
166 static void edid_desc_type(uint8_t *desc
, uint8_t type
)
175 static void edid_desc_text(uint8_t *desc
, uint8_t type
,
180 edid_desc_type(desc
, type
);
181 memset(desc
+ 5, ' ', 13);
187 memcpy(desc
+ 5, text
, len
);
188 desc
[5 + len
] = '\n';
191 static void edid_desc_ranges(uint8_t *desc
)
193 edid_desc_type(desc
, 0xfd);
195 /* vertical (50 -> 125 Hz) */
199 /* horizontal (30 -> 160 kHz) */
203 /* max dot clock (1200 MHz) */
206 /* no extended timing information */
211 memset(desc
+ 12, ' ', 6);
214 /* additional standard timings 3 */
215 static void edid_desc_xtra3_std(uint8_t *desc
)
217 edid_desc_type(desc
, 0xf7);
221 static void edid_desc_dummy(uint8_t *desc
)
223 edid_desc_type(desc
, 0x10);
226 static void edid_desc_timing(uint8_t *desc
, uint32_t refresh_rate
,
227 uint32_t xres
, uint32_t yres
,
228 uint32_t xmm
, uint32_t ymm
)
230 /* pull some realistic looking timings out of thin air */
231 uint32_t xfront
= xres
* 25 / 100;
232 uint32_t xsync
= xres
* 3 / 100;
233 uint32_t xblank
= xres
* 35 / 100;
235 uint32_t yfront
= yres
* 5 / 1000;
236 uint32_t ysync
= yres
* 5 / 1000;
237 uint32_t yblank
= yres
* 35 / 1000;
239 uint64_t clock
= (uint64_t)refresh_rate
* (xres
+ xblank
) * (yres
+ yblank
);
241 stl_le_p(desc
, clock
/ 10000000);
243 desc
[2] = xres
& 0xff;
244 desc
[3] = xblank
& 0xff;
245 desc
[4] = (((xres
& 0xf00) >> 4) |
246 ((xblank
& 0xf00) >> 8));
248 desc
[5] = yres
& 0xff;
249 desc
[6] = yblank
& 0xff;
250 desc
[7] = (((yres
& 0xf00) >> 4) |
251 ((yblank
& 0xf00) >> 8));
253 desc
[8] = xfront
& 0xff;
254 desc
[9] = xsync
& 0xff;
256 desc
[10] = (((yfront
& 0x00f) << 4) |
257 ((ysync
& 0x00f) << 0));
258 desc
[11] = (((xfront
& 0x300) >> 2) |
259 ((xsync
& 0x300) >> 4) |
260 ((yfront
& 0x030) >> 2) |
261 ((ysync
& 0x030) >> 4));
263 desc
[12] = xmm
& 0xff;
264 desc
[13] = ymm
& 0xff;
265 desc
[14] = (((xmm
& 0xf00) >> 4) |
266 ((ymm
& 0xf00) >> 8));
271 static uint32_t edid_to_10bit(float value
)
273 return (uint32_t)(value
* 1024 + 0.5);
276 static void edid_colorspace(uint8_t *edid
,
282 uint32_t red_x
= edid_to_10bit(rx
);
283 uint32_t red_y
= edid_to_10bit(ry
);
284 uint32_t green_x
= edid_to_10bit(gx
);
285 uint32_t green_y
= edid_to_10bit(gy
);
286 uint32_t blue_x
= edid_to_10bit(bx
);
287 uint32_t blue_y
= edid_to_10bit(by
);
288 uint32_t white_x
= edid_to_10bit(wx
);
289 uint32_t white_y
= edid_to_10bit(wy
);
291 edid
[25] = (((red_x
& 0x03) << 6) |
292 ((red_y
& 0x03) << 4) |
293 ((green_x
& 0x03) << 2) |
294 ((green_y
& 0x03) << 0));
295 edid
[26] = (((blue_x
& 0x03) << 6) |
296 ((blue_y
& 0x03) << 4) |
297 ((white_x
& 0x03) << 2) |
298 ((white_y
& 0x03) << 0));
299 edid
[27] = red_x
>> 2;
300 edid
[28] = red_y
>> 2;
301 edid
[29] = green_x
>> 2;
302 edid
[30] = green_y
>> 2;
303 edid
[31] = blue_x
>> 2;
304 edid
[32] = blue_y
>> 2;
305 edid
[33] = white_x
>> 2;
306 edid
[34] = white_y
>> 2;
309 static uint32_t qemu_edid_dpi_from_mm(uint32_t mm
, uint32_t res
)
311 return res
* 254 / 10 / mm
;
314 uint32_t qemu_edid_dpi_to_mm(uint32_t dpi
, uint32_t res
)
316 return res
* 254 / 10 / dpi
;
319 void qemu_edid_generate(uint8_t *edid
, size_t size
,
320 qemu_edid_info
*info
)
322 uint8_t *desc
= edid
+ 54;
323 uint8_t *xtra3
= NULL
;
325 uint32_t width_mm
, height_mm
;
326 uint32_t refresh_rate
= info
->refresh_rate
? info
->refresh_rate
: 75000;
327 uint32_t dpi
= 100; /* if no width_mm/height_mm */
329 /* =============== set defaults =============== */
331 if (!info
->vendor
|| strlen(info
->vendor
) != 3) {
332 info
->vendor
= "RHT";
335 info
->name
= "QEMU Monitor";
343 if (info
->width_mm
&& info
->height_mm
) {
344 width_mm
= info
->width_mm
;
345 height_mm
= info
->height_mm
;
346 dpi
= qemu_edid_dpi_from_mm(width_mm
, info
->prefx
);
348 width_mm
= qemu_edid_dpi_to_mm(dpi
, info
->prefx
);
349 height_mm
= qemu_edid_dpi_to_mm(dpi
, info
->prefy
);
352 /* =============== extensions =============== */
360 /* =============== header information =============== */
372 /* manufacturer id, product code, serial number */
373 uint16_t vendor_id
= ((((info
->vendor
[0] - '@') & 0x1f) << 10) |
374 (((info
->vendor
[1] - '@') & 0x1f) << 5) |
375 (((info
->vendor
[2] - '@') & 0x1f) << 0));
376 uint16_t model_nr
= 0x1234;
377 uint32_t serial_nr
= info
->serial
? atoi(info
->serial
) : 0;
378 stw_be_p(edid
+ 8, vendor_id
);
379 stw_le_p(edid
+ 10, model_nr
);
380 stl_le_p(edid
+ 12, serial_nr
);
382 /* manufacture week and year */
384 edid
[17] = 2014 - 1990;
391 /* =============== basic display parameters =============== */
393 /* video input: digital, 8bpc, displayport */
396 /* screen size: undefined */
397 edid
[21] = width_mm
/ 10;
398 edid
[22] = height_mm
/ 10;
400 /* display gamma: 2.2 */
401 edid
[23] = 220 - 100;
403 /* supported features bitmap: std sRGB, preferred timing */
407 /* =============== chromaticity coordinates =============== */
409 /* standard sRGB colorspace */
410 edid_colorspace(edid
,
411 0.6400, 0.3300, /* red */
412 0.3000, 0.6000, /* green */
413 0.1500, 0.0600, /* blue */
414 0.3127, 0.3290); /* white point */
416 /* =============== established timing bitmap =============== */
417 /* =============== standard timing information =============== */
419 /* both filled by edid_fill_modes() */
422 /* =============== descriptor blocks =============== */
424 edid_desc_timing(desc
, refresh_rate
, info
->prefx
, info
->prefy
,
425 width_mm
, height_mm
);
426 desc
= edid_desc_next(edid
, dta
, desc
);
429 edid_desc_xtra3_std(xtra3
);
430 desc
= edid_desc_next(edid
, dta
, desc
);
431 edid_fill_modes(edid
, xtra3
, dta
, info
->maxx
, info
->maxy
);
433 * dta video data block is finished at thus point,
434 * so dta descriptor offsets don't move any more.
437 edid_desc_ranges(desc
);
438 desc
= edid_desc_next(edid
, dta
, desc
);
440 if (desc
&& info
->name
) {
441 edid_desc_text(desc
, 0xfc, info
->name
);
442 desc
= edid_desc_next(edid
, dta
, desc
);
445 if (desc
&& info
->serial
) {
446 edid_desc_text(desc
, 0xff, info
->serial
);
447 desc
= edid_desc_next(edid
, dta
, desc
);
451 edid_desc_dummy(desc
);
452 desc
= edid_desc_next(edid
, dta
, desc
);
455 /* =============== finish up =============== */
463 size_t qemu_edid_size(uint8_t *edid
)
467 if (edid
[0] != 0x00 ||
469 /* doesn't look like a valid edid block */
474 return 128 * (exts
+ 1);