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 void edid_desc_type(uint8_t *desc
, uint8_t type
)
156 static void edid_desc_text(uint8_t *desc
, uint8_t type
,
161 edid_desc_type(desc
, type
);
162 memset(desc
+ 5, ' ', 13);
168 memcpy(desc
+ 5, text
, len
);
169 desc
[5 + len
] = '\n';
172 static void edid_desc_ranges(uint8_t *desc
)
174 edid_desc_type(desc
, 0xfd);
176 /* vertical (50 -> 125 Hz) */
180 /* horizontal (30 -> 160 kHz) */
184 /* max dot clock (1200 MHz) */
187 /* no extended timing information */
192 memset(desc
+ 12, ' ', 6);
195 /* additional standard timings 3 */
196 static void edid_desc_xtra3_std(uint8_t *desc
)
198 edid_desc_type(desc
, 0xf7);
202 static void edid_desc_dummy(uint8_t *desc
)
204 edid_desc_type(desc
, 0x10);
207 static void edid_desc_timing(uint8_t *desc
,
208 uint32_t xres
, uint32_t yres
,
209 uint32_t xmm
, uint32_t ymm
)
211 /* pull some realistic looking timings out of thin air */
212 uint32_t xfront
= xres
* 25 / 100;
213 uint32_t xsync
= xres
* 3 / 100;
214 uint32_t xblank
= xres
* 35 / 100;
216 uint32_t yfront
= yres
* 5 / 1000;
217 uint32_t ysync
= yres
* 5 / 1000;
218 uint32_t yblank
= yres
* 35 / 1000;
220 uint32_t clock
= 75 * (xres
+ xblank
) * (yres
+ yblank
);
222 stl_le_p(desc
, clock
/ 10000);
224 desc
[2] = xres
& 0xff;
225 desc
[3] = xblank
& 0xff;
226 desc
[4] = (((xres
& 0xf00) >> 4) |
227 ((xblank
& 0xf00) >> 8));
229 desc
[5] = yres
& 0xff;
230 desc
[6] = yblank
& 0xff;
231 desc
[7] = (((yres
& 0xf00) >> 4) |
232 ((yblank
& 0xf00) >> 8));
234 desc
[8] = xfront
& 0xff;
235 desc
[9] = xsync
& 0xff;
237 desc
[10] = (((yfront
& 0x00f) << 4) |
238 ((ysync
& 0x00f) << 0));
239 desc
[11] = (((xfront
& 0x300) >> 2) |
240 ((xsync
& 0x300) >> 4) |
241 ((yfront
& 0x030) >> 2) |
242 ((ysync
& 0x030) >> 4));
244 desc
[12] = xmm
& 0xff;
245 desc
[13] = ymm
& 0xff;
246 desc
[14] = (((xmm
& 0xf00) >> 4) |
247 ((ymm
& 0xf00) >> 8));
252 static uint32_t edid_to_10bit(float value
)
254 return (uint32_t)(value
* 1024 + 0.5);
257 static void edid_colorspace(uint8_t *edid
,
263 uint32_t red_x
= edid_to_10bit(rx
);
264 uint32_t red_y
= edid_to_10bit(ry
);
265 uint32_t green_x
= edid_to_10bit(gx
);
266 uint32_t green_y
= edid_to_10bit(gy
);
267 uint32_t blue_x
= edid_to_10bit(bx
);
268 uint32_t blue_y
= edid_to_10bit(by
);
269 uint32_t white_x
= edid_to_10bit(wx
);
270 uint32_t white_y
= edid_to_10bit(wy
);
272 edid
[25] = (((red_x
& 0x03) << 6) |
273 ((red_y
& 0x03) << 4) |
274 ((green_x
& 0x03) << 2) |
275 ((green_y
& 0x03) << 0));
276 edid
[26] = (((blue_x
& 0x03) << 6) |
277 ((blue_y
& 0x03) << 4) |
278 ((white_x
& 0x03) << 2) |
279 ((white_y
& 0x03) << 0));
280 edid
[27] = red_x
>> 2;
281 edid
[28] = red_y
>> 2;
282 edid
[29] = green_x
>> 2;
283 edid
[30] = green_y
>> 2;
284 edid
[31] = blue_x
>> 2;
285 edid
[32] = blue_y
>> 2;
286 edid
[33] = white_x
>> 2;
287 edid
[34] = white_y
>> 2;
290 static uint32_t qemu_edid_dpi_from_mm(uint32_t mm
, uint32_t res
)
292 return res
* 254 / 10 / mm
;
295 uint32_t qemu_edid_dpi_to_mm(uint32_t dpi
, uint32_t res
)
297 return res
* 254 / 10 / dpi
;
300 void qemu_edid_generate(uint8_t *edid
, size_t size
,
301 qemu_edid_info
*info
)
304 uint8_t *xtra3
= NULL
;
306 uint32_t width_mm
, height_mm
;
307 uint32_t dpi
= 100; /* if no width_mm/height_mm */
309 /* =============== set defaults =============== */
311 if (!info
->vendor
|| strlen(info
->vendor
) != 3) {
312 info
->vendor
= "RHT";
315 info
->name
= "QEMU Monitor";
323 if (info
->width_mm
&& info
->height_mm
) {
324 width_mm
= info
->width_mm
;
325 height_mm
= info
->height_mm
;
326 dpi
= qemu_edid_dpi_from_mm(width_mm
, info
->prefx
);
328 width_mm
= qemu_edid_dpi_to_mm(dpi
, info
->prefx
);
329 height_mm
= qemu_edid_dpi_to_mm(dpi
, info
->prefy
);
332 /* =============== extensions =============== */
340 /* =============== header information =============== */
352 /* manufacturer id, product code, serial number */
353 uint16_t vendor_id
= ((((info
->vendor
[0] - '@') & 0x1f) << 10) |
354 (((info
->vendor
[1] - '@') & 0x1f) << 5) |
355 (((info
->vendor
[2] - '@') & 0x1f) << 0));
356 uint16_t model_nr
= 0x1234;
357 uint32_t serial_nr
= info
->serial
? atoi(info
->serial
) : 0;
358 stw_be_p(edid
+ 8, vendor_id
);
359 stw_le_p(edid
+ 10, model_nr
);
360 stl_le_p(edid
+ 12, serial_nr
);
362 /* manufacture week and year */
364 edid
[17] = 2014 - 1990;
371 /* =============== basic display parameters =============== */
373 /* video input: digital, 8bpc, displayport */
376 /* screen size: undefined */
377 edid
[21] = width_mm
/ 10;
378 edid
[22] = height_mm
/ 10;
380 /* display gamma: 2.2 */
381 edid
[23] = 220 - 100;
383 /* supported features bitmap: std sRGB, preferred timing */
387 /* =============== chromaticity coordinates =============== */
389 /* standard sRGB colorspace */
390 edid_colorspace(edid
,
391 0.6400, 0.3300, /* red */
392 0.3000, 0.6000, /* green */
393 0.1500, 0.0600, /* blue */
394 0.3127, 0.3290); /* white point */
396 /* =============== established timing bitmap =============== */
397 /* =============== standard timing information =============== */
399 /* both filled by edid_fill_modes() */
402 /* =============== descriptor blocks =============== */
404 edid_desc_timing(edid
+ desc
, info
->prefx
, info
->prefy
,
405 width_mm
, height_mm
);
408 edid_desc_ranges(edid
+ desc
);
412 edid_desc_text(edid
+ desc
, 0xfc, info
->name
);
417 edid_desc_text(edid
+ desc
, 0xff, info
->serial
);
423 edid_desc_xtra3_std(xtra3
);
428 edid_desc_dummy(edid
+ desc
);
432 /* =============== finish up =============== */
434 edid_fill_modes(edid
, xtra3
, dta
, info
->maxx
, info
->maxy
);
441 size_t qemu_edid_size(uint8_t *edid
)
445 if (edid
[0] != 0x00 ||
447 /* doesn't look like a valid edid block */
452 return 128 * (exts
+ 1);