?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
soc/intel/alderlake: Add ADL-P 4+4 with 28W TDP
[coreboot.git] / src / lib / edid.c
blob06b9ceefc1ae4cb689d005e240a03f85f769b8b3
1 /* SPDX-License-Identifier: MIT */
2
3 /* this is a pretty robust parser for EDID, and we're tasked with parsing
4 * an arbitrary panel. We will pass it a raw EDID block and a struct which
5 * it must fill in with values. The set of values we need is pretty limited
6 * at present.
7 */
8
9 #include <assert.h>
10 #include <commonlib/helpers.h>
11 #include <console/console.h>
12 #include <ctype.h>
13 #include <stdint.h>
14 #include <string.h>
15 #include <edid.h>
16 #include <vbe.h>
17
18 struct edid_context {
19 int claims_one_point_oh;
20 int claims_one_point_two;
21 int claims_one_point_three;
22 int claims_one_point_four;
23 int nonconformant_digital_display;
24 int nonconformant_extension;
25 int did_detailed_timing;
26 int has_name_descriptor;
27 int has_range_descriptor;
28 int has_preferred_timing;
29 int has_valid_checksum;
30 int has_valid_cvt;
31 int has_valid_dummy_block;
32 int has_valid_week;
33 int has_valid_year;
34 int has_valid_detailed_blocks;
35 int has_valid_extension_count;
36 int has_valid_descriptor_ordering;
37 int has_valid_descriptor_pad;
38 int has_valid_range_descriptor;
39 int has_valid_max_dotclock;
40 int has_valid_string_termination;
41 int manufacturer_name_well_formed;
42 int seen_non_detailed_descriptor;
43 int warning_excessive_dotclock_correction;
44 int warning_zero_preferred_refresh;
45 enum edid_status conformant;
46 };
47
48 /* Stuff that isn't used anywhere but is nice to pretty-print while
49 we're decoding everything else. */
50 static struct {
51 unsigned int model;
52 unsigned int serial;
53 unsigned int year;
54 unsigned int week;
55 unsigned int version[2];
56 unsigned int nonconformant;
57 unsigned int type;
58
59 unsigned int x_mm;
60 unsigned int y_mm;
61
62 unsigned int voltage;
63 unsigned int sync;
64
65 const char *syncmethod;
66 const char *range_class;
67 const char *stereo;
68 } extra_info;
69
70 static struct edid tmp_edid;
71
72 static int manufacturer_name(unsigned char *x, char *output)
73 {
74 output[0] = ((x[0] & 0x7C) >> 2) + '@';
75 output[1] = ((x[0] & 0x03) << 3) + ((x[1] & 0xE0) >> 5) + '@';
76 output[2] = (x[1] & 0x1F) + '@';
77 output[3] = 0;
78
79 if (isupper(output[0]) &&
80 isupper(output[1]) &&
81 isupper(output[2]))
82 return 1;
83
84 memset(output, 0, 4);
85 return 0;
86 }
87
88 static int
89 detailed_cvt_descriptor(unsigned char *x, int first)
90 {
91 const unsigned char empty[3] = { 0, 0, 0 };
92 static const char *names[] = { "50", "60", "75", "85" };
93 int width = 0, height = 0;
94 int valid = 1;
95 int fifty = 0, sixty = 0, seventyfive = 0, eightyfive = 0, reduced = 0;
96
97 if (!first && !memcmp(x, empty, 3))
98 return valid;
99
100 height = x[0];
101 height |= (x[1] & 0xf0) << 4;
102 height++;
103 height *= 2;
104
105 switch (x[1] & 0x0c) {
106 case 0x00:
107 width = (height * 4) / 3; break;
108 case 0x04:
109 width = (height * 16) / 9; break;
110 case 0x08:
111 width = (height * 16) / 10; break;
112 case 0x0c:
113 width = (height * 15) / 9; break;
114 }
115
116 if (x[1] & 0x03)
117 valid = 0;
118 if (x[2] & 0x80)
119 valid = 0;
120 if (!(x[2] & 0x1f))
121 valid = 0;
122
123 fifty = (x[2] & 0x10);
124 sixty = (x[2] & 0x08);
125 seventyfive = (x[2] & 0x04);
126 eightyfive = (x[2] & 0x02);
127 reduced = (x[2] & 0x01);
128
129 if (!valid) {
130 printk(BIOS_SPEW, " (broken)\n");
131 } else {
132 printk(BIOS_SPEW,
133 " %dx%d @ (%s%s%s%s%s) Hz (%s%s preferred)\n",
134 width, height,
135 fifty ? "50 " : "",
136 sixty ? "60 " : "",
137 seventyfive ? "75 " : "",
138 eightyfive ? "85 " : "",
139 reduced ? "60RB " : "",
140 names[(x[2] & 0x60) >> 5],
141 (((x[2] & 0x60) == 0x20) && reduced) ? "RB" : "");
142 }
143
144 return valid;
145 }
146
147 /* extract a CP437 string from a detailed subblock, checking for termination (if
148 * less than len of bytes) with LF and padded with SP.
149 */
150 static char *
151 extract_string(unsigned char *x, int *valid_termination, int len)
152 {
153 static char ret[EDID_ASCII_STRING_LENGTH + 1];
154 int i, seen_newline = 0;
155
156 memset(ret, 0, sizeof(ret));
157
158 for (i = 0; i < MIN(len, EDID_ASCII_STRING_LENGTH); i++) {
159 if (seen_newline) {
160 if (x[i] != 0x20) {
161 *valid_termination = 0;
162 return ret;
163 }
164 } else if (x[i] == 0x0a) {
165 seen_newline = 1;
166 } else {
167 /* normal characters */
168 ret[i] = x[i];
169 }
170 }
171
172 return ret;
173 }
174
175 /* 1 means valid data */
176 static int
177 detailed_block(struct edid *result_edid, unsigned char *x, int in_extension,
178 struct edid_context *c)
179 {
180 struct edid *out = &tmp_edid;
181 int i;
182
183 if (console_log_level(BIOS_SPEW)) {
184 printk(BIOS_SPEW, "Hex of detail: ");
185 for (i = 0; i < 18; i++)
186 printk(BIOS_SPEW, "%02x", x[i]);
187 printk(BIOS_SPEW, "\n");
188 }
189
190 /* Result might already have some valid fields like mode_is_supported */
191 *out = *result_edid;
192
193 if (x[0] == 0 && x[1] == 0) {
194 /* Monitor descriptor block, not detailed timing descriptor. */
195 if (x[2] != 0) {
196 /* 1.3, 3.10.3 */
197 printk(BIOS_SPEW,
198 "Monitor descriptor block has byte 2 nonzero (0x%02x)\n",
199 x[2]);
200 c->has_valid_descriptor_pad = 0;
201 }
202 if (x[3] != 0xfd && x[4] != 0x00) {
203 /* 1.3, 3.10.3 */
204 printk(BIOS_SPEW,
205 "Monitor descriptor block has byte 4 nonzero (0x%02x)\n",
206 x[4]);
207 c->has_valid_descriptor_pad = 0;
208 }
209
210 c->seen_non_detailed_descriptor = 1;
211 if (x[3] <= 0xF) {
212 /*
213 * in principle we can decode these, if we know what
214 * they are.
215 * 0x0f seems to be common in laptop panels.
216 * 0x0e is used by EPI: http://www.epi-standard.org/
217 */
218 printk(BIOS_SPEW,
219 "Manufacturer-specified data, tag %d\n", x[3]);
220 return 1;
221 }
222 switch (x[3]) {
223 case 0x10:
224 printk(BIOS_SPEW, "Dummy block\n");
225 for (i = 5; i < 18; i++)
226 if (x[i] != 0x00)
227 c->has_valid_dummy_block = 0;
228 return 1;
229 case 0xF7:
230 /* TODO */
231 printk(BIOS_SPEW, "Established timings III\n");
232 return 1;
233 case 0xF8:
234 {
235 int valid_cvt = 1; /* just this block */
236 printk(BIOS_SPEW, "CVT 3-byte code descriptor:\n");
237 if (x[5] != 0x01) {
238 c->has_valid_cvt = 0;
239 return 0;
240 }
241 for (i = 0; i < 4; i++)
242 valid_cvt &= detailed_cvt_descriptor(x + 6
243 + (i * 3), (i == 0));
244 c->has_valid_cvt &= valid_cvt;
245 return 1;
246 }
247 case 0xF9:
248 /* TODO */
249 printk(BIOS_SPEW, "Color management data\n");
250 return 1;
251 case 0xFA:
252 /* TODO */
253 printk(BIOS_SPEW, "More standard timings\n");
254 return 1;
255 case 0xFB:
256 /* TODO */
257 printk(BIOS_SPEW, "Color point\n");
258 return 1;
259 case 0xFC:
260 printk(BIOS_SPEW, "Monitor name: %s\n",
261 extract_string(x + 5,
262 &c->has_valid_string_termination,
263 EDID_ASCII_STRING_LENGTH));
264 c->has_name_descriptor = 1;
265 return 1;
266 case 0xFD:
267 {
268 int h_max_offset = 0, h_min_offset = 0;
269 int v_max_offset = 0, v_min_offset = 0;
270 int is_cvt = 0;
271 c->has_range_descriptor = 1;
272 extra_info.range_class = "";
273 /*
274 * XXX todo: implement feature flags, vtd blocks
275 * XXX check: ranges are well-formed; block termination
276 * if no vtd
277 */
278 if (c->claims_one_point_four) {
279 if (x[4] & 0x02) {
280 v_max_offset = 255;
281 if (x[4] & 0x01)
282 v_min_offset = 255;
283 }
284 if (x[4] & 0x04) {
285 h_max_offset = 255;
286 if (x[4] & 0x03)
287 h_min_offset = 255;
288 }
289 } else if (x[4]) {
290 c->has_valid_range_descriptor = 0;
291 }
292
293 /*
294 * despite the values, this is not a bitfield.
295 */
296 switch (x[10]) {
297 case 0x00: /* default gtf */
298 extra_info.range_class = "GTF";
299 break;
300 case 0x01: /* range limits only */
301 extra_info.range_class = "bare limits";
302 if (!c->claims_one_point_four)
303 c->has_valid_range_descriptor = 0;
304 break;
305 case 0x02: /* secondary gtf curve */
306 extra_info.range_class = "GTF with icing";
307 break;
308 case 0x04: /* cvt */
309 extra_info.range_class = "CVT";
310 is_cvt = 1;
311 if (!c->claims_one_point_four)
312 c->has_valid_range_descriptor = 0;
313 break;
314 default: /* invalid */
315 c->has_valid_range_descriptor = 0;
316 extra_info.range_class = "invalid";
317 break;
318 }
319
320 if (x[5] + v_min_offset > x[6] + v_max_offset)
321 c->has_valid_range_descriptor = 0;
322 if (x[7] + h_min_offset > x[8] + h_max_offset)
323 c->has_valid_range_descriptor = 0;
324 printk(BIOS_SPEW,
325 "Monitor ranges (%s): %d-%dHz V, %d-%dkHz H",
326 extra_info.range_class,
327 x[5] + v_min_offset, x[6] + v_max_offset,
328 x[7] + h_min_offset, x[8] + h_max_offset);
329 if (x[9])
330 printk(BIOS_SPEW,
331 ", max dotclock %dMHz\n", x[9] * 10);
332 else {
333 if (c->claims_one_point_four)
334 c->has_valid_max_dotclock = 0;
335 printk(BIOS_SPEW, "\n");
336 }
337
338 if (is_cvt) {
339 int max_h_pixels = 0;
340
341 printk(BIOS_SPEW, "CVT version %d.%d\n",
342 x[11] & 0xf0 >> 4, x[11] & 0x0f);
343
344 if (x[12] & 0xfc) {
345 int raw_offset = (x[12] & 0xfc) >> 2;
346 printk(BIOS_SPEW,
347 "Real max dotclock: %dKHz\n",
348 (x[9] * 10000)
349 - (raw_offset * 250));
350 if (raw_offset >= 40)
351 c->warning_excessive_dotclock_correction = 1;
352 }
353
354 max_h_pixels = x[12] & 0x03;
355 max_h_pixels <<= 8;
356 max_h_pixels |= x[13];
357 max_h_pixels *= 8;
358 if (max_h_pixels)
359 printk(BIOS_SPEW,
360 "Max active pixels per line: %d\n",
361 max_h_pixels);
362
363 printk(BIOS_SPEW,
364 "Supported aspect ratios: %s %s %s %s %s\n",
365 x[14] & 0x80 ? "4:3" : "",
366 x[14] & 0x40 ? "16:9" : "",
367 x[14] & 0x20 ? "16:10" : "",
368 x[14] & 0x10 ? "5:4" : "",
369 x[14] & 0x08 ? "15:9" : "");
370 if (x[14] & 0x07)
371 c->has_valid_range_descriptor = 0;
372
373 printk(BIOS_SPEW, "Preferred aspect ratio: ");
374 switch ((x[15] & 0xe0) >> 5) {
375 case 0x00:
376 printk(BIOS_SPEW, "4:3");
377 break;
378 case 0x01:
379 printk(BIOS_SPEW, "16:9");
380 break;
381 case 0x02:
382 printk(BIOS_SPEW, "16:10");
383 break;
384 case 0x03:
385 printk(BIOS_SPEW, "5:4");
386 break;
387 case 0x04:
388 printk(BIOS_SPEW, "15:9");
389 break;
390 default:
391 printk(BIOS_SPEW, "(broken)");
392 break;
393 }
394 printk(BIOS_SPEW, "\n");
395
396 if (x[15] & 0x04)
397 printk(BIOS_SPEW,
398 "Supports CVT standard blanking\n");
399 if (x[15] & 0x10)
400 printk(BIOS_SPEW,
401 "Supports CVT reduced blanking\n");
402
403 if (x[15] & 0x07)
404 c->has_valid_range_descriptor = 0;
405
406 if (x[16] & 0xf0) {
407 printk(BIOS_SPEW,
408 "Supported display scaling:\n");
409 if (x[16] & 0x80)
410 printk(BIOS_SPEW,
411 " Horizontal shrink\n");
412 if (x[16] & 0x40)
413 printk(BIOS_SPEW,
414 " Horizontal stretch\n");
415 if (x[16] & 0x20)
416 printk(BIOS_SPEW,
417 " Vertical shrink\n");
418 if (x[16] & 0x10)
419 printk(BIOS_SPEW,
420 " Vertical stretch\n");
421 }
422
423 if (x[16] & 0x0f)
424 c->has_valid_range_descriptor = 0;
425
426 if (x[17])
427 printk(BIOS_SPEW,
428 "Preferred vertical refresh: %d Hz\n",
429 x[17]);
430 else
431 c->warning_zero_preferred_refresh = 1;
432 }
433
434 /*
435 * Slightly weird to return a global, but I've never
436 * seen any EDID block with two range descriptors, so
437 * it's harmless.
438 */
439 return 1;
440 }
441 case 0xFE:
442 /*
443 * TODO: Two of these in a row, in the third and fourth
444 * slots, seems to be specified by SPWG:
445 * http://www.spwg.org/
446 */
447 strcpy(result_edid->ascii_string, extract_string(x + 5,
448 &c->has_valid_string_termination,
449 EDID_ASCII_STRING_LENGTH));
450 printk(BIOS_SPEW, "ASCII string: %s\n",
451 result_edid->ascii_string);
452 return 1;
453 case 0xFF:
454 printk(BIOS_SPEW, "Serial number: %s\n",
455 extract_string(x + 5,
456 &c->has_valid_string_termination,
457 EDID_ASCII_STRING_LENGTH));
458 return 1;
459 default:
460 printk(BIOS_SPEW,
461 "Unknown monitor description type %d\n",
462 x[3]);
463 return 0;
464 }
465 }
466
467 if (c->seen_non_detailed_descriptor && !in_extension)
468 c->has_valid_descriptor_ordering = 0;
469
470 /* Edid contains pixel clock in terms of 10KHz */
471 out->mode.pixel_clock = (x[0] + (x[1] << 8)) * 10;
472 /*
473 LVDS supports following pixel clocks
474 25000...112000 kHz: single channel
475 80000...224000 kHz: dual channel
476 There is some overlap in theoretically supported
477 pixel clock between single-channel and dual-channel.
478 In practice with current panels all panels
479 <= 75200 kHz: single channel
480 >= 97750 kHz: dual channel
481 We have no samples between those values, so put a
482 threshold at 95000 kHz. If we get anything over
483 95000 kHz with single channel, we can make this
484 more sophisticated but it's currently not needed.
485 */
486 out->mode.lvds_dual_channel = (out->mode.pixel_clock >= 95000);
487 extra_info.x_mm = (x[12] + ((x[14] & 0xF0) << 4));
488 extra_info.y_mm = (x[13] + ((x[14] & 0x0F) << 8));
489 out->mode.ha = (x[2] + ((x[4] & 0xF0) << 4));
490 out->mode.hbl = (x[3] + ((x[4] & 0x0F) << 8));
491 out->mode.hso = (x[8] + ((x[11] & 0xC0) << 2));
492 out->mode.hspw = (x[9] + ((x[11] & 0x30) << 4));
493 out->mode.hborder = x[15];
494 out->mode.va = (x[5] + ((x[7] & 0xF0) << 4));
495 out->mode.vbl = (x[6] + ((x[7] & 0x0F) << 8));
496 out->mode.vso = ((x[10] >> 4) + ((x[11] & 0x0C) << 2));
497 out->mode.vspw = ((x[10] & 0x0F) + ((x[11] & 0x03) << 4));
498 out->mode.vborder = x[16];
499
500 /* We assume rgb888 (32 bits per pixel) framebuffers by default.
501 * Chipsets that want something else will need to override this with
502 * another call to edid_set_framebuffer_bits_per_pixel(). As a cheap
503 * heuristic, assume that X86 systems require a 64-byte row alignment
504 * (since that seems to be true for most Intel chipsets). */
505 if (ENV_X86)
506 edid_set_framebuffer_bits_per_pixel(out, 32, 64);
507 else
508 edid_set_framebuffer_bits_per_pixel(out, 32, 0);
509
510 switch ((x[17] & 0x18) >> 3) {
511 case 0x00:
512 extra_info.syncmethod = " analog composite";
513 break;
514 case 0x01:
515 extra_info.syncmethod = " bipolar analog composite";
516 break;
517 case 0x02:
518 extra_info.syncmethod = " digital composite";
519 break;
520 case 0x03:
521 extra_info.syncmethod = "";
522 break;
523 }
524 out->mode.pvsync = (x[17] & (1 << 2)) ? '+' : '-';
525 out->mode.phsync = (x[17] & (1 << 1)) ? '+' : '-';
526 switch (x[17] & 0x61) {
527 case 0x20:
528 extra_info.stereo = "field sequential L/R";
529 break;
530 case 0x40:
531 extra_info.stereo = "field sequential R/L";
532 break;
533 case 0x21:
534 extra_info.stereo = "interleaved right even";
535 break;
536 case 0x41:
537 extra_info.stereo = "interleaved left even";
538 break;
539 case 0x60:
540 extra_info.stereo = "four way interleaved";
541 break;
542 case 0x61:
543 extra_info.stereo = "side by side interleaved";
544 break;
545 default:
546 extra_info.stereo = "";
547 break;
548 }
549
550 printk(BIOS_SPEW,
551 "Detailed mode (IN HEX): Clock %d KHz, %x mm x %x mm\n"
552 " %04x %04x %04x %04x hborder %x\n"
553 " %04x %04x %04x %04x vborder %x\n"
554 " %chsync %cvsync%s%s%s\n",
555 out->mode.pixel_clock,
556 extra_info.x_mm,
557 extra_info.y_mm,
558 out->mode.ha, out->mode.ha + out->mode.hso,
559 out->mode.ha + out->mode.hso + out->mode.hspw,
560 out->mode.ha + out->mode.hbl, out->mode.hborder,
561 out->mode.va, out->mode.va + out->mode.vso,
562 out->mode.va + out->mode.vso + out->mode.vspw,
563 out->mode.va + out->mode.vbl, out->mode.vborder,
564 out->mode.phsync, out->mode.pvsync,
565 extra_info.syncmethod, x[17] & 0x80 ? " interlaced" : "",
566 extra_info.stereo);
567
568 if (!c->did_detailed_timing) {
569 printk(BIOS_SPEW, "Did detailed timing\n");
570 c->did_detailed_timing = 1;
571 *result_edid = *out;
572 }
573
574 return 1;
575 }
576
577 static int
578 do_checksum(unsigned char *x)
579 {
580 int valid = 0;
581 printk(BIOS_SPEW, "Checksum: 0x%hhx", x[0x7f]);
582 {
583 unsigned char sum = 0;
584 int i;
585 for (i = 0; i < 128; i++)
586 sum += x[i];
587 if (sum) {
588 printk(BIOS_SPEW, " (should be 0x%hhx)",
589 (unsigned char)(x[0x7f] - sum));
590 } else {
591 valid = 1;
592 printk(BIOS_SPEW, " (valid)");
593 }
594 }
595 printk(BIOS_SPEW, "\n");
596 return valid;
597 }
598
599 /* CEA extension */
600
601 static const char *
602 audio_format(unsigned char x)
603 {
604 switch (x) {
605 case 0: return "RESERVED";
606 case 1: return "Linear PCM";
607 case 2: return "AC-3";
608 case 3: return "MPEG 1 (Layers 1 & 2)";
609 case 4: return "MPEG 1 Layer 3 (MP3)";
610 case 5: return "MPEG2 (multichannel)";
611 case 6: return "AAC";
612 case 7: return "DTS";
613 case 8: return "ATRAC";
614 case 9: return "One Bit Audio";
615 case 10: return "Dolby Digital+";
616 case 11: return "DTS-HD";
617 case 12: return "MAT (MLP)";
618 case 13: return "DST";
619 case 14: return "WMA Pro";
620 case 15: return "RESERVED";
621 }
622 return "BROKEN"; /* can't happen */
623 }
624
625 static void
626 cea_audio_block(unsigned char *x)
627 {
628 int i, format;
629 int length = x[0] & 0x1f;
630
631 if (length % 3) {
632 printk(BIOS_SPEW, "Broken CEA audio block length %d\n", length);
633 /* XXX non-conformant */
634 return;
635 }
636
637 for (i = 1; i < length; i += 3) {
638 format = (x[i] & 0x78) >> 3;
639 printk(BIOS_SPEW, " %s, max channels %d\n",
640 audio_format(format), x[i] & 0x07);
641 printk(BIOS_SPEW,
642 " Supported sample rates (kHz):%s%s%s%s%s%s%s\n",
643 (x[i+1] & 0x40) ? " 192" : "",
644 (x[i+1] & 0x20) ? " 176.4" : "",
645 (x[i+1] & 0x10) ? " 96" : "",
646 (x[i+1] & 0x08) ? " 88.2" : "",
647 (x[i+1] & 0x04) ? " 48" : "",
648 (x[i+1] & 0x02) ? " 44.1" : "",
649 (x[i+1] & 0x01) ? " 32" : "");
650 if (format == 1) {
651 printk(BIOS_SPEW,
652 " Supported sample sizes (bits):%s%s%s\n",
653 (x[2] & 0x04) ? " 24" : "",
654 (x[2] & 0x02) ? " 20" : "",
655 (x[2] & 0x01) ? " 16" : "");
656 } else if (format <= 8) {
657 printk(BIOS_SPEW,
658 " Maximum bit rate: %d kHz\n", x[2] * 8);
659 }
660 }
661 }
662
663 static void
664 cea_video_block(unsigned char *x)
665 {
666 int i;
667 int length = x[0] & 0x1f;
668
669 for (i = 1; i < length; i++)
670 printk(BIOS_SPEW, " VIC %02d %s\n", x[i] & 0x7f,
671 x[i] & 0x80 ? "(native)" : "");
672 }
673
674 static void
675 cea_hdmi_block(struct edid *out, unsigned char *x)
676 {
677 int length = x[0] & 0x1f;
678
679 out->hdmi_monitor_detected = 1;
680
681 printk(BIOS_SPEW, " (HDMI)\n");
682 printk(BIOS_SPEW,
683 " Source physical address %d.%d.%d.%d\n",
684 x[4] >> 4, x[4] & 0x0f, x[5] >> 4, x[5] & 0x0f);
685
686 if (length > 5) {
687 if (x[6] & 0x80)
688 printk(BIOS_SPEW, " Supports_AI\n");
689 if (x[6] & 0x40)
690 printk(BIOS_SPEW, " DC_48bit\n");
691 if (x[6] & 0x20)
692 printk(BIOS_SPEW, " DC_36bit\n");
693 if (x[6] & 0x10)
694 printk(BIOS_SPEW, " DC_30bit\n");
695 if (x[6] & 0x08)
696 printk(BIOS_SPEW, " DC_Y444\n");
697 /* two reserved */
698 if (x[6] & 0x01)
699 printk(BIOS_SPEW, " DVI_Dual\n");
700 }
701
702 if (length > 6)
703 printk(BIOS_SPEW, " Maximum TMDS clock: %dMHz\n", x[7] * 5);
704
705 /* XXX the walk here is really ugly, and needs to be length-checked */
706 if (length > 7) {
707 int b = 0;
708
709 if (x[8] & 0x80) {
710 printk(BIOS_SPEW, " Video latency: %d\n", x[9 + b]);
711 printk(BIOS_SPEW, " Audio latency: %d\n", x[10 + b]);
712 b += 2;
713 }
714
715 if (x[8] & 0x40) {
716 printk(BIOS_SPEW,
717 " Interlaced video latency: %d\n", x[9 + b]);
718 printk(BIOS_SPEW,
719 " Interlaced audio latency: %d\n",
720 x[10 + b]);
721 b += 2;
722 }
723
724 if (x[8] & 0x20) {
725 int mask = 0, formats = 0;
726 int len_xx, len_3d;
727 printk(BIOS_SPEW, " Extended HDMI video details:\n");
728 if (x[9 + b] & 0x80)
729 printk(BIOS_SPEW, " 3D present\n");
730 if ((x[9 + b] & 0x60) == 0x20) {
731 printk(BIOS_SPEW,
732 " All advertised VICs are 3D-capable\n");
733 formats = 1;
734 }
735 if ((x[9 + b] & 0x60) == 0x40) {
736 printk(BIOS_SPEW,
737 " 3D-capable-VIC mask present\n");
738 formats = 1;
739 mask = 1;
740 }
741 switch (x[9 + b] & 0x18) {
742 case 0x00:
743 break;
744 case 0x08:
745 printk(BIOS_SPEW, " Base EDID image size is aspect ratio\n");
746 break;
747 case 0x10:
748 printk(BIOS_SPEW, " Base EDID image size is in units of 1cm\n");
749 break;
750 case 0x18:
751 printk(BIOS_SPEW, " Base EDID image size is in units of 5cm\n");
752 break;
753 }
754 len_xx = (x[10 + b] & 0xe0) >> 5;
755 len_3d = (x[10 + b] & 0x1f) >> 0;
756 b += 2;
757
758 if (len_xx) {
759 printk(BIOS_SPEW, " Skipping %d bytes that HDMI refuses to publicly"
760 " document\n", len_xx);
761 b += len_xx;
762 }
763
764 if (len_3d) {
765 if (formats) {
766 if (x[9 + b] & 0x01)
767 printk(BIOS_SPEW, " Side-by-side 3D supported\n");
768 if (x[10 + b] & 0x40)
769 printk(BIOS_SPEW, " Top-and-bottom 3D supported\n");
770 if (x[10 + b] & 0x01)
771 printk(BIOS_SPEW, " Frame-packing 3D supported\n");
772 b += 2;
773 }
774 if (mask) {
775 int i;
776 printk(BIOS_SPEW,
777 " 3D VIC indices:");
778 /* worst bit ordering ever */
779 for (i = 0; i < 8; i++)
780 if (x[10 + b] & (1 << i))
781 printk(BIOS_SPEW,
782 " %d", i);
783 for (i = 0; i < 8; i++)
784 if (x[9 + b] & (1 << i))
785 printk(BIOS_SPEW,
786 " %d", i + 8);
787 printk(BIOS_SPEW, "\n");
788 b += 2;
789 }
790
791 /*
792 * XXX list of nibbles:
793 * 2D_VIC_Order_X
794 * 3D_Structure_X
795 * (optionally: 3D_Detail_X and reserved)
796 */
797 }
798 }
799 /* Tell static analysis we know index b is left unused. */
800 (void)b;
801 }
802 }
803
804 static void
805 cea_block(struct edid *out, unsigned char *x)
806 {
807 unsigned int oui;
808
809 switch ((x[0] & 0xe0) >> 5) {
810 case 0x01:
811 printk(BIOS_SPEW, " Audio data block\n");
812 cea_audio_block(x);
813 break;
814 case 0x02:
815 printk(BIOS_SPEW, " Video data block\n");
816 cea_video_block(x);
817 break;
818 case 0x03:
819 /* yes really, endianness lols */
820 oui = (x[3] << 16) + (x[2] << 8) + x[1];
821 printk(BIOS_SPEW, " Vendor-specific data block, OUI %06x",
822 oui);
823 if (oui == 0x000c03)
824 cea_hdmi_block(out, x);
825 else
826 printk(BIOS_SPEW, "\n");
827 break;
828 case 0x04:
829 printk(BIOS_SPEW, " Speaker allocation data block\n");
830 break;
831 case 0x05:
832 printk(BIOS_SPEW, " VESA DTC data block\n");
833 break;
834 case 0x07:
835 printk(BIOS_SPEW, " Extended tag: ");
836 switch (x[1]) {
837 case 0x00:
838 printk(BIOS_SPEW, "video capability data block\n");
839 break;
840 case 0x01:
841 printk(BIOS_SPEW, "vendor-specific video data block\n");
842 break;
843 case 0x02:
844 printk(BIOS_SPEW,
845 "VESA video display device information data block\n");
846 break;
847 case 0x03:
848 printk(BIOS_SPEW, "VESA video data block\n");
849 break;
850 case 0x04:
851 printk(BIOS_SPEW, "HDMI video data block\n");
852 break;
853 case 0x05:
854 printk(BIOS_SPEW, "Colorimetry data block\n");
855 break;
856 case 0x10:
857 printk(BIOS_SPEW, "CEA miscellaneous audio fields\n");
858 break;
859 case 0x11:
860 printk(BIOS_SPEW, "Vendor-specific audio data block\n");
861 break;
862 case 0x12:
863 printk(BIOS_SPEW, "HDMI audio data block\n");
864 break;
865 default:
866 if (x[1] >= 6 && x[1] <= 15)
867 printk(BIOS_SPEW,
868 "Reserved video block (%02x)\n", x[1]);
869 else if (x[1] >= 19 && x[1] <= 31)
870 printk(BIOS_SPEW,
871 "Reserved audio block (%02x)\n", x[1]);
872 else
873 printk(BIOS_SPEW, "Unknown (%02x)\n", x[1]);
874 break;
875 }
876 break;
877 default:
878 {
879 int tag = (*x & 0xe0) >> 5;
880 int length = *x & 0x1f;
881 printk(BIOS_SPEW,
882 " Unknown tag %d, length %d (raw %02x)\n",
883 tag, length, *x);
884 break;
885 }
886 }
887 }
888
889 static int
890 parse_cea(struct edid *out, unsigned char *x, struct edid_context *c)
891 {
892 int ret = 0;
893 int version = x[1];
894 int offset = x[2];
895 unsigned char *detailed;
896
897 if (version >= 1)
898 do {
899 if (version == 1 && x[3] != 0)
900 ret = 1;
901
902 if (offset < 4)
903 break;
904
905 if (version < 3)
906 printk(BIOS_SPEW,
907 "%d 8-byte timing descriptors\n",
908 (offset - 4) / 8);
909 else if (version == 3) {
910 int i;
911 printk(BIOS_SPEW,
912 "%d bytes of CEA data\n", offset - 4);
913 for (i = 4; i < offset; i += (x[i] & 0x1f) + 1)
914 cea_block(out, x + i);
915 }
916
917 if (version >= 2) {
918 if (x[3] & 0x80)
919 printk(BIOS_SPEW,
920 "Underscans PC formats by default\n");
921 if (x[3] & 0x40)
922 printk(BIOS_SPEW,
923 "Basic audio support\n");
924 if (x[3] & 0x20)
925 printk(BIOS_SPEW,
926 "Supports YCbCr 4:4:4\n");
927 if (x[3] & 0x10)
928 printk(BIOS_SPEW,
929 "Supports YCbCr 4:2:2\n");
930 printk(BIOS_SPEW,
931 "%d native detailed modes\n",
932 x[3] & 0x0f);
933 }
934
935 for (detailed = x + offset; detailed + 18 < x + 127;
936 detailed += 18)
937 if (detailed[0])
938 detailed_block(out, detailed, 1, c);
939 } while (0);
940
941 c->has_valid_checksum &= do_checksum(x);
942 return ret;
943 }
944
945 /* generic extension code */
946
947 static void
948 extension_version(struct edid *out, unsigned char *x)
949 {
950 printk(BIOS_SPEW, "Extension version: %d\n", x[1]);
951 }
952
953 static int
954 parse_extension(struct edid *out, unsigned char *x, struct edid_context *c)
955 {
956 int conformant_extension = 0;
957 printk(BIOS_SPEW, "\n");
958
959 switch (x[0]) {
960 case 0x02:
961 printk(BIOS_SPEW, "CEA extension block\n");
962 extension_version(out, x);
963 conformant_extension = parse_cea(out, x, c);
964 break;
965 case 0x10:
966 printk(BIOS_SPEW, "VTB extension block\n");
967 break;
968 case 0x40:
969 printk(BIOS_SPEW, "DI extension block\n");
970 break;
971 case 0x50:
972 printk(BIOS_SPEW, "LS extension block\n");
973 break;
974 case 0x60:
975 printk(BIOS_SPEW, "DPVL extension block\n");
976 break;
977 case 0xF0:
978 printk(BIOS_SPEW, "Block map\n");
979 break;
980 case 0xFF:
981 printk(BIOS_SPEW, "Manufacturer-specific extension block\n");
982 break;
983 default:
984 printk(BIOS_SPEW, "Unknown extension block\n");
985 break;
986 }
987
988 printk(BIOS_SPEW, "\n");
989
990 return conformant_extension;
991 }
992
993 static const struct {
994 int x, y, refresh;
995 } established_timings[] = {
996 /* 0x23 bit 7 - 0 */
997 {720, 400, 70},
998 {720, 400, 88},
999 {640, 480, 60},
1000 {640, 480, 67},
1001 {640, 480, 72},
1002 {640, 480, 75},
1003 {800, 600, 56},
1004 {800, 600, 60},
1005 /* 0x24 bit 7 - 0 */
1006 {800, 600, 72},
1007 {800, 600, 75},
1008 {832, 624, 75},
1009 {1280, 768, 87},
1010 {1024, 768, 60},
1011 {1024, 768, 70},
1012 {1024, 768, 75},
1013 {1280, 1024, 75},
1014 /* 0x25 bit 7*/
1015 {1152, 870, 75},
1016 };
1017
1018 static void print_subsection(const char *name, unsigned char *edid, int start,
1019 int end)
1020 {
1021 int i;
1022
1023 printk(BIOS_SPEW, "%s:", name);
1024 for (i = strlen(name); i < 15; i++)
1025 printk(BIOS_SPEW, " ");
1026 for (i = start; i <= end; i++)
1027 printk(BIOS_SPEW, " %02x", edid[i]);
1028 printk(BIOS_SPEW, "\n");
1029 }
1030
1031 static void dump_breakdown(unsigned char *edid)
1032 {
1033 printk(BIOS_SPEW, "Extracted contents:\n");
1034 print_subsection("header", edid, 0, 7);
1035 print_subsection("serial number", edid, 8, 17);
1036 print_subsection("version", edid, 18, 19);
1037 print_subsection("basic params", edid, 20, 24);
1038 print_subsection("chroma info", edid, 25, 34);
1039 print_subsection("established", edid, 35, 37);
1040 print_subsection("standard", edid, 38, 53);
1041 print_subsection("descriptor 1", edid, 54, 71);
1042 print_subsection("descriptor 2", edid, 72, 89);
1043 print_subsection("descriptor 3", edid, 90, 107);
1044 print_subsection("descriptor 4", edid, 108, 125);
1045 print_subsection("extensions", edid, 126, 126);
1046 print_subsection("checksum", edid, 127, 127);
1047 printk(BIOS_SPEW, "\n");
1048 }
1049
1050 /*
1051 * Lookup table of some well-known modes that can be useful in case the
1052 * auto-detected mode is unsuitable.
1053 * ha = hdisplay; va = vdisplay;
1054 * hbl = htotal - hdisplay; vbl = vtotal - vdisplay;
1055 * hso = hsync_start - hdsiplay; vso = vsync_start - vdisplay;
1056 * hspw = hsync_end - hsync_start; vspw = vsync_end - vsync_start;
1057 */
1058 static struct edid_mode known_modes[NUM_KNOWN_MODES] = {
1059 [EDID_MODE_640x480_60Hz] = {
1060 .name = "640x480@60Hz", .pixel_clock = 25200, .refresh = 60,
1061 .ha = 640, .hbl = 160, .hso = 16, .hspw = 96,
1062 .va = 480, .vbl = 45, .vso = 10, .vspw = 2,
1063 .phsync = '-', .pvsync = '-' },
1064 [EDID_MODE_720x480_60Hz] = {
1065 .name = "720x480@60Hz", .pixel_clock = 27000, .refresh = 60,
1066 .ha = 720, .hbl = 138, .hso = 16, .hspw = 62,
1067 .va = 480, .vbl = 45, .vso = 9, .vspw = 6,
1068 .phsync = '-', .pvsync = '-' },
1069 [EDID_MODE_1280x720_60Hz] = {
1070 .name = "1280x720@60Hz", .pixel_clock = 74250, .refresh = 60,
1071 .ha = 1280, .hbl = 370, .hso = 110, .hspw = 40,
1072 .va = 720, .vbl = 30, .vso = 5, .vspw = 20,
1073 .phsync = '+', .pvsync = '+' },
1074 [EDID_MODE_1920x1080_60Hz] = {
1075 .name = "1920x1080@60Hz", .pixel_clock = 148500, .refresh = 60,
1076 .ha = 1920, .hbl = 280, .hso = 88, .hspw = 44,
1077 .va = 1080, .vbl = 45, .vso = 4, .vspw = 5,
1078 .phsync = '+', .pvsync = '+' },
1079 };
1080
1081 int set_display_mode(struct edid *edid, enum edid_modes mode)
1082 {
1083 if (mode == EDID_MODE_AUTO)
1084 return 0;
1085
1086 if (edid->mode_is_supported[mode]) {
1087 printk(BIOS_DEBUG, "Forcing mode %s\n", known_modes[mode].name);
1088 edid->mode = known_modes[mode];
1089 return 0;
1090 }
1091
1092 printk(BIOS_ERR, "Requested display mode not supported.\n");
1093 return -1;
1094 }
1095
1096 /*
1097 * Given a raw edid block, decode it into a form
1098 * that other parts of coreboot can use -- mainly
1099 * graphics bringup functions. The raw block is
1100 * required to be 128 bytes long, per the standard,
1101 * but we have no way of checking this minimum length.
1102 * We accept what we are given.
1103 */
1104 int decode_edid(unsigned char *edid, int size, struct edid *out)
1105 {
1106 int analog, i, j;
1107 struct edid_context c = {
1108 .has_valid_cvt = 1,
1109 .has_valid_dummy_block = 1,
1110 .has_valid_descriptor_ordering = 1,
1111 .has_valid_detailed_blocks = 1,
1112 .has_valid_descriptor_pad = 1,
1113 .has_valid_range_descriptor = 1,
1114 .has_valid_max_dotclock = 1,
1115 .has_valid_string_termination = 1,
1116 .conformant = EDID_CONFORMANT,
1117 };
1118
1119 if (!edid) {
1120 printk(BIOS_ERR, "No EDID found\n");
1121 return EDID_ABSENT;
1122 }
1123
1124 dump_breakdown(edid);
1125
1126 if (memcmp(edid, "\x00\xFF\xFF\xFF\xFF\xFF\xFF\x00", 8)) {
1127 printk(BIOS_ERR, "No header found\n");
1128 return EDID_ABSENT;
1129 }
1130
1131 memset(out, 0, sizeof(*out));
1132
1133 if (manufacturer_name(edid + 0x08, out->manufacturer_name))
1134 c.manufacturer_name_well_formed = 1;
1135
1136 extra_info.model = (unsigned short)(edid[0x0A] + (edid[0x0B] << 8));
1137 extra_info.serial = (unsigned int)(edid[0x0C] + (edid[0x0D] << 8)
1138 + (edid[0x0E] << 16) + (edid[0x0F] << 24));
1139
1140 printk(BIOS_SPEW, "Manufacturer: %s Model %x Serial Number %u\n",
1141 out->manufacturer_name,
1142 (unsigned short)(edid[0x0A] + (edid[0x0B] << 8)),
1143 (unsigned int)(edid[0x0C] + (edid[0x0D] << 8)
1144 + (edid[0x0E] << 16) + (edid[0x0F] << 24)));
1145 /* XXX need manufacturer ID table */
1146
1147 if (edid[0x10] < 55 || edid[0x10] == 0xff) {
1148 c.has_valid_week = 1;
1149 if (edid[0x11] > 0x0f) {
1150 if (edid[0x10] == 0xff) {
1151 c.has_valid_year = 1;
1152 printk(BIOS_SPEW,
1153 "Made week %hhd of model year %hhd\n",
1154 edid[0x10], edid[0x11]);
1155 extra_info.week = edid[0x10];
1156 extra_info.year = edid[0x11];
1157 } else {
1158 /* we know it's at least 2013, when this code
1159 * was written
1160 */
1161 if (edid[0x11] + 90 <= 2013) {
1162 c.has_valid_year = 1;
1163 printk(BIOS_SPEW,
1164 "Made week %hhd of %d\n",
1165 edid[0x10], edid[0x11] + 1990);
1166 extra_info.week = edid[0x10];
1167 extra_info.year = edid[0x11] + 1990;
1168 }
1169 }
1170 }
1171 }
1172
1173 printk(BIOS_SPEW, "EDID version: %hhd.%hhd\n", edid[0x12], edid[0x13]);
1174 extra_info.version[0] = edid[0x12];
1175 extra_info.version[1] = edid[0x13];
1176
1177 if (edid[0x12] == 1) {
1178 if (edid[0x13] > 4) {
1179 printk(BIOS_SPEW,
1180 "Claims > 1.4, assuming 1.4 conformance\n");
1181 edid[0x13] = 4;
1182 }
1183 switch (edid[0x13]) {
1184 case 4:
1185 c.claims_one_point_four = 1;
1186 __fallthrough;
1187 case 3:
1188 c.claims_one_point_three = 1;
1189 __fallthrough;
1190 case 2:
1191 c.claims_one_point_two = 1;
1192 __fallthrough;
1193 default:
1194 c.claims_one_point_oh = 1;
1195 }
1196 }
1197
1198 /* display section */
1199 if (edid[0x14] & 0x80) {
1200 int conformance_mask;
1201 analog = 0;
1202 printk(BIOS_SPEW, "Digital display\n");
1203 if (c.claims_one_point_four) {
1204 conformance_mask = 0;
1205 if ((edid[0x14] & 0x70) == 0x00)
1206 printk(BIOS_SPEW, "Color depth is undefined\n");
1207 else if ((edid[0x14] & 0x70) == 0x70)
1208 c.nonconformant_digital_display = 1;
1209 else
1210 printk(BIOS_SPEW,
1211 "%d bits per primary color channel\n",
1212 ((edid[0x14] & 0x70) >> 3) + 4);
1213 out->panel_bits_per_color = ((edid[0x14] & 0x70) >> 3)
1214 + 4;
1215 out->panel_bits_per_pixel = 3*out->panel_bits_per_color;
1216
1217 switch (edid[0x14] & 0x0f) {
1218 case 0x00:
1219 printk(BIOS_SPEW,
1220 "Digital interface is not defined\n");
1221 break;
1222 case 0x01:
1223 printk(BIOS_SPEW, "DVI interface\n");
1224 break;
1225 case 0x02:
1226 printk(BIOS_SPEW, "HDMI-a interface\n");
1227 break;
1228 case 0x03:
1229 printk(BIOS_SPEW, "HDMI-b interface\n");
1230 break;
1231 case 0x04:
1232 printk(BIOS_SPEW, "MDDI interface\n");
1233 break;
1234 case 0x05:
1235 printk(BIOS_SPEW, "DisplayPort interface\n");
1236 break;
1237 default:
1238 c.nonconformant_digital_display = 1;
1239 break;
1240 }
1241 extra_info.type = edid[0x14] & 0x0f;
1242 } else if (c.claims_one_point_two) {
1243 conformance_mask = 0x7E;
1244 if (edid[0x14] & 0x01)
1245 printk(BIOS_SPEW, "DFP 1.x compatible TMDS\n");
1246 } else
1247 conformance_mask = 0x7F;
1248
1249 if (!c.nonconformant_digital_display)
1250 c.nonconformant_digital_display = edid[0x14]
1251 & conformance_mask;
1252 extra_info.nonconformant = c.nonconformant_digital_display;
1253 } else {
1254 analog = 1;
1255 int voltage = (edid[0x14] & 0x60) >> 5;
1256 int sync = (edid[0x14] & 0x0F);
1257 extra_info.voltage = voltage;
1258 extra_info.sync = sync;
1259
1260 printk(BIOS_SPEW, "Analog display, Input voltage level: %s V\n",
1261 voltage == 3 ? "0.7/0.7" :
1262 voltage == 2 ? "1.0/0.4" :
1263 voltage == 1 ? "0.714/0.286" :
1264 "0.7/0.3");
1265
1266 if (c.claims_one_point_four) {
1267 if (edid[0x14] & 0x10)
1268 printk(BIOS_SPEW,
1269 "Blank-to-black setup/pedestal\n");
1270 else
1271 printk(BIOS_SPEW,
1272 "Blank level equals black level\n");
1273 } else if (edid[0x14] & 0x10) {
1274 /*
1275 * XXX this is just the X text. 1.3 says "if set,
1276 * display expects a blank-to-black setup or pedestal
1277 * per appropriate Signal Level Standard". Whatever
1278 * _that_ means.
1279 */
1280 printk(BIOS_SPEW, "Configurable signal levels\n");
1281 }
1282
1283 printk(BIOS_SPEW, "Sync: %s%s%s%s\n",
1284 sync & 0x08 ? "Separate " : "",
1285 sync & 0x04 ? "Composite " : "",
1286 sync & 0x02 ? "SyncOnGreen " : "",
1287 sync & 0x01 ? "Serration " : "");
1288 }
1289
1290
1291 if (edid[0x15] && edid[0x16]) {
1292 printk(BIOS_SPEW, "Maximum image size: %d cm x %d cm\n",
1293 edid[0x15], edid[0x16]);
1294 } else if (c.claims_one_point_four && (edid[0x15] || edid[0x16])) {
1295 if (edid[0x15]) { /* edid[0x15] != 0 && edid[0x16] == 0 */
1296 unsigned int ratio = 100000/(edid[0x15] + 99);
1297 printk(BIOS_SPEW,
1298 "Aspect ratio is %u.%03u (landscape)\n",
1299 ratio / 1000, ratio % 1000);
1300 } else { /* edid[0x15] == 0 && edid[0x16] != 0 */
1301 unsigned int ratio = 100000/(edid[0x16] + 99);
1302 printk(BIOS_SPEW,
1303 "Aspect ratio is %u.%03u (portrait)\n",
1304 ratio / 1000, ratio % 1000);
1305 }
1306 } else {
1307 /* Either or both can be zero for 1.3 and before */
1308 printk(BIOS_SPEW, "Image size is variable\n");
1309 }
1310
1311 if (edid[0x17] == 0xff) {
1312 if (c.claims_one_point_four)
1313 printk(BIOS_SPEW,
1314 "Gamma is defined in an extension block\n");
1315 else
1316 /* XXX Technically 1.3 doesn't say this... */
1317 printk(BIOS_SPEW, "Gamma: 1.0\n");
1318 } else
1319 printk(BIOS_SPEW, "Gamma: %d%%\n", ((edid[0x17] + 100)));
1320 printk(BIOS_SPEW, "Check DPMS levels\n");
1321 if (edid[0x18] & 0xE0) {
1322 printk(BIOS_SPEW, "DPMS levels:");
1323 if (edid[0x18] & 0x80)
1324 printk(BIOS_SPEW, " Standby");
1325 if (edid[0x18] & 0x40)
1326 printk(BIOS_SPEW, " Suspend");
1327 if (edid[0x18] & 0x20)
1328 printk(BIOS_SPEW, " Off");
1329 printk(BIOS_SPEW, "\n");
1330 }
1331
1332 /* FIXME: this is from 1.4 spec, check earlier */
1333 if (analog) {
1334 switch (edid[0x18] & 0x18) {
1335 case 0x00:
1336 printk(BIOS_SPEW, "Monochrome or grayscale display\n");
1337 break;
1338 case 0x08:
1339 printk(BIOS_SPEW, "RGB color display\n");
1340 break;
1341 case 0x10:
1342 printk(BIOS_SPEW, "Non-RGB color display\n");
1343 break;
1344 case 0x18:
1345 printk(BIOS_SPEW, "Undefined display color type\n");
1346 break;
1347 }
1348 } else {
1349 printk(BIOS_SPEW, "Supported color formats: RGB 4:4:4");
1350 if (edid[0x18] & 0x10)
1351 printk(BIOS_SPEW, ", YCrCb 4:4:4");
1352 if (edid[0x18] & 0x08)
1353 printk(BIOS_SPEW, ", YCrCb 4:2:2");
1354 printk(BIOS_SPEW, "\n");
1355 }
1356
1357 if (edid[0x18] & 0x04)
1358 printk(BIOS_SPEW,
1359 "Default (sRGB) color space is primary color space\n");
1360 if (edid[0x18] & 0x02) {
1361 printk(BIOS_SPEW,
1362 "First detailed timing is preferred timing\n");
1363 c.has_preferred_timing = 1;
1364 }
1365 if (edid[0x18] & 0x01)
1366 printk(BIOS_SPEW,
1367 "Supports GTF timings within operating range\n");
1368
1369 /* XXX color section */
1370
1371 printk(BIOS_SPEW, "Established timings supported:\n");
1372 /* it's not yet clear we want all this stuff in the edid struct.
1373 * Let's wait.
1374 */
1375 for (i = 0; i < 17; i++) {
1376 if (edid[0x23 + i / 8] & (1 << (7 - i % 8))) {
1377 printk(BIOS_SPEW, " %dx%d@%dHz\n",
1378 established_timings[i].x,
1379 established_timings[i].y,
1380 established_timings[i].refresh);
1381
1382 for (j = 0; j < NUM_KNOWN_MODES; j++) {
1383 if (known_modes[j].ha ==
1384 established_timings[i].x
1385 && known_modes[j].va ==
1386 established_timings[i].y
1387 && known_modes[j].refresh ==
1388 established_timings[i].refresh)
1389 out->mode_is_supported[j] = 1;
1390 }
1391 }
1392
1393 }
1394
1395 printk(BIOS_SPEW, "Standard timings supported:\n");
1396 for (i = 0; i < 8; i++) {
1397 uint8_t b1 = edid[0x26 + i * 2], b2 = edid[0x26 + i * 2 + 1];
1398 unsigned int x, y = 0, refresh;
1399
1400 if (b1 == 0x01 && b2 == 0x01)
1401 continue;
1402
1403 if (b1 == 0) {
1404 printk(BIOS_SPEW,
1405 "non-conformant standard timing (0 horiz)\n");
1406 continue;
1407 }
1408 x = (b1 + 31) * 8;
1409 switch ((b2 >> 6) & 0x3) {
1410 case 0x00:
1411 if (c.claims_one_point_three)
1412 y = x * 10 / 16;
1413 else
1414 y = x;
1415 break;
1416 case 0x01:
1417 y = x * 3 / 4;
1418 break;
1419 case 0x02:
1420 y = x * 4 / 5;
1421 break;
1422 case 0x03:
1423 y = x * 9 / 16;
1424 break;
1425 }
1426 refresh = 60 + (b2 & 0x3f);
1427
1428 printk(BIOS_SPEW, " %dx%d@%dHz\n", x, y, refresh);
1429 for (j = 0; j < NUM_KNOWN_MODES; j++) {
1430 if (known_modes[j].ha == x && known_modes[j].va == y &&
1431 known_modes[j].refresh == refresh)
1432 out->mode_is_supported[j] = 1;
1433 }
1434 }
1435
1436 /* detailed timings */
1437 printk(BIOS_SPEW, "Detailed timings\n");
1438 for (i = 0; i < 4; i++) {
1439 c.has_valid_detailed_blocks &= detailed_block(
1440 out, edid + 0x36 + i * 18, 0, &c);
1441 if (i == 0 && c.has_preferred_timing
1442 && !c.did_detailed_timing) {
1443 /* not really accurate... */
1444 c.has_preferred_timing = 0;
1445 }
1446 }
1447
1448 /* check this, 1.4 verification guide says otherwise */
1449 if (edid[0x7e]) {
1450 printk(BIOS_SPEW, "Has %d extension blocks\n", edid[0x7e]);
1451 /* 2 is impossible because of the block map */
1452 if (edid[0x7e] != 2)
1453 c.has_valid_extension_count = 1;
1454 } else {
1455 c.has_valid_extension_count = 1;
1456 }
1457
1458 printk(BIOS_SPEW, "Checksum\n");
1459 c.has_valid_checksum = do_checksum(edid);
1460
1461 /* EDID v2.0 has a larger blob (256 bytes) and may have some problem in
1462 * the extension parsing loop below. Since v2.0 was quickly deprecated
1463 * by v1.3 and we are unlikely to use any EDID 2.0 panels, we ignore
1464 * that case now and can fix it when we need to use a real 2.0 panel.
1465 */
1466 for (i = 128; i < size; i += 128)
1467 c.nonconformant_extension +=
1468 parse_extension(out, &edid[i], &c);
1469
1470 if (c.claims_one_point_four) {
1471 if (c.nonconformant_digital_display ||
1472 !c.has_valid_string_termination ||
1473 !c.has_valid_descriptor_pad ||
1474 !c.has_preferred_timing) {
1475 c.conformant = EDID_NOT_CONFORMANT;
1476 printk(BIOS_ERR,
1477 "EDID block does NOT conform to EDID 1.4!\n");
1478 }
1479
1480 if (c.nonconformant_digital_display)
1481 printk(BIOS_ERR,
1482 "\tDigital display field contains garbage: %x\n",
1483 c.nonconformant_digital_display);
1484 if (!c.has_valid_string_termination)
1485 printk(BIOS_ERR,
1486 "\tDetailed block string not properly terminated\n");
1487 if (!c.has_valid_descriptor_pad)
1488 printk(BIOS_ERR,
1489 "\tInvalid descriptor block padding\n");
1490 if (!c.has_preferred_timing)
1491 printk(BIOS_ERR, "\tMissing preferred timing\n");
1492 } else if (c.claims_one_point_three) {
1493 if (c.nonconformant_digital_display ||
1494 !c.has_valid_string_termination ||
1495 !c.has_valid_descriptor_pad ||
1496 !c.has_preferred_timing) {
1497 c.conformant = EDID_NOT_CONFORMANT;
1498 }
1499 /**
1500 * According to E-EDID (EDIDv1.3), has_name_descriptor and
1501 * has_range_descriptor are both required. These fields are
1502 * optional in v1.4. However some v1.3 panels (Ex, B133XTN01.3)
1503 * don't have them. As a workaround, we only print warning
1504 * messages.
1505 */
1506 if (c.conformant == EDID_NOT_CONFORMANT)
1507 printk(BIOS_ERR,
1508 "EDID block does NOT conform to EDID 1.3!\n");
1509 else if (!c.has_name_descriptor || !c.has_range_descriptor)
1510 printk(BIOS_WARNING, "EDID block does NOT "
1511 "fully conform to EDID 1.3.\n");
1512
1513 if (c.nonconformant_digital_display)
1514 printk(BIOS_ERR,
1515 "\tDigital display field contains garbage: %x\n",
1516 c.nonconformant_digital_display);
1517 if (!c.has_name_descriptor)
1518 printk(BIOS_ERR, "\tMissing name descriptor\n");
1519 if (!c.has_preferred_timing)
1520 printk(BIOS_ERR, "\tMissing preferred timing\n");
1521 if (!c.has_range_descriptor)
1522 printk(BIOS_ERR, "\tMissing monitor ranges\n");
1523 /* Might be more than just 1.3 */
1524 if (!c.has_valid_descriptor_pad)
1525 printk(BIOS_ERR,
1526 "\tInvalid descriptor block padding\n");
1527 if (!c.has_valid_string_termination) /* Likewise */
1528 printk(BIOS_ERR,
1529 "\tDetailed block string not properly terminated\n");
1530 } else if (c.claims_one_point_two) {
1531 if (c.nonconformant_digital_display ||
1532 !c.has_valid_string_termination) {
1533 c.conformant = EDID_NOT_CONFORMANT;
1534 printk(BIOS_ERR,
1535 "EDID block does NOT conform to EDID 1.2!\n");
1536 }
1537 if (c.nonconformant_digital_display)
1538 printk(BIOS_ERR,
1539 "\tDigital display field contains garbage: %x\n",
1540 c.nonconformant_digital_display);
1541 if (!c.has_valid_string_termination)
1542 printk(BIOS_ERR,
1543 "\tDetailed block string not properly terminated\n");
1544 } else if (c.claims_one_point_oh) {
1545 if (c.seen_non_detailed_descriptor) {
1546 c.conformant = EDID_NOT_CONFORMANT;
1547 printk(BIOS_ERR,
1548 "EDID block does NOT conform to EDID 1.0!\n");
1549 }
1550 if (c.seen_non_detailed_descriptor)
1551 printk(BIOS_ERR,
1552 "\tHas descriptor blocks other than detailed timings\n");
1553 }
1554
1555 if (c.nonconformant_extension ||
1556 !c.has_valid_checksum ||
1557 !c.has_valid_cvt ||
1558 !c.has_valid_year ||
1559 !c.has_valid_week ||
1560 !c.has_valid_detailed_blocks ||
1561 !c.has_valid_dummy_block ||
1562 !c.has_valid_extension_count ||
1563 !c.has_valid_descriptor_ordering ||
1564 !c.has_valid_range_descriptor ||
1565 !c.manufacturer_name_well_formed) {
1566 c.conformant = EDID_NOT_CONFORMANT;
1567 printk(BIOS_ERR, "EDID block does not conform at all!\n");
1568 if (c.nonconformant_extension)
1569 printk(BIOS_ERR,
1570 "\tHas %d nonconformant extension block(s)\n",
1571 c.nonconformant_extension);
1572 if (!c.has_valid_checksum)
1573 printk(BIOS_ERR, "\tBlock has broken checksum\n");
1574 if (!c.has_valid_cvt)
1575 printk(BIOS_ERR, "\tBroken 3-byte CVT blocks\n");
1576 if (!c.has_valid_year)
1577 printk(BIOS_ERR, "\tBad year of manufacture\n");
1578 if (!c.has_valid_week)
1579 printk(BIOS_ERR, "\tBad week of manufacture\n");
1580 if (!c.has_valid_detailed_blocks)
1581 printk(BIOS_ERR,
1582 "\tDetailed blocks filled with garbage\n");
1583 if (!c.has_valid_dummy_block)
1584 printk(BIOS_ERR, "\tDummy block filled with garbage\n");
1585 if (!c.has_valid_extension_count)
1586 printk(BIOS_ERR,
1587 "\tImpossible extension block count\n");
1588 if (!c.manufacturer_name_well_formed)
1589 printk(BIOS_ERR,
1590 "\tManufacturer name field contains garbage\n");
1591 if (!c.has_valid_descriptor_ordering)
1592 printk(BIOS_ERR,
1593 "\tInvalid detailed timing descriptor ordering\n");
1594 if (!c.has_valid_range_descriptor)
1595 printk(BIOS_ERR,
1596 "\tRange descriptor contains garbage\n");
1597 if (!c.has_valid_max_dotclock)
1598 printk(BIOS_ERR,
1599 "\tEDID 1.4 block does not set max dotclock\n");
1600 }
1601
1602 if (c.warning_excessive_dotclock_correction)
1603 printk(BIOS_ERR,
1604 "Warning: CVT block corrects dotclock by more than 9.75MHz\n");
1605 if (c.warning_zero_preferred_refresh)
1606 printk(BIOS_ERR,
1607 "Warning: CVT block does not set preferred refresh rate\n");
1608 return c.conformant;
1609 }
1610
1611 /*
1612 * Notes on panel extensions: (TODO, implement me in the code)
1613 *
1614 * EPI: http://www.epi-standard.org/fileadmin/spec/EPI_Specification1.0.pdf
1615 * at offset 0x6c (fourth detailed block): (all other bits reserved)
1616 * 0x6c: 00 00 00 0e 00
1617 * 0x71: bit 6-5: data color mapping (00 conventional/fpdi/vesa, 01 openldi)
1618 * bit 4-3: pixels per clock (00 1, 01 2, 10 4, 11 reserved)
1619 * bit 2-0: bits per pixel (000 18, 001 24, 010 30, else reserved)
1620 * 0x72: bit 5: FPSCLK polarity (0 normal 1 inverted)
1621 * bit 4: DE polarity (0 high active 1 low active)
1622 * bit 3-0: interface (0000 LVDS TFT
1623 * 0001 mono STN 4/8bit
1624 * 0010 color STN 8/16 bit
1625 * 0011 18 bit tft
1626 * 0100 24 bit tft
1627 * 0101 tmds
1628 * else reserved)
1629 * 0x73: bit 1: horizontal display mode (0 normal 1 right/left reverse)
1630 * bit 0: vertical display mode (0 normal 1 up/down reverse)
1631 * 0x74: bit 7-4: total poweroff seq delay (0000 vga controller default
1632 * else time in 10ms (10ms to 150ms))
1633 * bit 3-0: total poweron seq delay (as above)
1634 * 0x75: contrast power on/off seq delay, same as 0x74
1635 * 0x76: bit 7: backlight control enable (1 means this field is valid)
1636 * bit 6: backlight enabled at boot (0 on 1 off)
1637 * bit 5-0: backlight brightness control steps (0..63)
1638 * 0x77: bit 7: contrast control, same bit pattern as 0x76 except bit 6 resvd
1639 * 0x78 - 0x7c: reserved
1640 * 0x7d: bit 7-4: EPI descriptor major version (1)
1641 * bit 3-0: EPI descriptor minor version (0)
1642 *
1643 * ----
1644 *
1645 * SPWG: http://www.spwg.org/spwg_spec_version3.8_3-14-2007.pdf
1646 *
1647 * Since these are "dummy" blocks, terminate with 0a 20 20 20 ... as usual
1648 *
1649 * detailed descriptor 3:
1650 * 0x5a - 0x5e: 00 00 00 fe 00
1651 * 0x5f - 0x63: PC maker part number
1652 * 0x64: LCD supplier revision #
1653 * 0x65 - 0x6b: manufacturer part number
1654 *
1655 * detailed descriptor 4:
1656 * 0x6c - 0x70: 00 00 00 fe 00
1657 * 0x71 - 0x78: smbus nits values (whut)
1658 * 0x79: number of lvds channels (1 or 2)
1659 * 0x7A: panel self test (1 if present)
1660 * and then dummy terminator
1661 *
1662 * SPWG also says something strange about the LSB of detailed descriptor 1:
1663 * "LSB is set to "1" if panel is DE-timing only. H/V can be ignored."
1664 */
1665
1666 /* Set the framebuffer bits-per-pixel, recalculating all dependent values. */
1667 void edid_set_framebuffer_bits_per_pixel(struct edid *edid, int fb_bpp,
1668 int row_byte_alignment)
1669 {
1670 /* Caller should pass a supported value, everything else is BUG(). */
1671 assert(fb_bpp == 32 || fb_bpp == 24 || fb_bpp == 16);
1672 row_byte_alignment = MAX(row_byte_alignment, 1);
1673
1674 edid->framebuffer_bits_per_pixel = fb_bpp;
1675 edid->bytes_per_line = ALIGN_UP(edid->mode.ha *
1676 DIV_ROUND_UP(fb_bpp, 8), row_byte_alignment);
1677 edid->x_resolution = edid->bytes_per_line / (fb_bpp / 8);
1678 edid->y_resolution = edid->mode.va;
1679 }
ast, secure and flexible OpenSource firmware