1
2
3
4
5
6
7#include "qemu/osdep.h"
8#include "qemu/bswap.h"
9#include "hw/display/edid.h"
10
11static const struct edid_mode {
12 uint32_t xres;
13 uint32_t yres;
14 uint32_t byte;
15 uint32_t xtra3;
16 uint32_t bit;
17 uint32_t dta;
18} modes[] = {
19
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 },
26
27
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 },
35
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 },
41
42
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 },
46};
47
48static void edid_ext_dta(uint8_t *dta)
49{
50 dta[0] = 0x02;
51 dta[1] = 0x03;
52 dta[2] = 0x05;
53 dta[3] = 0x00;
54
55
56 dta[4] = 0x40;
57}
58
59static void edid_ext_dta_mode(uint8_t *dta, uint8_t nr)
60{
61 dta[dta[2]] = nr;
62 dta[2]++;
63 dta[4]++;
64}
65
66static int edid_std_mode(uint8_t *mode, uint32_t xres, uint32_t yres)
67{
68 uint32_t aspect;
69
70 if (xres == 0 || yres == 0) {
71 mode[0] = 0x01;
72 mode[1] = 0x01;
73 return 0;
74
75 } else if (xres * 10 == yres * 16) {
76 aspect = 0;
77 } else if (xres * 3 == yres * 4) {
78 aspect = 1;
79 } else if (xres * 4 == yres * 5) {
80 aspect = 2;
81 } else if (xres * 9 == yres * 16) {
82 aspect = 3;
83 } else {
84 return -1;
85 }
86
87 if ((xres / 8) - 31 > 255) {
88 return -1;
89 }
90
91 mode[0] = (xres / 8) - 31;
92 mode[1] = ((aspect << 6) | (60 - 60));
93 return 0;
94}
95
96static void edid_fill_modes(uint8_t *edid, uint8_t *xtra3, uint8_t *dta,
97 uint32_t maxx, uint32_t maxy)
98{
99 const struct edid_mode *mode;
100 int std = 38;
101 int rc, i;
102
103 for (i = 0; i < ARRAY_SIZE(modes); i++) {
104 mode = modes + i;
105
106 if ((maxx && mode->xres > maxx) ||
107 (maxy && mode->yres > maxy)) {
108 continue;
109 }
110
111 if (mode->byte) {
112 edid[mode->byte] |= (1 << mode->bit);
113 } else if (std < 54) {
114 rc = edid_std_mode(edid + std, mode->xres, mode->yres);
115 if (rc == 0) {
116 std += 2;
117 }
118 } else if (mode->xtra3 && xtra3) {
119 xtra3[mode->xtra3] |= (1 << mode->bit);
120 }
121
122 if (dta && mode->dta) {
123 edid_ext_dta_mode(dta, mode->dta);
124 }
125 }
126
127 while (std < 54) {
128 edid_std_mode(edid + std, 0, 0);
129 std += 2;
130 }
131}
132
133static void edid_checksum(uint8_t *edid)
134{
135 uint32_t sum = 0;
136 int i;
137
138 for (i = 0; i < 127; i++) {
139 sum += edid[i];
140 }
141 sum &= 0xff;
142 if (sum) {
143 edid[127] = 0x100 - sum;
144 }
145}
146
147static void edid_desc_type(uint8_t *desc, uint8_t type)
148{
149 desc[0] = 0;
150 desc[1] = 0;
151 desc[2] = 0;
152 desc[3] = type;
153 desc[4] = 0;
154}
155
156static void edid_desc_text(uint8_t *desc, uint8_t type,
157 const char *text)
158{
159 size_t len;
160
161 edid_desc_type(desc, type);
162 memset(desc + 5, ' ', 13);
163
164 len = strlen(text);
165 if (len > 12) {
166 len = 12;
167 }
168 memcpy(desc + 5, text, len);
169 desc[5 + len] = '\n';
170}
171
172static void edid_desc_ranges(uint8_t *desc)
173{
174 edid_desc_type(desc, 0xfd);
175
176
177 desc[5] = 50;
178 desc[6] = 125;
179
180
181 desc[7] = 30;
182 desc[8] = 160;
183
184
185 desc[9] = 1200 / 10;
186
187
188 desc[10] = 0x01;
189
190
191 desc[11] = '\n';
192 memset(desc + 12, ' ', 6);
193}
194
195
196static void edid_desc_xtra3_std(uint8_t *desc)
197{
198 edid_desc_type(desc, 0xf7);
199 desc[5] = 10;
200}
201
202static void edid_desc_dummy(uint8_t *desc)
203{
204 edid_desc_type(desc, 0x10);
205}
206
207static void edid_desc_timing(uint8_t *desc,
208 uint32_t xres, uint32_t yres,
209 uint32_t xmm, uint32_t ymm)
210{
211
212 uint32_t xfront = xres * 25 / 100;
213 uint32_t xsync = xres * 3 / 100;
214 uint32_t xblank = xres * 35 / 100;
215
216 uint32_t yfront = yres * 5 / 1000;
217 uint32_t ysync = yres * 5 / 1000;
218 uint32_t yblank = yres * 35 / 1000;
219
220 uint32_t clock = 75 * (xres + xblank) * (yres + yblank);
221
222 stl_le_p(desc, clock / 10000);
223
224 desc[2] = xres & 0xff;
225 desc[3] = xblank & 0xff;
226 desc[4] = (((xres & 0xf00) >> 4) |
227 ((xblank & 0xf00) >> 8));
228
229 desc[5] = yres & 0xff;
230 desc[6] = yblank & 0xff;
231 desc[7] = (((yres & 0xf00) >> 4) |
232 ((yblank & 0xf00) >> 8));
233
234 desc[8] = xfront & 0xff;
235 desc[9] = xsync & 0xff;
236
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));
243
244 desc[12] = xmm & 0xff;
245 desc[13] = ymm & 0xff;
246 desc[14] = (((xmm & 0xf00) >> 4) |
247 ((ymm & 0xf00) >> 8));
248
249 desc[17] = 0x18;
250}
251
252static uint32_t edid_to_10bit(float value)
253{
254 return (uint32_t)(value * 1024 + 0.5);
255}
256
257static void edid_colorspace(uint8_t *edid,
258 float rx, float ry,
259 float gx, float gy,
260 float bx, float by,
261 float wx, float wy)
262{
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);
271
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;
288}
289
290static uint32_t qemu_edid_dpi_from_mm(uint32_t mm, uint32_t res)
291{
292 return res * 254 / 10 / mm;
293}
294
295uint32_t qemu_edid_dpi_to_mm(uint32_t dpi, uint32_t res)
296{
297 return res * 254 / 10 / dpi;
298}
299
300void qemu_edid_generate(uint8_t *edid, size_t size,
301 qemu_edid_info *info)
302{
303 uint32_t desc = 54;
304 uint8_t *xtra3 = NULL;
305 uint8_t *dta = NULL;
306 uint32_t width_mm, height_mm;
307 uint32_t dpi = 100;
308
309
310
311 if (!info->vendor || strlen(info->vendor) != 3) {
312 info->vendor = "RHT";
313 }
314 if (!info->name) {
315 info->name = "QEMU Monitor";
316 }
317 if (!info->prefx) {
318 info->prefx = 1024;
319 }
320 if (!info->prefy) {
321 info->prefy = 768;
322 }
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);
327 } else {
328 width_mm = qemu_edid_dpi_to_mm(dpi, info->prefx);
329 height_mm = qemu_edid_dpi_to_mm(dpi, info->prefy);
330 }
331
332
333
334 if (size >= 256) {
335 dta = edid + 128;
336 edid[126]++;
337 edid_ext_dta(dta);
338 }
339
340
341
342
343 edid[0] = 0x00;
344 edid[1] = 0xff;
345 edid[2] = 0xff;
346 edid[3] = 0xff;
347 edid[4] = 0xff;
348 edid[5] = 0xff;
349 edid[6] = 0xff;
350 edid[7] = 0x00;
351
352
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);
361
362
363 edid[16] = 42;
364 edid[17] = 2014 - 1990;
365
366
367 edid[18] = 1;
368 edid[19] = 4;
369
370
371
372
373
374 edid[20] = 0xa5;
375
376
377 edid[21] = width_mm / 10;
378 edid[22] = height_mm / 10;
379
380
381 edid[23] = 220 - 100;
382
383
384 edid[24] = 0x06;
385
386
387
388
389
390 edid_colorspace(edid,
391 0.6400, 0.3300,
392 0.3000, 0.6000,
393 0.1500, 0.0600,
394 0.3127, 0.3290);
395
396
397
398
399
400
401
402
403
404 edid_desc_timing(edid + desc, info->prefx, info->prefy,
405 width_mm, height_mm);
406 desc += 18;
407
408 edid_desc_ranges(edid + desc);
409 desc += 18;
410
411 if (info->name) {
412 edid_desc_text(edid + desc, 0xfc, info->name);
413 desc += 18;
414 }
415
416 if (info->serial) {
417 edid_desc_text(edid + desc, 0xff, info->serial);
418 desc += 18;
419 }
420
421 if (desc < 126) {
422 xtra3 = edid + desc;
423 edid_desc_xtra3_std(xtra3);
424 desc += 18;
425 }
426
427 while (desc < 126) {
428 edid_desc_dummy(edid + desc);
429 desc += 18;
430 }
431
432
433
434 edid_fill_modes(edid, xtra3, dta, info->maxx, info->maxy);
435 edid_checksum(edid);
436 if (dta) {
437 edid_checksum(dta);
438 }
439}
440
441size_t qemu_edid_size(uint8_t *edid)
442{
443 uint32_t exts;
444
445 if (edid[0] != 0x00 ||
446 edid[1] != 0xff) {
447
448 return 0;
449 }
450
451 exts = edid[126];
452 return 128 * (exts + 1);
453}
454