hw/arm/bcm2836: Only provide "enabled-cpus" property to multicore SoCs
[qemu.git] / hw / display / edid-generate.c
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 = 1440, .xtra3 = 11, .bit = 5 },
29 { .xres = 1920, .yres = 1200, .xtra3 = 10, .bit = 0 },
30 { .xres = 1856, .yres = 1392, .xtra3 = 10, .bit = 3 },
31 { .xres = 1792, .yres = 1344, .xtra3 = 10, .bit = 5 },
32 { .xres = 1600, .yres = 1200, .xtra3 = 9, .bit = 2 },
33 { .xres = 1680, .yres = 1050, .xtra3 = 9, .bit = 5 },
34 { .xres = 1440, .yres = 1050, .xtra3 = 8, .bit = 1 },
35 { .xres = 1440, .yres = 900, .xtra3 = 8, .bit = 5 },
36 { .xres = 1360, .yres = 768, .xtra3 = 8, .bit = 7 },
37 { .xres = 1280, .yres = 1024, .xtra3 = 7, .bit = 1 },
38 { .xres = 1280, .yres = 960, .xtra3 = 7, .bit = 3 },
39 { .xres = 1280, .yres = 768, .xtra3 = 7, .bit = 6 },
40
41 /* established timings (all @ 60Hz) */
42 { .xres = 1024, .yres = 768, .byte = 36, .bit = 3 },
43 { .xres = 800, .yres = 600, .byte = 35, .bit = 0 },
44 { .xres = 640, .yres = 480, .byte = 35, .bit = 5 },
45 };
46
47 static void edid_ext_dta(uint8_t *dta)
48 {
49 dta[0] = 0x02;
50 dta[1] = 0x03;
51 dta[2] = 0x05;
52 dta[3] = 0x00;
53
54 /* video data block */
55 dta[4] = 0x40;
56 }
57
58 static void edid_ext_dta_mode(uint8_t *dta, uint8_t nr)
59 {
60 dta[dta[2]] = nr;
61 dta[2]++;
62 dta[4]++;
63 }
64
65 static int edid_std_mode(uint8_t *mode, uint32_t xres, uint32_t yres)
66 {
67 uint32_t aspect;
68
69 if (xres == 0 || yres == 0) {
70 mode[0] = 0x01;
71 mode[1] = 0x01;
72 return 0;
73
74 } else if (xres * 10 == yres * 16) {
75 aspect = 0;
76 } else if (xres * 3 == yres * 4) {
77 aspect = 1;
78 } else if (xres * 4 == yres * 5) {
79 aspect = 2;
80 } else if (xres * 9 == yres * 16) {
81 aspect = 3;
82 } else {
83 return -1;
84 }
85
86 if ((xres / 8) - 31 > 255) {
87 return -1;
88 }
89
90 mode[0] = (xres / 8) - 31;
91 mode[1] = ((aspect << 6) | (60 - 60));
92 return 0;
93 }
94
95 static void edid_fill_modes(uint8_t *edid, uint8_t *xtra3, uint8_t *dta,
96 uint32_t maxx, uint32_t maxy)
97 {
98 const struct edid_mode *mode;
99 int std = 38;
100 int rc, i;
101
102 for (i = 0; i < ARRAY_SIZE(modes); i++) {
103 mode = modes + i;
104
105 if ((maxx && mode->xres > maxx) ||
106 (maxy && mode->yres > maxy)) {
107 continue;
108 }
109
110 if (mode->byte) {
111 edid[mode->byte] |= (1 << mode->bit);
112 } else if (mode->xtra3 && xtra3) {
113 xtra3[mode->xtra3] |= (1 << mode->bit);
114 } else if (std < 54) {
115 rc = edid_std_mode(edid + std, mode->xres, mode->yres);
116 if (rc == 0) {
117 std += 2;
118 }
119 }
120
121 if (dta && mode->dta) {
122 edid_ext_dta_mode(dta, mode->dta);
123 }
124 }
125
126 while (std < 54) {
127 edid_std_mode(edid + std, 0, 0);
128 std += 2;
129 }
130 }
131
132 static void edid_checksum(uint8_t *edid)
133 {
134 uint32_t sum = 0;
135 int i;
136
137 for (i = 0; i < 127; i++) {
138 sum += edid[i];
139 }
140 sum &= 0xff;
141 if (sum) {
142 edid[127] = 0x100 - sum;
143 }
144 }
145
146 static void edid_desc_type(uint8_t *desc, uint8_t type)
147 {
148 desc[0] = 0;
149 desc[1] = 0;
150 desc[2] = 0;
151 desc[3] = type;
152 desc[4] = 0;
153 }
154
155 static void edid_desc_text(uint8_t *desc, uint8_t type,
156 const char *text)
157 {
158 size_t len;
159
160 edid_desc_type(desc, type);
161 memset(desc + 5, ' ', 13);
162
163 len = strlen(text);
164 if (len > 12) {
165 len = 12;
166 }
167 memcpy(desc + 5, text, len);
168 desc[5 + len] = '\n';
169 }
170
171 static void edid_desc_ranges(uint8_t *desc)
172 {
173 edid_desc_type(desc, 0xfd);
174
175 /* vertical (50 -> 125 Hz) */
176 desc[5] = 50;
177 desc[6] = 125;
178
179 /* horizontal (30 -> 160 kHz) */
180 desc[7] = 30;
181 desc[8] = 160;
182
183 /* max dot clock (1200 MHz) */
184 desc[9] = 1200 / 10;
185
186 /* no extended timing information */
187 desc[10] = 0x01;
188
189 /* padding */
190 desc[11] = '\n';
191 memset(desc + 12, ' ', 6);
192 }
193
194 /* additional standard timings 3 */
195 static void edid_desc_xtra3_std(uint8_t *desc)
196 {
197 edid_desc_type(desc, 0xf7);
198 desc[5] = 10;
199 }
200
201 static void edid_desc_dummy(uint8_t *desc)
202 {
203 edid_desc_type(desc, 0x10);
204 }
205
206 static void edid_desc_timing(uint8_t *desc,
207 uint32_t xres, uint32_t yres,
208 uint32_t xmm, uint32_t ymm)
209 {
210 /* pull some realistic looking timings out of thin air */
211 uint32_t xfront = xres * 25 / 100;
212 uint32_t xsync = xres * 3 / 100;
213 uint32_t xblank = xres * 35 / 100;
214
215 uint32_t yfront = yres * 5 / 1000;
216 uint32_t ysync = yres * 5 / 1000;
217 uint32_t yblank = yres * 35 / 1000;
218
219 uint32_t clock = 75 * (xres + xblank) * (yres + yblank);
220
221 stl_le_p(desc, clock / 10000);
222
223 desc[2] = xres & 0xff;
224 desc[3] = xblank & 0xff;
225 desc[4] = (((xres & 0xf00) >> 4) |
226 ((xblank & 0xf00) >> 8));
227
228 desc[5] = yres & 0xff;
229 desc[6] = yblank & 0xff;
230 desc[7] = (((yres & 0xf00) >> 4) |
231 ((yblank & 0xf00) >> 8));
232
233 desc[8] = xfront & 0xff;
234 desc[9] = xsync & 0xff;
235
236 desc[10] = (((yfront & 0x00f) << 4) |
237 ((ysync & 0x00f) << 0));
238 desc[11] = (((xfront & 0x300) >> 2) |
239 ((xsync & 0x300) >> 4) |
240 ((yfront & 0x030) >> 2) |
241 ((ysync & 0x030) >> 4));
242
243 desc[12] = xmm & 0xff;
244 desc[13] = ymm & 0xff;
245 desc[14] = (((xmm & 0xf00) >> 4) |
246 ((ymm & 0xf00) >> 8));
247
248 desc[17] = 0x18;
249 }
250
251 static uint32_t edid_to_10bit(float value)
252 {
253 return (uint32_t)(value * 1024 + 0.5);
254 }
255
256 static void edid_colorspace(uint8_t *edid,
257 float rx, float ry,
258 float gx, float gy,
259 float bx, float by,
260 float wx, float wy)
261 {
262 uint32_t red_x = edid_to_10bit(rx);
263 uint32_t red_y = edid_to_10bit(ry);
264 uint32_t green_x = edid_to_10bit(gx);
265 uint32_t green_y = edid_to_10bit(gy);
266 uint32_t blue_x = edid_to_10bit(bx);
267 uint32_t blue_y = edid_to_10bit(by);
268 uint32_t white_x = edid_to_10bit(wx);
269 uint32_t white_y = edid_to_10bit(wy);
270
271 edid[25] = (((red_x & 0x03) << 6) |
272 ((red_y & 0x03) << 4) |
273 ((green_x & 0x03) << 2) |
274 ((green_y & 0x03) << 0));
275 edid[26] = (((blue_x & 0x03) << 6) |
276 ((blue_y & 0x03) << 4) |
277 ((white_x & 0x03) << 2) |
278 ((white_y & 0x03) << 0));
279 edid[27] = red_x >> 2;
280 edid[28] = red_y >> 2;
281 edid[29] = green_x >> 2;
282 edid[30] = green_y >> 2;
283 edid[31] = blue_x >> 2;
284 edid[32] = blue_y >> 2;
285 edid[33] = white_x >> 2;
286 edid[34] = white_y >> 2;
287 }
288
289 static uint32_t qemu_edid_dpi_from_mm(uint32_t mm, uint32_t res)
290 {
291 return res * 254 / 10 / mm;
292 }
293
294 uint32_t qemu_edid_dpi_to_mm(uint32_t dpi, uint32_t res)
295 {
296 return res * 254 / 10 / dpi;
297 }
298
299 void qemu_edid_generate(uint8_t *edid, size_t size,
300 qemu_edid_info *info)
301 {
302 uint32_t desc = 54;
303 uint8_t *xtra3 = NULL;
304 uint8_t *dta = NULL;
305 uint32_t width_mm, height_mm;
306 uint32_t dpi = 100; /* if no width_mm/height_mm */
307
308 /* =============== set defaults =============== */
309
310 if (!info->vendor || strlen(info->vendor) != 3) {
311 info->vendor = "RHT";
312 }
313 if (!info->name) {
314 info->name = "QEMU Monitor";
315 }
316 if (!info->prefx) {
317 info->prefx = 1024;
318 }
319 if (!info->prefy) {
320 info->prefy = 768;
321 }
322 if (info->width_mm && info->height_mm) {
323 width_mm = info->width_mm;
324 height_mm = info->height_mm;
325 dpi = qemu_edid_dpi_from_mm(width_mm, info->prefx);
326 } else {
327 width_mm = qemu_edid_dpi_to_mm(dpi, info->prefx);
328 height_mm = qemu_edid_dpi_to_mm(dpi, info->prefy);
329 }
330
331 /* =============== extensions =============== */
332
333 if (size >= 256) {
334 dta = edid + 128;
335 edid[126]++;
336 edid_ext_dta(dta);
337 }
338
339 /* =============== header information =============== */
340
341 /* fixed */
342 edid[0] = 0x00;
343 edid[1] = 0xff;
344 edid[2] = 0xff;
345 edid[3] = 0xff;
346 edid[4] = 0xff;
347 edid[5] = 0xff;
348 edid[6] = 0xff;
349 edid[7] = 0x00;
350
351 /* manufacturer id, product code, serial number */
352 uint16_t vendor_id = ((((info->vendor[0] - '@') & 0x1f) << 10) |
353 (((info->vendor[1] - '@') & 0x1f) << 5) |
354 (((info->vendor[2] - '@') & 0x1f) << 0));
355 uint16_t model_nr = 0x1234;
356 uint32_t serial_nr = info->serial ? atoi(info->serial) : 0;
357 stw_be_p(edid + 8, vendor_id);
358 stw_le_p(edid + 10, model_nr);
359 stl_le_p(edid + 12, serial_nr);
360
361 /* manufacture week and year */
362 edid[16] = 42;
363 edid[17] = 2014 - 1990;
364
365 /* edid version */
366 edid[18] = 1;
367 edid[19] = 4;
368
369
370 /* =============== basic display parameters =============== */
371
372 /* video input: digital, 8bpc, displayport */
373 edid[20] = 0xa5;
374
375 /* screen size: undefined */
376 edid[21] = width_mm / 10;
377 edid[22] = height_mm / 10;
378
379 /* display gamma: 2.2 */
380 edid[23] = 220 - 100;
381
382 /* supported features bitmap: std sRGB, preferred timing */
383 edid[24] = 0x06;
384
385
386 /* =============== chromaticity coordinates =============== */
387
388 /* standard sRGB colorspace */
389 edid_colorspace(edid,
390 0.6400, 0.3300, /* red */
391 0.3000, 0.6000, /* green */
392 0.1500, 0.0600, /* blue */
393 0.3127, 0.3290); /* white point */
394
395 /* =============== established timing bitmap =============== */
396 /* =============== standard timing information =============== */
397
398 /* both filled by edid_fill_modes() */
399
400
401 /* =============== descriptor blocks =============== */
402
403 edid_desc_timing(edid + desc, info->prefx, info->prefy,
404 width_mm, height_mm);
405 desc += 18;
406
407 edid_desc_ranges(edid + desc);
408 desc += 18;
409
410 if (info->name) {
411 edid_desc_text(edid + desc, 0xfc, info->name);
412 desc += 18;
413 }
414
415 if (info->serial) {
416 edid_desc_text(edid + desc, 0xff, info->serial);
417 desc += 18;
418 }
419
420 if (desc < 126) {
421 xtra3 = edid + desc;
422 edid_desc_xtra3_std(xtra3);
423 desc += 18;
424 }
425
426 while (desc < 126) {
427 edid_desc_dummy(edid + desc);
428 desc += 18;
429 }
430
431 /* =============== finish up =============== */
432
433 edid_fill_modes(edid, xtra3, dta, info->maxx, info->maxy);
434 edid_checksum(edid);
435 if (dta) {
436 edid_checksum(dta);
437 }
438 }
439
440 size_t qemu_edid_size(uint8_t *edid)
441 {
442 uint32_t exts;
443
444 if (edid[0] != 0x00 ||
445 edid[1] != 0xff) {
446 /* doesn't look like a valid edid block */
447 return 0;
448 }
449
450 exts = edid[126];
451 return 128 * (exts + 1);
452 }