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