| 1 | /* |
| 2 | * Copyright 1998 by Egbert Eich <Egbert.Eich@Physik.TU-Darmstadt.DE> |
| 3 | * Copyright 2007 Red Hat, Inc. |
| 4 | * |
| 5 | * Permission is hereby granted, free of charge, to any person obtaining a |
| 6 | * copy of this software and associated documentation files (the "Software"), |
| 7 | * to deal in the Software without restriction, including without limitation |
| 8 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| 9 | * and/or sell copies of the Software, and to permit persons to whom the |
| 10 | * Software is furnished to do so, subject to the following conditions: |
| 11 | * |
| 12 | * The above copyright notice and this permission notice (including the next |
| 13 | * paragraph) shall be included in all copies or substantial portions of the |
| 14 | * Software. |
| 15 | * |
| 16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| 17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| 19 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| 20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| 21 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
| 22 | * DEALINGS IN THE SOFTWARE. |
| 23 | * |
| 24 | * interpret_edid.c: interpret a primary EDID block |
| 25 | */ |
| 26 | |
| 27 | #ifdef HAVE_XORG_CONFIG_H |
| 28 | #include <xorg-config.h> |
| 29 | #endif |
| 30 | |
| 31 | #include "misc.h" |
| 32 | #include "xf86.h" |
| 33 | #include "xf86_OSproc.h" |
| 34 | #define _PARSE_EDID_ |
| 35 | #include "xf86DDC.h" |
| 36 | #include <string.h> |
| 37 | |
| 38 | static void get_vendor_section(Uchar *, struct vendor *); |
| 39 | static void get_version_section(Uchar *, struct edid_version *); |
| 40 | static void get_display_section(Uchar *, struct disp_features *, |
| 41 | struct edid_version *); |
| 42 | static void get_established_timing_section(Uchar *, |
| 43 | struct established_timings *); |
| 44 | static void get_std_timing_section(Uchar *, struct std_timings *, |
| 45 | struct edid_version *); |
| 46 | static void fetch_detailed_block(Uchar * c, struct edid_version *ver, |
| 47 | struct detailed_monitor_section *det_mon); |
| 48 | static void get_dt_md_section(Uchar *, struct edid_version *, |
| 49 | struct detailed_monitor_section *det_mon); |
| 50 | static void copy_string(Uchar *, Uchar *); |
| 51 | static void get_dst_timing_section(Uchar *, struct std_timings *, |
| 52 | struct edid_version *); |
| 53 | static void get_monitor_ranges(Uchar *, struct monitor_ranges *); |
| 54 | static void get_whitepoint_section(Uchar *, struct whitePoints *); |
| 55 | static void get_detailed_timing_section(Uchar *, struct detailed_timings *); |
| 56 | static Bool validate_version(int scrnIndex, struct edid_version *); |
| 57 | |
| 58 | static void |
| 59 | find_ranges_section(struct detailed_monitor_section *det, void *ranges) |
| 60 | { |
| 61 | if (det->type == DS_RANGES && det->section.ranges.max_clock) |
| 62 | *(struct monitor_ranges **) ranges = &det->section.ranges; |
| 63 | } |
| 64 | |
| 65 | static void |
| 66 | find_max_detailed_clock(struct detailed_monitor_section *det, void *ret) |
| 67 | { |
| 68 | if (det->type == DT) { |
| 69 | *(int *) ret = max(*((int *) ret), det->section.d_timings.clock); |
| 70 | } |
| 71 | } |
| 72 | |
| 73 | static void |
| 74 | handle_edid_quirks(xf86MonPtr m) |
| 75 | { |
| 76 | struct monitor_ranges *ranges = NULL; |
| 77 | |
| 78 | /* |
| 79 | * max_clock is only encoded in EDID in tens of MHz, so occasionally we |
| 80 | * find a monitor claiming a max of 160 with a mode requiring 162, or |
| 81 | * similar. Strictly we should refuse to round up too far, but let's |
| 82 | * see how well this works. |
| 83 | */ |
| 84 | |
| 85 | /* Try to find Monitor Range and max clock, then re-set range value */ |
| 86 | xf86ForEachDetailedBlock(m, find_ranges_section, &ranges); |
| 87 | if (ranges && ranges->max_clock) { |
| 88 | int clock = 0; |
| 89 | |
| 90 | xf86ForEachDetailedBlock(m, find_max_detailed_clock, &clock); |
| 91 | if (clock && (ranges->max_clock * 1e6 < clock)) { |
| 92 | xf86Msg(X_WARNING, "EDID timing clock %.2f exceeds claimed max " |
| 93 | "%dMHz, fixing\n", clock / 1.0e6, ranges->max_clock); |
| 94 | ranges->max_clock = (clock + 999999) / 1e6; |
| 95 | } |
| 96 | } |
| 97 | } |
| 98 | |
| 99 | struct det_hv_parameter { |
| 100 | int real_hsize; |
| 101 | int real_vsize; |
| 102 | float target_aspect; |
| 103 | }; |
| 104 | |
| 105 | static void |
| 106 | handle_detailed_hvsize(struct detailed_monitor_section *det_mon, void *data) |
| 107 | { |
| 108 | struct det_hv_parameter *p = (struct det_hv_parameter *) data; |
| 109 | float timing_aspect; |
| 110 | |
| 111 | if (det_mon->type == DT) { |
| 112 | struct detailed_timings *timing; |
| 113 | |
| 114 | timing = &det_mon->section.d_timings; |
| 115 | |
| 116 | if (!timing->v_size) |
| 117 | return; |
| 118 | |
| 119 | timing_aspect = (float) timing->h_size / timing->v_size; |
| 120 | if (fabs(1 - (timing_aspect / p->target_aspect)) < 0.05) { |
| 121 | p->real_hsize = max(p->real_hsize, timing->h_size); |
| 122 | p->real_vsize = max(p->real_vsize, timing->v_size); |
| 123 | } |
| 124 | } |
| 125 | } |
| 126 | |
| 127 | static void |
| 128 | encode_aspect_ratio(xf86MonPtr m) |
| 129 | { |
| 130 | /* |
| 131 | * some monitors encode the aspect ratio instead of the physical size. |
| 132 | * try to find the largest detailed timing that matches that aspect |
| 133 | * ratio and use that to fill in the feature section. |
| 134 | */ |
| 135 | if ((m->features.hsize == 16 && m->features.vsize == 9) || |
| 136 | (m->features.hsize == 16 && m->features.vsize == 10) || |
| 137 | (m->features.hsize == 4 && m->features.vsize == 3) || |
| 138 | (m->features.hsize == 5 && m->features.vsize == 4)) { |
| 139 | |
| 140 | struct det_hv_parameter p; |
| 141 | |
| 142 | p.real_hsize = 0; |
| 143 | p.real_vsize = 0; |
| 144 | p.target_aspect = (float) m->features.hsize / m->features.vsize; |
| 145 | |
| 146 | xf86ForEachDetailedBlock(m, handle_detailed_hvsize, &p); |
| 147 | |
| 148 | if (!p.real_hsize || !p.real_vsize) { |
| 149 | m->features.hsize = m->features.vsize = 0; |
| 150 | } |
| 151 | else if ((m->features.hsize * 10 == p.real_hsize) && |
| 152 | (m->features.vsize * 10 == p.real_vsize)) { |
| 153 | /* exact match is just unlikely, should do a better check though */ |
| 154 | m->features.hsize = m->features.vsize = 0; |
| 155 | } |
| 156 | else { |
| 157 | /* convert mm to cm */ |
| 158 | m->features.hsize = (p.real_hsize + 5) / 10; |
| 159 | m->features.vsize = (p.real_vsize + 5) / 10; |
| 160 | } |
| 161 | |
| 162 | xf86Msg(X_INFO, "Quirked EDID physical size to %dx%d cm\n", |
| 163 | m->features.hsize, m->features.vsize); |
| 164 | } |
| 165 | } |
| 166 | |
| 167 | xf86MonPtr |
| 168 | xf86InterpretEDID(int scrnIndex, Uchar * block) |
| 169 | { |
| 170 | xf86MonPtr m; |
| 171 | |
| 172 | if (!block) |
| 173 | return NULL; |
| 174 | if (!(m = xnfcalloc(sizeof(xf86Monitor), 1))) |
| 175 | return NULL; |
| 176 | m->scrnIndex = scrnIndex; |
| 177 | m->rawData = block; |
| 178 | |
| 179 | get_vendor_section(SECTION(VENDOR_SECTION, block), &m->vendor); |
| 180 | get_version_section(SECTION(VERSION_SECTION, block), &m->ver); |
| 181 | if (!validate_version(scrnIndex, &m->ver)) |
| 182 | goto error; |
| 183 | get_display_section(SECTION(DISPLAY_SECTION, block), &m->features, &m->ver); |
| 184 | get_established_timing_section(SECTION(ESTABLISHED_TIMING_SECTION, block), |
| 185 | &m->timings1); |
| 186 | get_std_timing_section(SECTION(STD_TIMING_SECTION, block), m->timings2, |
| 187 | &m->ver); |
| 188 | get_dt_md_section(SECTION(DET_TIMING_SECTION, block), &m->ver, m->det_mon); |
| 189 | m->no_sections = (int) *(char *) SECTION(NO_EDID, block); |
| 190 | |
| 191 | handle_edid_quirks(m); |
| 192 | encode_aspect_ratio(m); |
| 193 | |
| 194 | return m; |
| 195 | |
| 196 | error: |
| 197 | free(m); |
| 198 | return NULL; |
| 199 | } |
| 200 | |
| 201 | static int |
| 202 | get_cea_detail_timing(Uchar * blk, xf86MonPtr mon, |
| 203 | struct detailed_monitor_section *det_mon) |
| 204 | { |
| 205 | int dt_num; |
| 206 | int dt_offset = ((struct cea_ext_body *) blk)->dt_offset; |
| 207 | |
| 208 | dt_num = 0; |
| 209 | |
| 210 | if (dt_offset < CEA_EXT_MIN_DATA_OFFSET) |
| 211 | return dt_num; |
| 212 | |
| 213 | for (; dt_offset < (CEA_EXT_MAX_DATA_OFFSET - DET_TIMING_INFO_LEN) && |
| 214 | dt_num < CEA_EXT_DET_TIMING_NUM; _NEXT_DT_MD_SECTION(dt_offset)) { |
| 215 | |
| 216 | fetch_detailed_block(blk + dt_offset, &mon->ver, det_mon + dt_num); |
| 217 | dt_num = dt_num + 1; |
| 218 | } |
| 219 | |
| 220 | return dt_num; |
| 221 | } |
| 222 | |
| 223 | static void |
| 224 | handle_cea_detail_block(Uchar * ext, xf86MonPtr mon, |
| 225 | handle_detailed_fn fn, void *data) |
| 226 | { |
| 227 | int i; |
| 228 | struct detailed_monitor_section det_mon[CEA_EXT_DET_TIMING_NUM]; |
| 229 | int det_mon_num; |
| 230 | |
| 231 | det_mon_num = get_cea_detail_timing(ext, mon, det_mon); |
| 232 | |
| 233 | for (i = 0; i < det_mon_num; i++) |
| 234 | fn(det_mon + i, data); |
| 235 | } |
| 236 | |
| 237 | void |
| 238 | xf86ForEachDetailedBlock(xf86MonPtr mon, handle_detailed_fn fn, void *data) |
| 239 | { |
| 240 | int i; |
| 241 | Uchar *ext; |
| 242 | |
| 243 | if (mon == NULL) |
| 244 | return; |
| 245 | |
| 246 | for (i = 0; i < DET_TIMINGS; i++) |
| 247 | fn(mon->det_mon + i, data); |
| 248 | |
| 249 | for (i = 0; i < mon->no_sections; i++) { |
| 250 | ext = mon->rawData + EDID1_LEN * (i + 1); |
| 251 | switch (ext[EXT_TAG]) { |
| 252 | case CEA_EXT: |
| 253 | handle_cea_detail_block(ext, mon, fn, data); |
| 254 | break; |
| 255 | case VTB_EXT: |
| 256 | case DI_EXT: |
| 257 | case LS_EXT: |
| 258 | case MI_EXT: |
| 259 | break; |
| 260 | } |
| 261 | } |
| 262 | } |
| 263 | |
| 264 | static struct cea_data_block * |
| 265 | extract_cea_data_block(Uchar * ext, int data_type) |
| 266 | { |
| 267 | struct cea_ext_body *cea; |
| 268 | struct cea_data_block *data_collection; |
| 269 | struct cea_data_block *data_end; |
| 270 | |
| 271 | cea = (struct cea_ext_body *) ext; |
| 272 | |
| 273 | if (cea->dt_offset <= CEA_EXT_MIN_DATA_OFFSET) |
| 274 | return NULL; |
| 275 | |
| 276 | data_collection = &cea->data_collection; |
| 277 | data_end = (struct cea_data_block *) (cea->dt_offset + ext); |
| 278 | |
| 279 | for (; data_collection < data_end;) { |
| 280 | |
| 281 | if (data_type == data_collection->tag) { |
| 282 | return data_collection; |
| 283 | } |
| 284 | data_collection = (void *) ((unsigned char *) data_collection + |
| 285 | data_collection->len + 1); |
| 286 | } |
| 287 | |
| 288 | return NULL; |
| 289 | } |
| 290 | |
| 291 | static void |
| 292 | handle_cea_video_block(Uchar * ext, handle_video_fn fn, void *data) |
| 293 | { |
| 294 | struct cea_video_block *video; |
| 295 | struct cea_video_block *video_end; |
| 296 | struct cea_data_block *data_collection; |
| 297 | |
| 298 | data_collection = extract_cea_data_block(ext, CEA_VIDEO_BLK); |
| 299 | if (data_collection == NULL) |
| 300 | return; |
| 301 | |
| 302 | video = &data_collection->u.video; |
| 303 | video_end = (struct cea_video_block *) |
| 304 | ((Uchar *) video + data_collection->len); |
| 305 | |
| 306 | for (; video < video_end; video = video + 1) { |
| 307 | fn(video, data); |
| 308 | } |
| 309 | } |
| 310 | |
| 311 | void |
| 312 | xf86ForEachVideoBlock(xf86MonPtr mon, handle_video_fn fn, void *data) |
| 313 | { |
| 314 | int i; |
| 315 | Uchar *ext; |
| 316 | |
| 317 | if (mon == NULL) |
| 318 | return; |
| 319 | |
| 320 | for (i = 0; i < mon->no_sections; i++) { |
| 321 | ext = mon->rawData + EDID1_LEN * (i + 1); |
| 322 | switch (ext[EXT_TAG]) { |
| 323 | case CEA_EXT: |
| 324 | handle_cea_video_block(ext, fn, data); |
| 325 | break; |
| 326 | case VTB_EXT: |
| 327 | case DI_EXT: |
| 328 | case LS_EXT: |
| 329 | case MI_EXT: |
| 330 | break; |
| 331 | } |
| 332 | } |
| 333 | } |
| 334 | |
| 335 | xf86MonPtr |
| 336 | xf86InterpretEEDID(int scrnIndex, Uchar * block) |
| 337 | { |
| 338 | xf86MonPtr m; |
| 339 | |
| 340 | m = xf86InterpretEDID(scrnIndex, block); |
| 341 | if (!m) |
| 342 | return NULL; |
| 343 | |
| 344 | /* extension parse */ |
| 345 | |
| 346 | return m; |
| 347 | } |
| 348 | |
| 349 | static void |
| 350 | get_vendor_section(Uchar * c, struct vendor *r) |
| 351 | { |
| 352 | r->name[0] = L1; |
| 353 | r->name[1] = L2; |
| 354 | r->name[2] = L3; |
| 355 | r->name[3] = '\0'; |
| 356 | |
| 357 | r->prod_id = PROD_ID; |
| 358 | r->serial = SERIAL_NO; |
| 359 | r->week = WEEK; |
| 360 | r->year = YEAR; |
| 361 | } |
| 362 | |
| 363 | static void |
| 364 | get_version_section(Uchar * c, struct edid_version *r) |
| 365 | { |
| 366 | r->version = VERSION; |
| 367 | r->revision = REVISION; |
| 368 | } |
| 369 | |
| 370 | static void |
| 371 | get_display_section(Uchar * c, struct disp_features *r, struct edid_version *v) |
| 372 | { |
| 373 | r->input_type = INPUT_TYPE; |
| 374 | if (!DIGITAL(r->input_type)) { |
| 375 | r->input_voltage = INPUT_VOLTAGE; |
| 376 | r->input_setup = SETUP; |
| 377 | r->input_sync = SYNC; |
| 378 | } |
| 379 | else if (v->revision == 2 || v->revision == 3) { |
| 380 | r->input_dfp = DFP; |
| 381 | } |
| 382 | else if (v->revision >= 4) { |
| 383 | r->input_bpc = BPC; |
| 384 | r->input_interface = DIGITAL_INTERFACE; |
| 385 | } |
| 386 | r->hsize = HSIZE_MAX; |
| 387 | r->vsize = VSIZE_MAX; |
| 388 | r->gamma = GAMMA; |
| 389 | r->dpms = DPMS; |
| 390 | r->display_type = DISPLAY_TYPE; |
| 391 | r->msc = MSC; |
| 392 | r->redx = REDX; |
| 393 | r->redy = REDY; |
| 394 | r->greenx = GREENX; |
| 395 | r->greeny = GREENY; |
| 396 | r->bluex = BLUEX; |
| 397 | r->bluey = BLUEY; |
| 398 | r->whitex = WHITEX; |
| 399 | r->whitey = WHITEY; |
| 400 | } |
| 401 | |
| 402 | static void |
| 403 | get_established_timing_section(Uchar * c, struct established_timings *r) |
| 404 | { |
| 405 | r->t1 = T1; |
| 406 | r->t2 = T2; |
| 407 | r->t_manu = T_MANU; |
| 408 | } |
| 409 | |
| 410 | static void |
| 411 | get_cvt_timing_section(Uchar * c, struct cvt_timings *r) |
| 412 | { |
| 413 | int i; |
| 414 | |
| 415 | for (i = 0; i < 4; i++) { |
| 416 | if (c[0] && c[1] && c[2]) { |
| 417 | r[i].height = (c[0] + ((c[1] & 0xF0) << 8) + 1) * 2; |
| 418 | switch (c[1] & 0xc0) { |
| 419 | case 0x00: |
| 420 | r[i].width = r[i].height * 4 / 3; |
| 421 | break; |
| 422 | case 0x40: |
| 423 | r[i].width = r[i].height * 16 / 9; |
| 424 | break; |
| 425 | case 0x80: |
| 426 | r[i].width = r[i].height * 16 / 10; |
| 427 | break; |
| 428 | case 0xc0: |
| 429 | r[i].width = r[i].height * 15 / 9; |
| 430 | break; |
| 431 | } |
| 432 | switch (c[2] & 0x60) { |
| 433 | case 0x00: |
| 434 | r[i].rate = 50; |
| 435 | break; |
| 436 | case 0x20: |
| 437 | r[i].rate = 60; |
| 438 | break; |
| 439 | case 0x40: |
| 440 | r[i].rate = 75; |
| 441 | break; |
| 442 | case 0x60: |
| 443 | r[i].rate = 85; |
| 444 | break; |
| 445 | } |
| 446 | r[i].rates = c[2] & 0x1f; |
| 447 | } |
| 448 | else { |
| 449 | return; |
| 450 | } |
| 451 | c += 3; |
| 452 | } |
| 453 | } |
| 454 | |
| 455 | static void |
| 456 | get_std_timing_section(Uchar * c, struct std_timings *r, struct edid_version *v) |
| 457 | { |
| 458 | int i; |
| 459 | |
| 460 | for (i = 0; i < STD_TIMINGS; i++) { |
| 461 | if (VALID_TIMING) { |
| 462 | r[i].hsize = HSIZE1; |
| 463 | VSIZE1(r[i].vsize); |
| 464 | r[i].refresh = REFRESH_R; |
| 465 | r[i].id = STD_TIMING_ID; |
| 466 | } |
| 467 | else { |
| 468 | r[i].hsize = r[i].vsize = r[i].refresh = r[i].id = 0; |
| 469 | } |
| 470 | NEXT_STD_TIMING; |
| 471 | } |
| 472 | } |
| 473 | |
| 474 | static const unsigned char empty_block[18]; |
| 475 | |
| 476 | static void |
| 477 | fetch_detailed_block(Uchar * c, struct edid_version *ver, |
| 478 | struct detailed_monitor_section *det_mon) |
| 479 | { |
| 480 | if (ver->version == 1 && ver->revision >= 1 && IS_MONITOR_DESC) { |
| 481 | switch (MONITOR_DESC_TYPE) { |
| 482 | case SERIAL_NUMBER: |
| 483 | det_mon->type = DS_SERIAL; |
| 484 | copy_string(c, det_mon->section.serial); |
| 485 | break; |
| 486 | case ASCII_STR: |
| 487 | det_mon->type = DS_ASCII_STR; |
| 488 | copy_string(c, det_mon->section.ascii_data); |
| 489 | break; |
| 490 | case MONITOR_RANGES: |
| 491 | det_mon->type = DS_RANGES; |
| 492 | get_monitor_ranges(c, &det_mon->section.ranges); |
| 493 | break; |
| 494 | case MONITOR_NAME: |
| 495 | det_mon->type = DS_NAME; |
| 496 | copy_string(c, det_mon->section.name); |
| 497 | break; |
| 498 | case ADD_COLOR_POINT: |
| 499 | det_mon->type = DS_WHITE_P; |
| 500 | get_whitepoint_section(c, det_mon->section.wp); |
| 501 | break; |
| 502 | case ADD_STD_TIMINGS: |
| 503 | det_mon->type = DS_STD_TIMINGS; |
| 504 | get_dst_timing_section(c, det_mon->section.std_t, ver); |
| 505 | break; |
| 506 | case COLOR_MANAGEMENT_DATA: |
| 507 | det_mon->type = DS_CMD; |
| 508 | break; |
| 509 | case CVT_3BYTE_DATA: |
| 510 | det_mon->type = DS_CVT; |
| 511 | get_cvt_timing_section(c, det_mon->section.cvt); |
| 512 | break; |
| 513 | case ADD_EST_TIMINGS: |
| 514 | det_mon->type = DS_EST_III; |
| 515 | memcpy(det_mon->section.est_iii, c + 6, 6); |
| 516 | break; |
| 517 | case ADD_DUMMY: |
| 518 | det_mon->type = DS_DUMMY; |
| 519 | break; |
| 520 | default: |
| 521 | det_mon->type = DS_UNKOWN; |
| 522 | break; |
| 523 | } |
| 524 | if (c[3] <= 0x0F && memcmp(c, empty_block, sizeof(empty_block))) { |
| 525 | det_mon->type = DS_VENDOR + c[3]; |
| 526 | } |
| 527 | } |
| 528 | else { |
| 529 | det_mon->type = DT; |
| 530 | get_detailed_timing_section(c, &det_mon->section.d_timings); |
| 531 | } |
| 532 | } |
| 533 | |
| 534 | static void |
| 535 | get_dt_md_section(Uchar * c, struct edid_version *ver, |
| 536 | struct detailed_monitor_section *det_mon) |
| 537 | { |
| 538 | int i; |
| 539 | |
| 540 | for (i = 0; i < DET_TIMINGS; i++) { |
| 541 | fetch_detailed_block(c, ver, det_mon + i); |
| 542 | NEXT_DT_MD_SECTION; |
| 543 | } |
| 544 | } |
| 545 | |
| 546 | static void |
| 547 | copy_string(Uchar * c, Uchar * s) |
| 548 | { |
| 549 | int i; |
| 550 | |
| 551 | c = c + 5; |
| 552 | for (i = 0; (i < 13 && *c != 0x0A); i++) |
| 553 | *(s++) = *(c++); |
| 554 | *s = 0; |
| 555 | while (i-- && (*--s == 0x20)) |
| 556 | *s = 0; |
| 557 | } |
| 558 | |
| 559 | static void |
| 560 | get_dst_timing_section(Uchar * c, struct std_timings *t, struct edid_version *v) |
| 561 | { |
| 562 | int j; |
| 563 | |
| 564 | c = c + 5; |
| 565 | for (j = 0; j < 5; j++) { |
| 566 | t[j].hsize = HSIZE1; |
| 567 | VSIZE1(t[j].vsize); |
| 568 | t[j].refresh = REFRESH_R; |
| 569 | t[j].id = STD_TIMING_ID; |
| 570 | NEXT_STD_TIMING; |
| 571 | } |
| 572 | } |
| 573 | |
| 574 | static void |
| 575 | get_monitor_ranges(Uchar * c, struct monitor_ranges *r) |
| 576 | { |
| 577 | r->min_v = MIN_V; |
| 578 | r->max_v = MAX_V; |
| 579 | r->min_h = MIN_H; |
| 580 | r->max_h = MAX_H; |
| 581 | r->max_clock = 0; |
| 582 | if (MAX_CLOCK != 0xff) /* is specified? */ |
| 583 | r->max_clock = MAX_CLOCK * 10 + 5; |
| 584 | if (HAVE_2ND_GTF) { |
| 585 | r->gtf_2nd_f = F_2ND_GTF; |
| 586 | r->gtf_2nd_c = C_2ND_GTF; |
| 587 | r->gtf_2nd_m = M_2ND_GTF; |
| 588 | r->gtf_2nd_k = K_2ND_GTF; |
| 589 | r->gtf_2nd_j = J_2ND_GTF; |
| 590 | } |
| 591 | else { |
| 592 | r->gtf_2nd_f = 0; |
| 593 | } |
| 594 | if (HAVE_CVT) { |
| 595 | r->max_clock_khz = MAX_CLOCK_KHZ; |
| 596 | r->max_clock = r->max_clock_khz / 1000; |
| 597 | r->maxwidth = MAXWIDTH; |
| 598 | r->supported_aspect = SUPPORTED_ASPECT; |
| 599 | r->preferred_aspect = PREFERRED_ASPECT; |
| 600 | r->supported_blanking = SUPPORTED_BLANKING; |
| 601 | r->supported_scaling = SUPPORTED_SCALING; |
| 602 | r->preferred_refresh = PREFERRED_REFRESH; |
| 603 | } |
| 604 | else { |
| 605 | r->max_clock_khz = 0; |
| 606 | } |
| 607 | } |
| 608 | |
| 609 | static void |
| 610 | get_whitepoint_section(Uchar * c, struct whitePoints *wp) |
| 611 | { |
| 612 | wp[0].white_x = WHITEX1; |
| 613 | wp[0].white_y = WHITEY1; |
| 614 | wp[1].white_x = WHITEX2; |
| 615 | wp[1].white_y = WHITEY2; |
| 616 | wp[0].index = WHITE_INDEX1; |
| 617 | wp[1].index = WHITE_INDEX2; |
| 618 | wp[0].white_gamma = WHITE_GAMMA1; |
| 619 | wp[1].white_gamma = WHITE_GAMMA2; |
| 620 | } |
| 621 | |
| 622 | static void |
| 623 | get_detailed_timing_section(Uchar * c, struct detailed_timings *r) |
| 624 | { |
| 625 | r->clock = PIXEL_CLOCK; |
| 626 | r->h_active = H_ACTIVE; |
| 627 | r->h_blanking = H_BLANK; |
| 628 | r->v_active = V_ACTIVE; |
| 629 | r->v_blanking = V_BLANK; |
| 630 | r->h_sync_off = H_SYNC_OFF; |
| 631 | r->h_sync_width = H_SYNC_WIDTH; |
| 632 | r->v_sync_off = V_SYNC_OFF; |
| 633 | r->v_sync_width = V_SYNC_WIDTH; |
| 634 | r->h_size = H_SIZE; |
| 635 | r->v_size = V_SIZE; |
| 636 | r->h_border = H_BORDER; |
| 637 | r->v_border = V_BORDER; |
| 638 | r->interlaced = INTERLACED; |
| 639 | r->stereo = STEREO; |
| 640 | r->stereo_1 = STEREO1; |
| 641 | r->sync = SYNC_T; |
| 642 | r->misc = MISC; |
| 643 | } |
| 644 | |
| 645 | #define MAX_EDID_MINOR 4 |
| 646 | |
| 647 | static Bool |
| 648 | validate_version(int scrnIndex, struct edid_version *r) |
| 649 | { |
| 650 | if (r->version != 1) { |
| 651 | xf86DrvMsg(scrnIndex, X_ERROR, "Unknown EDID version %d\n", r->version); |
| 652 | return FALSE; |
| 653 | } |
| 654 | |
| 655 | if (r->revision > MAX_EDID_MINOR) |
| 656 | xf86DrvMsg(scrnIndex, X_WARNING, |
| 657 | "Assuming version 1.%d is compatible with 1.%d\n", |
| 658 | r->revision, MAX_EDID_MINOR); |
| 659 | |
| 660 | return TRUE; |
| 661 | } |
| 662 | |
| 663 | /* |
| 664 | * Returns true if HDMI, false if definitely not or unknown. |
| 665 | */ |
| 666 | Bool |
| 667 | xf86MonitorIsHDMI(xf86MonPtr mon) |
| 668 | { |
| 669 | int i = 0, version, offset; |
| 670 | char *edid = NULL; |
| 671 | |
| 672 | if (!mon) |
| 673 | return FALSE; |
| 674 | |
| 675 | if (!(mon->flags & EDID_COMPLETE_RAWDATA)) |
| 676 | return FALSE; |
| 677 | |
| 678 | if (!mon->no_sections) |
| 679 | return FALSE; |
| 680 | |
| 681 | edid = (char *) mon->rawData; |
| 682 | if (!edid) |
| 683 | return FALSE; |
| 684 | |
| 685 | /* find the CEA extension block */ |
| 686 | for (i = 1; i <= mon->no_sections; i++) |
| 687 | if (edid[i * 128] == 0x02) |
| 688 | break; |
| 689 | if (i == mon->no_sections + 1) |
| 690 | return FALSE; |
| 691 | edid += (i * 128); |
| 692 | |
| 693 | version = edid[1]; |
| 694 | offset = edid[2]; |
| 695 | if (version < 3 || offset < 4) |
| 696 | return FALSE; |
| 697 | |
| 698 | /* walk the cea data blocks */ |
| 699 | for (i = 4; i < offset; i += (edid[i] & 0x1f) + 1) { |
| 700 | char *x = edid + i; |
| 701 | |
| 702 | /* find a vendor specific block */ |
| 703 | if ((x[0] & 0xe0) >> 5 == 0x03) { |
| 704 | int oui = (x[3] << 16) + (x[2] << 8) + x[1]; |
| 705 | |
| 706 | /* find the HDMI vendor OUI */ |
| 707 | if (oui == 0x000c03) |
| 708 | return TRUE; |
| 709 | } |
| 710 | } |
| 711 | |
| 712 | /* guess it's not HDMI after all */ |
| 713 | return FALSE; |
| 714 | } |