1 /** @file 2 Read EDID information and parse EDID information. 3 4 Copyright (c) 2008 - 2014, Intel Corporation. All rights reserved.<BR> 5 This program and the accompanying materials 6 are licensed and made available under the terms and conditions of the BSD License 7 which accompanies this distribution. The full text of the license may be found at 8 http://opensource.org/licenses/bsd-license.php 9 10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, 11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. 12 13 **/ 14 15 #include "CirrusLogic5430.h" 16 #include "CirrusLogic5430I2c.h" 17 18 // 19 // EDID block 20 // 21 typedef struct { 22 UINT8 Header[8]; //EDID header "00 FF FF FF FF FF FF 00" 23 UINT16 ManufactureName; //EISA 3-character ID 24 UINT16 ProductCode; //Vendor assigned code 25 UINT32 SerialNumber; //32-bit serial number 26 UINT8 WeekOfManufacture; //Week number 27 UINT8 YearOfManufacture; //Year 28 UINT8 EdidVersion; //EDID Structure Version 29 UINT8 EdidRevision; //EDID Structure Revision 30 UINT8 VideoInputDefinition; 31 UINT8 MaxHorizontalImageSize; //cm 32 UINT8 MaxVerticalImageSize; //cm 33 UINT8 DisplayTransferCharacteristic; 34 UINT8 FeatureSupport; 35 UINT8 RedGreenLowBits; //Rx1 Rx0 Ry1 Ry0 Gx1 Gx0 Gy1Gy0 36 UINT8 BlueWhiteLowBits; //Bx1 Bx0 By1 By0 Wx1 Wx0 Wy1 Wy0 37 UINT8 RedX; //Red-x Bits 9 - 2 38 UINT8 RedY; //Red-y Bits 9 - 2 39 UINT8 GreenX; //Green-x Bits 9 - 2 40 UINT8 GreenY; //Green-y Bits 9 - 2 41 UINT8 BlueX; //Blue-x Bits 9 - 2 42 UINT8 BlueY; //Blue-y Bits 9 - 2 43 UINT8 WhiteX; //White-x Bits 9 - 2 44 UINT8 WhiteY; //White-x Bits 9 - 2 45 UINT8 EstablishedTimings[3]; 46 UINT8 StandardTimingIdentification[16]; 47 UINT8 DetailedTimingDescriptions[72]; 48 UINT8 ExtensionFlag; //Number of (optional) 128-byte EDID extension blocks to follow 49 UINT8 Checksum; 50 } EDID_BLOCK; 51 52 #define EDID_BLOCK_SIZE 128 53 #define VBE_EDID_ESTABLISHED_TIMING_MAX_NUMBER 17 54 55 typedef struct { 56 UINT16 HorizontalResolution; 57 UINT16 VerticalResolution; 58 UINT16 RefreshRate; 59 } EDID_TIMING; 60 61 typedef struct { 62 UINT32 ValidNumber; 63 UINT32 Key[VBE_EDID_ESTABLISHED_TIMING_MAX_NUMBER]; 64 } VALID_EDID_TIMING; 65 66 // 67 // Standard timing defined by VESA EDID 68 // 69 EDID_TIMING mVbeEstablishedEdidTiming[] = { 70 // 71 // Established Timing I 72 // 73 {800, 600, 60}, 74 {800, 600, 56}, 75 {640, 480, 75}, 76 {640, 480, 72}, 77 {640, 480, 67}, 78 {640, 480, 60}, 79 {720, 400, 88}, 80 {720, 400, 70}, 81 // 82 // Established Timing II 83 // 84 {1280, 1024, 75}, 85 {1024, 768, 75}, 86 {1024, 768, 70}, 87 {1024, 768, 60}, 88 {1024, 768, 87}, 89 {832, 624, 75}, 90 {800, 600, 75}, 91 {800, 600, 72}, 92 // 93 // Established Timing III 94 // 95 {1152, 870, 75} 96 }; 97 98 /** 99 Read EDID information from I2C Bus on CirrusLogic. 100 101 @param Private Pointer to CIRRUS_LOGIC_5430_PRIVATE_DATA. 102 @param EdidDataBlock Pointer to EDID data block. 103 @param EdidSize Returned EDID block size. 104 105 @retval EFI_UNSUPPORTED 106 @retval EFI_SUCCESS 107 108 **/ 109 EFI_STATUS 110 ReadEdidData ( 111 CIRRUS_LOGIC_5430_PRIVATE_DATA *Private, 112 UINT8 **EdidDataBlock, 113 UINTN *EdidSize 114 ) 115 { 116 UINTN Index; 117 UINT8 EdidData[EDID_BLOCK_SIZE * 2]; 118 UINT8 *ValidEdid; 119 UINT64 Signature; 120 121 for (Index = 0; Index < EDID_BLOCK_SIZE * 2; Index ++) { 122 I2cReadByte (Private->PciIo, 0xa0, (UINT8)Index, &EdidData[Index]); 123 } 124 125 // 126 // Search for the EDID signature 127 // 128 ValidEdid = &EdidData[0]; 129 Signature = 0x00ffffffffffff00ull; 130 for (Index = 0; Index < EDID_BLOCK_SIZE * 2; Index ++, ValidEdid ++) { 131 if (CompareMem (ValidEdid, &Signature, 8) == 0) { 132 break; 133 } 134 } 135 136 if (Index == 256) { 137 // 138 // No EDID signature found 139 // 140 return EFI_UNSUPPORTED; 141 } 142 143 *EdidDataBlock = AllocateCopyPool ( 144 EDID_BLOCK_SIZE, 145 ValidEdid 146 ); 147 if (*EdidDataBlock == NULL) { 148 return EFI_OUT_OF_RESOURCES; 149 } 150 151 // 152 // Currently only support EDID 1.x 153 // 154 *EdidSize = EDID_BLOCK_SIZE; 155 156 return EFI_SUCCESS; 157 } 158 159 /** 160 Generate a search key for a specified timing data. 161 162 @param EdidTiming Pointer to EDID timing 163 164 @return The 32 bit unique key for search. 165 166 **/ 167 UINT32 168 CalculateEdidKey ( 169 EDID_TIMING *EdidTiming 170 ) 171 { 172 UINT32 Key; 173 174 // 175 // Be sure no conflicts for all standard timing defined by VESA. 176 // 177 Key = (EdidTiming->HorizontalResolution * 2) + EdidTiming->VerticalResolution; 178 return Key; 179 } 180 181 /** 182 Search a specified Timing in all the valid EDID timings. 183 184 @param ValidEdidTiming All valid EDID timing information. 185 @param EdidTiming The Timing to search for. 186 187 @retval TRUE Found. 188 @retval FALSE Not found. 189 190 **/ 191 BOOLEAN 192 SearchEdidTiming ( 193 VALID_EDID_TIMING *ValidEdidTiming, 194 EDID_TIMING *EdidTiming 195 ) 196 { 197 UINT32 Index; 198 UINT32 Key; 199 200 Key = CalculateEdidKey (EdidTiming); 201 202 for (Index = 0; Index < ValidEdidTiming->ValidNumber; Index ++) { 203 if (Key == ValidEdidTiming->Key[Index]) { 204 return TRUE; 205 } 206 } 207 208 return FALSE; 209 } 210 211 /** 212 Parse the Established Timing and Standard Timing in EDID data block. 213 214 @param EdidBuffer Pointer to EDID data block 215 @param ValidEdidTiming Valid EDID timing information 216 217 @retval TRUE The EDID data is valid. 218 @retval FALSE The EDID data is invalid. 219 220 **/ 221 BOOLEAN 222 ParseEdidData ( 223 UINT8 *EdidBuffer, 224 VALID_EDID_TIMING *ValidEdidTiming 225 ) 226 { 227 UINT8 CheckSum; 228 UINT32 Index; 229 UINT32 ValidNumber; 230 UINT32 TimingBits; 231 UINT8 *BufferIndex; 232 UINT16 HorizontalResolution; 233 UINT16 VerticalResolution; 234 UINT8 AspectRatio; 235 UINT8 RefreshRate; 236 EDID_TIMING TempTiming; 237 EDID_BLOCK *EdidDataBlock; 238 239 EdidDataBlock = (EDID_BLOCK *) EdidBuffer; 240 241 // 242 // Check the checksum of EDID data 243 // 244 CheckSum = 0; 245 for (Index = 0; Index < EDID_BLOCK_SIZE; Index ++) { 246 CheckSum = (UINT8) (CheckSum + EdidBuffer[Index]); 247 } 248 if (CheckSum != 0) { 249 return FALSE; 250 } 251 252 ValidNumber = 0; 253 SetMem (ValidEdidTiming, sizeof (VALID_EDID_TIMING), 0); 254 255 if ((EdidDataBlock->EstablishedTimings[0] != 0) || 256 (EdidDataBlock->EstablishedTimings[1] != 0) || 257 (EdidDataBlock->EstablishedTimings[2] != 0) 258 ) { 259 // 260 // Established timing data 261 // 262 TimingBits = EdidDataBlock->EstablishedTimings[0] | 263 (EdidDataBlock->EstablishedTimings[1] << 8) | 264 ((EdidDataBlock->EstablishedTimings[2] & 0x80) << 9) ; 265 for (Index = 0; Index < VBE_EDID_ESTABLISHED_TIMING_MAX_NUMBER; Index ++) { 266 if (TimingBits & 0x1) { 267 ValidEdidTiming->Key[ValidNumber] = CalculateEdidKey (&mVbeEstablishedEdidTiming[Index]); 268 ValidNumber ++; 269 } 270 TimingBits = TimingBits >> 1; 271 } 272 } else { 273 // 274 // If no Established timing data, read the standard timing data 275 // 276 BufferIndex = &EdidDataBlock->StandardTimingIdentification[0]; 277 for (Index = 0; Index < 8; Index ++) { 278 if ((BufferIndex[0] != 0x1) && (BufferIndex[1] != 0x1)){ 279 // 280 // A valid Standard Timing 281 // 282 HorizontalResolution = (UINT16) (BufferIndex[0] * 8 + 248); 283 AspectRatio = (UINT8) (BufferIndex[1] >> 6); 284 switch (AspectRatio) { 285 case 0: 286 VerticalResolution = (UINT16) (HorizontalResolution / 16 * 10); 287 break; 288 case 1: 289 VerticalResolution = (UINT16) (HorizontalResolution / 4 * 3); 290 break; 291 case 2: 292 VerticalResolution = (UINT16) (HorizontalResolution / 5 * 4); 293 break; 294 case 3: 295 VerticalResolution = (UINT16) (HorizontalResolution / 16 * 9); 296 break; 297 default: 298 VerticalResolution = (UINT16) (HorizontalResolution / 4 * 3); 299 break; 300 } 301 RefreshRate = (UINT8) ((BufferIndex[1] & 0x1f) + 60); 302 TempTiming.HorizontalResolution = HorizontalResolution; 303 TempTiming.VerticalResolution = VerticalResolution; 304 TempTiming.RefreshRate = RefreshRate; 305 ValidEdidTiming->Key[ValidNumber] = CalculateEdidKey (&TempTiming); 306 ValidNumber ++; 307 } 308 BufferIndex += 2; 309 } 310 } 311 312 ValidEdidTiming->ValidNumber = ValidNumber; 313 return TRUE; 314 } 315 316 /** 317 Construct the valid video modes for CirrusLogic5430. 318 319 **/ 320 EFI_STATUS 321 CirrusLogic5430VideoModeSetup ( 322 CIRRUS_LOGIC_5430_PRIVATE_DATA *Private 323 ) 324 { 325 EFI_STATUS Status; 326 UINT32 Index; 327 BOOLEAN EdidFound; 328 EFI_EDID_OVERRIDE_PROTOCOL *EdidOverride; 329 UINT32 EdidAttributes; 330 BOOLEAN EdidOverrideFound; 331 UINTN EdidOverrideDataSize; 332 UINT8 *EdidOverrideDataBlock; 333 UINTN EdidDiscoveredDataSize; 334 UINT8 *EdidDiscoveredDataBlock; 335 UINTN EdidActiveDataSize; 336 UINT8 *EdidActiveDataBlock; 337 VALID_EDID_TIMING ValidEdidTiming; 338 UINT32 ValidModeCount; 339 CIRRUS_LOGIC_5430_MODE_DATA *ModeData; 340 BOOLEAN TimingMatch; 341 CIRRUS_LOGIC_5430_VIDEO_MODES *VideoMode; 342 EDID_TIMING TempTiming; 343 344 // 345 // setup EDID information 346 // 347 Private->EdidDiscovered.Edid = NULL; 348 Private->EdidDiscovered.SizeOfEdid = 0; 349 Private->EdidActive.Edid = NULL; 350 Private->EdidActive.SizeOfEdid = 0; 351 352 EdidFound = FALSE; 353 EdidOverrideFound = FALSE; 354 EdidAttributes = 0xff; 355 EdidOverrideDataSize = 0; 356 EdidOverrideDataBlock = NULL; 357 EdidActiveDataSize = 0; 358 EdidActiveDataBlock = NULL; 359 EdidDiscoveredDataBlock = NULL; 360 361 // 362 // Find EDID Override protocol firstly, this protocol is installed by platform if needed. 363 // 364 Status = gBS->LocateProtocol ( 365 &gEfiEdidOverrideProtocolGuid, 366 NULL, 367 (VOID **) &EdidOverride 368 ); 369 if (!EFI_ERROR (Status)) { 370 // 371 // Allocate double size of VESA_BIOS_EXTENSIONS_EDID_BLOCK_SIZE to avoid overflow 372 // 373 EdidOverrideDataBlock = AllocatePool (EDID_BLOCK_SIZE * 2); 374 if (NULL == EdidOverrideDataBlock) { 375 Status = EFI_OUT_OF_RESOURCES; 376 goto Done; 377 } 378 379 Status = EdidOverride->GetEdid ( 380 EdidOverride, 381 Private->Handle, 382 &EdidAttributes, 383 &EdidOverrideDataSize, 384 (UINT8 **) &EdidOverrideDataBlock 385 ); 386 if (!EFI_ERROR (Status) && 387 EdidAttributes == 0 && 388 EdidOverrideDataSize != 0) { 389 // 390 // Succeeded to get EDID Override Data 391 // 392 EdidOverrideFound = TRUE; 393 } 394 } 395 396 if (EdidOverrideFound != TRUE || EdidAttributes == EFI_EDID_OVERRIDE_DONT_OVERRIDE) { 397 // 398 // If EDID Override data doesn't exist or EFI_EDID_OVERRIDE_DONT_OVERRIDE returned, 399 // read EDID information through I2C Bus 400 // 401 if (ReadEdidData (Private, &EdidDiscoveredDataBlock, &EdidDiscoveredDataSize) == EFI_SUCCESS) { 402 Private->EdidDiscovered.SizeOfEdid = (UINT32) EdidDiscoveredDataSize; 403 Private->EdidDiscovered.Edid = (UINT8 *) AllocateCopyPool ( 404 EdidDiscoveredDataSize, 405 EdidDiscoveredDataBlock 406 ); 407 408 if (NULL == Private->EdidDiscovered.Edid) { 409 Status = EFI_OUT_OF_RESOURCES; 410 goto Done; 411 } 412 413 EdidActiveDataSize = Private->EdidDiscovered.SizeOfEdid; 414 EdidActiveDataBlock = Private->EdidDiscovered.Edid; 415 416 EdidFound = TRUE; 417 } 418 } 419 420 if (EdidFound != TRUE && EdidOverrideFound == TRUE) { 421 EdidActiveDataSize = EdidOverrideDataSize; 422 EdidActiveDataBlock = EdidOverrideDataBlock; 423 EdidFound = TRUE; 424 } 425 426 if (EdidFound == TRUE) { 427 // 428 // Parse EDID data structure to retrieve modes supported by monitor 429 // 430 if (ParseEdidData ((UINT8 *) EdidActiveDataBlock, &ValidEdidTiming) == TRUE) { 431 // 432 // Copy EDID Override Data to EDID Active Data 433 // 434 Private->EdidActive.SizeOfEdid = (UINT32) EdidActiveDataSize; 435 Private->EdidActive.Edid = (UINT8 *) AllocateCopyPool ( 436 EdidActiveDataSize, 437 EdidActiveDataBlock 438 ); 439 if (NULL == Private->EdidActive.Edid) { 440 Status = EFI_OUT_OF_RESOURCES; 441 goto Done; 442 } 443 } 444 } else { 445 Private->EdidActive.SizeOfEdid = 0; 446 Private->EdidActive.Edid = NULL; 447 EdidFound = FALSE; 448 } 449 450 if (EdidFound) { 451 // 452 // Initialize the private mode data with the supported modes. 453 // 454 ValidModeCount = 0; 455 ModeData = &Private->ModeData[0]; 456 VideoMode = &CirrusLogic5430VideoModes[0]; 457 for (Index = 0; Index < CIRRUS_LOGIC_5430_MODE_COUNT; Index++) { 458 459 TimingMatch = TRUE; 460 461 // 462 // Check whether match with CirrusLogic5430 video mode 463 // 464 TempTiming.HorizontalResolution = (UINT16) VideoMode->Width; 465 TempTiming.VerticalResolution = (UINT16) VideoMode->Height; 466 TempTiming.RefreshRate = (UINT16) VideoMode->RefreshRate; 467 if (SearchEdidTiming (&ValidEdidTiming, &TempTiming) != TRUE) { 468 TimingMatch = FALSE; 469 } 470 471 // 472 // Not export Mode 0x0 as GOP mode, this is not defined in spec. 473 // 474 if ((VideoMode->Width == 0) || (VideoMode->Height == 0)) { 475 TimingMatch = FALSE; 476 } 477 478 if (TimingMatch) { 479 ModeData->ModeNumber = Index; 480 ModeData->HorizontalResolution = VideoMode->Width; 481 ModeData->VerticalResolution = VideoMode->Height; 482 ModeData->ColorDepth = VideoMode->ColorDepth; 483 ModeData->RefreshRate = VideoMode->RefreshRate; 484 485 ModeData ++; 486 ValidModeCount ++; 487 } 488 489 VideoMode ++; 490 } 491 492 Private->MaxMode = ValidModeCount; 493 494 } else { 495 // 496 // If EDID information wasn't found 497 // 498 ModeData = &Private->ModeData[0]; 499 VideoMode = &CirrusLogic5430VideoModes[0]; 500 for (Index = 0; Index < CIRRUS_LOGIC_5430_MODE_COUNT; Index ++) { 501 ModeData->ModeNumber = Index; 502 ModeData->HorizontalResolution = VideoMode->Width; 503 ModeData->VerticalResolution = VideoMode->Height; 504 ModeData->ColorDepth = VideoMode->ColorDepth; 505 ModeData->RefreshRate = VideoMode->RefreshRate; 506 507 ModeData ++ ; 508 VideoMode ++; 509 } 510 Private->MaxMode = CIRRUS_LOGIC_5430_MODE_COUNT; 511 } 512 513 if (EdidOverrideDataBlock != NULL) { 514 FreePool (EdidOverrideDataBlock); 515 } 516 517 return EFI_SUCCESS; 518 519 Done: 520 if (EdidOverrideDataBlock != NULL) { 521 FreePool (EdidOverrideDataBlock); 522 } 523 if (Private->EdidDiscovered.Edid != NULL) { 524 FreePool (Private->EdidDiscovered.Edid); 525 } 526 if (Private->EdidDiscovered.Edid != NULL) { 527 FreePool (Private->EdidActive.Edid); 528 } 529 530 return EFI_DEVICE_ERROR; 531 } 532
