xref: /qemu/hw/display/edid-generate.c (revision 7cebff0d) 
1 /*
2  * QEMU EDID generator.
3  *
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.
6  */
7 #include "qemu/osdep.h"
8 #include "qemu/bswap.h"
9 #include "hw/display/edid.h"
10 
11 static 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     /* 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 },
26 
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 },
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     /* 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 },
46 };
47 
48 static 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     /* video data block */
56     dta[4] = 0x40;
57 }
58 
59 static 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 
66 static 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 
96 static 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 
133 static 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 
147 static 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 
156 static 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 
172 static void edid_desc_ranges(uint8_t *desc)
173 {
174     edid_desc_type(desc, 0xfd);
175 
176     /* vertical (50 -> 125 Hz) */
177     desc[5] =  50;
178     desc[6] = 125;
179 
180     /* horizontal (30 -> 160 kHz) */
181     desc[7] =  30;
182     desc[8] = 160;
183 
184     /* max dot clock (1200 MHz) */
185     desc[9] = 1200 / 10;
186 
187     /* no extended timing information */
188     desc[10] = 0x01;
189 
190     /* padding */
191     desc[11] = '\n';
192     memset(desc + 12, ' ', 6);
193 }
194 
195 /* additional standard timings 3 */
196 static void edid_desc_xtra3_std(uint8_t *desc)
197 {
198     edid_desc_type(desc, 0xf7);
199     desc[5] = 10;
200 }
201 
202 static void edid_desc_dummy(uint8_t *desc)
203 {
204     edid_desc_type(desc, 0x10);
205 }
206 
207 static void edid_desc_timing(uint8_t *desc,
208                              uint32_t xres, uint32_t yres,
209                              uint32_t xmm, uint32_t ymm)
210 {
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;
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 
252 static uint32_t edid_to_10bit(float value)
253 {
254     return (uint32_t)(value * 1024 + 0.5);
255 }
256 
257 static 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 
290 static uint32_t qemu_edid_dpi_from_mm(uint32_t mm, uint32_t res)
291 {
292     return res * 254 / 10 / mm;
293 }
294 
295 uint32_t qemu_edid_dpi_to_mm(uint32_t dpi, uint32_t res)
296 {
297     return res * 254 / 10 / dpi;
298 }
299 
300 void 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; /* if no width_mm/height_mm */
308 
309     /* =============== set defaults  =============== */
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     /* =============== extensions  =============== */
333 
334     if (size >= 256) {
335         dta = edid + 128;
336         edid[126]++;
337         edid_ext_dta(dta);
338     }
339 
340     /* =============== header information =============== */
341 
342     /* fixed */
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     /* 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);
361 
362     /* manufacture week and year */
363     edid[16] = 42;
364     edid[17] = 2014 - 1990;
365 
366     /* edid version */
367     edid[18] = 1;
368     edid[19] = 4;
369 
370 
371     /* =============== basic display parameters =============== */
372 
373     /* video input: digital, 8bpc, displayport */
374     edid[20] = 0xa5;
375 
376     /* screen size: undefined */
377     edid[21] = width_mm / 10;
378     edid[22] = height_mm / 10;
379 
380     /* display gamma: 2.2 */
381     edid[23] = 220 - 100;
382 
383     /* supported features bitmap: std sRGB, preferred timing */
384     edid[24] = 0x06;
385 
386 
387     /* =============== chromaticity coordinates =============== */
388 
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  */
395 
396     /* =============== established timing bitmap =============== */
397     /* =============== standard timing information =============== */
398 
399     /* both filled by edid_fill_modes() */
400 
401 
402     /* =============== descriptor blocks =============== */
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     /* =============== finish up =============== */
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 
441 size_t qemu_edid_size(uint8_t *edid)
442 {
443     uint32_t exts;
444 
445     if (edid[0] != 0x00 ||
446         edid[1] != 0xff) {
447         /* doesn't look like a valid edid block */
448         return 0;
449     }
450 
451     exts = edid[126];
452     return 128 * (exts + 1);
453 }
454