1 /* 2 * Copyright (C) 2010 The Android Open Source Project 3 * Copyright (C) 2012, The Linux Foundation. All rights reserved. 4 * 5 * Not a Contribution, Apache license notifications and license are 6 * retained for attribution purposes only. 7 * 8 * Licensed under the Apache License, Version 2.0 (the "License"); 9 * you may not use this file except in compliance with the License. 10 * You may obtain a copy of the License at 11 * 12 * http://www.apache.org/licenses/LICENSE-2.0 13 * 14 * Unless required by applicable law or agreed to in writing, software 15 * distributed under the License is distributed on an "AS IS" BASIS, 16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 17 * See the License for the specific language governing permissions and 18 * limitations under the License. 19 */ 20 21 #define DEBUG 0 22 #include <ctype.h> 23 #include <fcntl.h> 24 #include <media/IAudioPolicyService.h> 25 #include <media/AudioSystem.h> 26 #include <utils/threads.h> 27 #include <utils/Errors.h> 28 #include <utils/Log.h> 29 30 #include <linux/msm_mdp.h> 31 #include <linux/fb.h> 32 #include <sys/ioctl.h> 33 #include <sys/poll.h> 34 #include <sys/resource.h> 35 #include <cutils/properties.h> 36 #include "hwc_utils.h" 37 #include "external.h" 38 #include "overlayUtils.h" 39 #include "overlay.h" 40 41 using namespace android; 42 43 namespace qhwc { 44 45 #define MAX_FRAME_BUFFER_NAME_SIZE (80) 46 #define MAX_DISPLAY_DEVICES (3) 47 48 49 const char* msmFbDevicePath[] = { "/dev/graphics/fb1", 50 "/dev/graphics/fb2"}; 51 52 /* 53 * Updates extDeviceFbIndex Array with the correct frame buffer indices 54 * of avaiable external devices 55 * 56 */ 57 void ExternalDisplay::updateExtDispDevFbIndex() 58 { 59 FILE *displayDeviceFP = NULL; 60 char fbType[MAX_FRAME_BUFFER_NAME_SIZE]; 61 char msmFbTypePath[MAX_FRAME_BUFFER_NAME_SIZE]; 62 63 for(int j = 1; j < MAX_DISPLAY_DEVICES; j++) { 64 sprintf (msmFbTypePath,"/sys/class/graphics/fb%d/msm_fb_type", j); 65 displayDeviceFP = fopen(msmFbTypePath, "r"); 66 if(displayDeviceFP){ 67 fread(fbType, sizeof(char), MAX_FRAME_BUFFER_NAME_SIZE, 68 displayDeviceFP); 69 if(strncmp(fbType, "dtv panel", strlen("dtv panel")) == 0){ 70 ALOGD_IF(DEBUG,"hdmi framebuffer index is %d",j); 71 mHdmiFbNum = j; 72 } else if(strncmp(fbType, "writeback panel", 73 strlen("writeback panel")) == 0){ 74 ALOGD_IF(DEBUG,"wfd framebuffer index is %d",j); 75 mWfdFbNum = j; 76 } 77 fclose(displayDeviceFP); 78 } 79 } 80 ALOGD_IF(DEBUG,"%s: mHdmiFbNum: %d mWfdFbNum: %d ",__FUNCTION__, 81 mHdmiFbNum, mWfdFbNum); 82 } 83 84 int ExternalDisplay::configureHDMIDisplay() { 85 openFrameBuffer(mHdmiFbNum); 86 if(mFd == -1) 87 return -1; 88 readCEUnderscanInfo(); 89 readResolution(); 90 // TODO: Move this to activate 91 /* Used for changing the resolution 92 * getUserMode will get the preferred 93 * mode set thru adb shell */ 94 int mode = getUserMode(); 95 if (mode == -1) { 96 //Get the best mode and set 97 mode = getBestMode(); 98 } 99 setResolution(mode); 100 setDpyHdmiAttr(); 101 setExternalDisplay(true, mHdmiFbNum); 102 return 0; 103 } 104 105 int ExternalDisplay::configureWFDDisplay() { 106 int ret = 0; 107 if(mConnectedFbNum == mHdmiFbNum) { 108 ALOGE("%s: Cannot process WFD connection while HDMI is active", 109 __FUNCTION__); 110 return -1; 111 } 112 openFrameBuffer(mWfdFbNum); 113 if(mFd == -1) 114 return -1; 115 ret = ioctl(mFd, FBIOGET_VSCREENINFO, &mVInfo); 116 if(ret < 0) { 117 ALOGD("In %s: FBIOGET_VSCREENINFO failed Err Str = %s", __FUNCTION__, 118 strerror(errno)); 119 } 120 setDpyWfdAttr(); 121 setExternalDisplay(true, mWfdFbNum); 122 return 0; 123 } 124 125 int ExternalDisplay::teardownHDMIDisplay() { 126 if(mConnectedFbNum == mHdmiFbNum) { 127 // hdmi offline event..! 128 closeFrameBuffer(); 129 resetInfo(); 130 setExternalDisplay(false); 131 } 132 return 0; 133 } 134 135 int ExternalDisplay::teardownWFDDisplay() { 136 if(mConnectedFbNum == mWfdFbNum) { 137 // wfd offline event..! 138 closeFrameBuffer(); 139 memset(&mVInfo, 0, sizeof(mVInfo)); 140 setExternalDisplay(false); 141 } 142 return 0; 143 } 144 145 void ExternalDisplay::processUEventOnline(const char *str) { 146 const char *s1 = str + strlen("change@/devices/virtual/switch/"); 147 if(!strncmp(s1,"hdmi",strlen(s1))) { 148 // hdmi online event..! 149 configureHDMIDisplay(); 150 // set system property 151 property_set("hw.hdmiON", "1"); 152 }else if(!strncmp(s1,"wfd",strlen(s1))) { 153 // wfd online event..! 154 configureWFDDisplay(); 155 } 156 } 157 158 void ExternalDisplay::processUEventOffline(const char *str) { 159 const char *s1 = str + strlen("change@/devices/virtual/switch/"); 160 if(!strncmp(s1,"hdmi",strlen(s1))) { 161 teardownHDMIDisplay(); 162 // unset system property 163 property_set("hw.hdmiON", "0"); 164 }else if(!strncmp(s1,"wfd",strlen(s1))) { 165 teardownWFDDisplay(); 166 } 167 } 168 169 ExternalDisplay::ExternalDisplay(hwc_context_t* ctx):mFd(-1), 170 mCurrentMode(-1), mConnected(0), mConnectedFbNum(0), mModeCount(0), 171 mUnderscanSupported(false), mHwcContext(ctx), mHdmiFbNum(-1), 172 mWfdFbNum(-1), mExtDpyNum(HWC_DISPLAY_EXTERNAL) 173 { 174 memset(&mVInfo, 0, sizeof(mVInfo)); 175 //Determine the fb index for external display devices. 176 updateExtDispDevFbIndex(); 177 // disable HPD at start, it will be enabled later 178 // when the display powers on 179 // This helps for framework reboot or adb shell stop/start 180 writeHPDOption(0); 181 182 } 183 184 void ExternalDisplay::setEDIDMode(int resMode) { 185 ALOGD_IF(DEBUG,"resMode=%d ", resMode); 186 { 187 Mutex::Autolock lock(mExtDispLock); 188 setExternalDisplay(false); 189 openFrameBuffer(mHdmiFbNum); 190 setResolution(resMode); 191 } 192 setExternalDisplay(true, mHdmiFbNum); 193 } 194 195 void ExternalDisplay::setHPD(uint32_t startEnd) { 196 ALOGD_IF(DEBUG,"HPD enabled=%d", startEnd); 197 writeHPDOption(startEnd); 198 } 199 200 void ExternalDisplay::setActionSafeDimension(int w, int h) { 201 ALOGD_IF(DEBUG,"ActionSafe w=%d h=%d", w, h); 202 Mutex::Autolock lock(mExtDispLock); 203 char actionsafeWidth[PROPERTY_VALUE_MAX]; 204 char actionsafeHeight[PROPERTY_VALUE_MAX]; 205 sprintf(actionsafeWidth, "%d", w); 206 property_set("hw.actionsafe.width", actionsafeWidth); 207 sprintf(actionsafeHeight, "%d", h); 208 property_set("hw.actionsafe.height", actionsafeHeight); 209 setExternalDisplay(true, mHdmiFbNum); 210 } 211 212 int ExternalDisplay::getModeCount() const { 213 ALOGD_IF(DEBUG,"HPD mModeCount=%d", mModeCount); 214 Mutex::Autolock lock(mExtDispLock); 215 return mModeCount; 216 } 217 218 void ExternalDisplay::getEDIDModes(int *out) const { 219 Mutex::Autolock lock(mExtDispLock); 220 for(int i = 0;i < mModeCount;i++) { 221 out[i] = mEDIDModes[i]; 222 } 223 } 224 225 void ExternalDisplay::readCEUnderscanInfo() 226 { 227 int hdmiScanInfoFile = -1; 228 int len = -1; 229 char scanInfo[17]; 230 char *ce_info_str = NULL; 231 const char token[] = ", \n"; 232 int ce_info = -1; 233 char sysFsScanInfoFilePath[128]; 234 sprintf(sysFsScanInfoFilePath, "/sys/devices/virtual/graphics/fb%d/" 235 "scan_info", mHdmiFbNum); 236 237 memset(scanInfo, 0, sizeof(scanInfo)); 238 hdmiScanInfoFile = open(sysFsScanInfoFilePath, O_RDONLY, 0); 239 if (hdmiScanInfoFile < 0) { 240 ALOGD_IF(DEBUG, "%s: scan_info file '%s' not found", 241 __FUNCTION__, sysFsScanInfoFilePath); 242 return; 243 } else { 244 len = read(hdmiScanInfoFile, scanInfo, sizeof(scanInfo)-1); 245 ALOGD("%s: Scan Info string: %s length = %d", 246 __FUNCTION__, scanInfo, len); 247 if (len <= 0) { 248 close(hdmiScanInfoFile); 249 ALOGE("%s: Scan Info file empty '%s'", 250 __FUNCTION__, sysFsScanInfoFilePath); 251 return; 252 } 253 scanInfo[len] = '\0'; /* null terminate the string */ 254 } 255 close(hdmiScanInfoFile); 256 257 /* 258 * The scan_info contains the three fields 259 * PT - preferred video format 260 * IT - video format 261 * CE video format - containing the underscan support information 262 */ 263 264 /* PT */ 265 ce_info_str = strtok(scanInfo, token); 266 if (ce_info_str) { 267 /* IT */ 268 ce_info_str = strtok(NULL, token); 269 if (ce_info_str) { 270 /* CE */ 271 ce_info_str = strtok(NULL, token); 272 if (ce_info_str) 273 ce_info = atoi(ce_info_str); 274 } 275 } 276 277 if (ce_info_str) { 278 // ce_info contains the underscan information 279 if (ce_info == EXT_SCAN_ALWAYS_UNDERSCANED || 280 ce_info == EXT_SCAN_BOTH_SUPPORTED) 281 // if TV supported underscan, then driver will always underscan 282 // hence no need to apply action safe rectangle 283 mUnderscanSupported = true; 284 } else { 285 ALOGE("%s: scan_info string error", __FUNCTION__); 286 } 287 288 // Store underscan support info in a system property 289 const char* prop = (mUnderscanSupported) ? "1" : "0"; 290 property_set("hw.underscan_supported", prop); 291 return; 292 } 293 294 ExternalDisplay::~ExternalDisplay() 295 { 296 closeFrameBuffer(); 297 } 298 299 struct disp_mode_timing_type { 300 int video_format; 301 302 int active_h; 303 int active_v; 304 305 int front_porch_h; 306 int pulse_width_h; 307 int back_porch_h; 308 309 int front_porch_v; 310 int pulse_width_v; 311 int back_porch_v; 312 313 int pixel_freq; 314 bool interlaced; 315 316 void set_info(struct fb_var_screeninfo &info) const; 317 }; 318 319 void disp_mode_timing_type::set_info(struct fb_var_screeninfo &info) const 320 { 321 info.reserved[0] = 0; 322 info.reserved[1] = 0; 323 info.reserved[2] = 0; 324 #ifndef FB_METADATA_VIDEO_INFO_CODE_SUPPORT 325 info.reserved[3] = (info.reserved[3] & 0xFFFF) | (video_format << 16); 326 #endif 327 info.xoffset = 0; 328 info.yoffset = 0; 329 info.xres = active_h; 330 info.yres = active_v; 331 332 info.pixclock = pixel_freq*1000; 333 info.vmode = interlaced ? FB_VMODE_INTERLACED : FB_VMODE_NONINTERLACED; 334 335 info.right_margin = front_porch_h; 336 info.hsync_len = pulse_width_h; 337 info.left_margin = back_porch_h; 338 info.lower_margin = front_porch_v; 339 info.vsync_len = pulse_width_v; 340 info.upper_margin = back_porch_v; 341 } 342 343 /* Video formates supported by the HDMI Standard */ 344 /* Indicates the resolution, pix clock and the aspect ratio */ 345 #define m640x480p60_4_3 1 346 #define m720x480p60_4_3 2 347 #define m720x480p60_16_9 3 348 #define m1280x720p60_16_9 4 349 #define m1920x1080i60_16_9 5 350 #define m1440x480i60_4_3 6 351 #define m1440x480i60_16_9 7 352 #define m1920x1080p60_16_9 16 353 #define m720x576p50_4_3 17 354 #define m720x576p50_16_9 18 355 #define m1280x720p50_16_9 19 356 #define m1440x576i50_4_3 21 357 #define m1440x576i50_16_9 22 358 #define m1920x1080p50_16_9 31 359 #define m1920x1080p24_16_9 32 360 #define m1920x1080p25_16_9 33 361 #define m1920x1080p30_16_9 34 362 363 static struct disp_mode_timing_type supported_video_mode_lut[] = { 364 {m640x480p60_4_3, 640, 480, 16, 96, 48, 10, 2, 33, 25200, false}, 365 {m720x480p60_4_3, 720, 480, 16, 62, 60, 9, 6, 30, 27030, false}, 366 {m720x480p60_16_9, 720, 480, 16, 62, 60, 9, 6, 30, 27030, false}, 367 {m1280x720p60_16_9, 1280, 720, 110, 40, 220, 5, 5, 20, 74250, false}, 368 {m1920x1080i60_16_9, 1920, 540, 88, 44, 148, 2, 5, 5, 74250, false}, 369 {m1440x480i60_4_3, 1440, 240, 38, 124, 114, 4, 3, 15, 27000, true}, 370 {m1440x480i60_16_9, 1440, 240, 38, 124, 114, 4, 3, 15, 27000, true}, 371 {m1920x1080p60_16_9, 1920, 1080, 88, 44, 148, 4, 5, 36, 148500, false}, 372 {m720x576p50_4_3, 720, 576, 12, 64, 68, 5, 5, 39, 27000, false}, 373 {m720x576p50_16_9, 720, 576, 12, 64, 68, 5, 5, 39, 27000, false}, 374 {m1280x720p50_16_9, 1280, 720, 440, 40, 220, 5, 5, 20, 74250, false}, 375 {m1440x576i50_4_3, 1440, 288, 24, 126, 138, 2, 3, 19, 27000, true}, 376 {m1440x576i50_16_9, 1440, 288, 24, 126, 138, 2, 3, 19, 27000, true}, 377 {m1920x1080p50_16_9, 1920, 1080, 528, 44, 148, 4, 5, 36, 148500, false}, 378 {m1920x1080p24_16_9, 1920, 1080, 638, 44, 148, 4, 5, 36, 74250, false}, 379 {m1920x1080p25_16_9, 1920, 1080, 528, 44, 148, 4, 5, 36, 74250, false}, 380 {m1920x1080p30_16_9, 1920, 1080, 88, 44, 148, 4, 5, 36, 74250, false}, 381 }; 382 383 int ExternalDisplay::parseResolution(char* edidStr, int* edidModes) 384 { 385 char delim = ','; 386 int count = 0; 387 char *start, *end; 388 // EDIDs are string delimited by ',' 389 // Ex: 16,4,5,3,32,34,1 390 // Parse this string to get mode(int) 391 start = (char*) edidStr; 392 end = &delim; 393 while(*end == delim) { 394 edidModes[count] = (int) strtol(start, &end, 10); 395 start = end+1; 396 count++; 397 } 398 ALOGD_IF(DEBUG, "In %s: count = %d", __FUNCTION__, count); 399 for (int i = 0; i < count; i++) 400 ALOGD_IF(DEBUG, "Mode[%d] = %d", i, edidModes[i]); 401 return count; 402 } 403 404 bool ExternalDisplay::readResolution() 405 { 406 char sysFsEDIDFilePath[255]; 407 sprintf(sysFsEDIDFilePath , "/sys/devices/virtual/graphics/fb%d/edid_modes", 408 mHdmiFbNum); 409 410 int hdmiEDIDFile = open(sysFsEDIDFilePath, O_RDONLY, 0); 411 int len = -1; 412 413 if (hdmiEDIDFile < 0) { 414 ALOGE("%s: edid_modes file '%s' not found", 415 __FUNCTION__, sysFsEDIDFilePath); 416 return false; 417 } else { 418 len = read(hdmiEDIDFile, mEDIDs, sizeof(mEDIDs)-1); 419 ALOGD_IF(DEBUG, "%s: EDID string: %s length = %d", 420 __FUNCTION__, mEDIDs, len); 421 if ( len <= 0) { 422 ALOGE("%s: edid_modes file empty '%s'", 423 __FUNCTION__, sysFsEDIDFilePath); 424 } 425 else { 426 while (len > 1 && isspace(mEDIDs[len-1])) 427 --len; 428 mEDIDs[len] = 0; 429 } 430 } 431 close(hdmiEDIDFile); 432 if(len > 0) { 433 // Get EDID modes from the EDID strings 434 mModeCount = parseResolution(mEDIDs, mEDIDModes); 435 ALOGD_IF(DEBUG, "%s: mModeCount = %d", __FUNCTION__, 436 mModeCount); 437 } 438 439 return (strlen(mEDIDs) > 0); 440 } 441 442 bool ExternalDisplay::openFrameBuffer(int fbNum) 443 { 444 if (mFd == -1) { 445 mFd = open(msmFbDevicePath[fbNum-1], O_RDWR); 446 if (mFd < 0) 447 ALOGE("%s: %s is not available", __FUNCTION__, 448 msmFbDevicePath[fbNum-1]); 449 if(mHwcContext) { 450 mHwcContext->dpyAttr[mExtDpyNum].fd = mFd; 451 } 452 } 453 return (mFd > 0); 454 } 455 456 bool ExternalDisplay::closeFrameBuffer() 457 { 458 int ret = 0; 459 if(mFd >= 0) { 460 ret = close(mFd); 461 mFd = -1; 462 } 463 if(mHwcContext) { 464 mHwcContext->dpyAttr[mExtDpyNum].fd = mFd; 465 } 466 return (ret == 0); 467 } 468 469 // clears the vinfo, edid, best modes 470 void ExternalDisplay::resetInfo() 471 { 472 memset(&mVInfo, 0, sizeof(mVInfo)); 473 memset(mEDIDs, 0, sizeof(mEDIDs)); 474 memset(mEDIDModes, 0, sizeof(mEDIDModes)); 475 mModeCount = 0; 476 mCurrentMode = -1; 477 mUnderscanSupported = false; 478 // Reset the underscan supported system property 479 const char* prop = "0"; 480 property_set("hw.underscan_supported", prop); 481 } 482 483 int ExternalDisplay::getModeOrder(int mode) 484 { 485 // XXX: We dont support interlaced modes but having 486 // it here for for future 487 switch (mode) { 488 default: 489 case m1440x480i60_4_3: 490 return 1; // 480i 4:3 491 case m1440x480i60_16_9: 492 return 2; // 480i 16:9 493 case m1440x576i50_4_3: 494 return 3; // i576i 4:3 495 case m1440x576i50_16_9: 496 return 4; // 576i 16:9 497 case m640x480p60_4_3: 498 return 5; // 640x480 4:3 499 case m720x480p60_4_3: 500 return 6; // 480p 4:3 501 case m720x480p60_16_9: 502 return 7; // 480p 16:9 503 case m720x576p50_4_3: 504 return 8; // 576p 4:3 505 case m720x576p50_16_9: 506 return 9; // 576p 16:9 507 case m1920x1080i60_16_9: 508 return 10; // 1080i 16:9 509 case m1280x720p50_16_9: 510 return 11; // 720p@50Hz 511 case m1280x720p60_16_9: 512 return 12; // 720p@60Hz 513 case m1920x1080p24_16_9: 514 return 13; //1080p@24Hz 515 case m1920x1080p25_16_9: 516 return 14; //108-p@25Hz 517 case m1920x1080p30_16_9: 518 return 15; //1080p@30Hz 519 case m1920x1080p50_16_9: 520 return 16; //1080p@50Hz 521 case m1920x1080p60_16_9: 522 return 17; //1080p@60Hz 523 } 524 } 525 526 /// Returns the user mode set(if any) using adb shell 527 int ExternalDisplay::getUserMode() { 528 /* Based on the property set the resolution */ 529 char property_value[PROPERTY_VALUE_MAX]; 530 property_get("hw.hdmi.resolution", property_value, "-1"); 531 int mode = atoi(property_value); 532 // We dont support interlaced modes 533 if(isValidMode(mode) && !isInterlacedMode(mode)) { 534 ALOGD_IF(DEBUG, "%s: setting the HDMI mode = %d", __FUNCTION__, mode); 535 return mode; 536 } 537 return -1; 538 } 539 540 // Get the best mode for the current HD TV 541 int ExternalDisplay::getBestMode() { 542 int bestOrder = 0; 543 int bestMode = m640x480p60_4_3; 544 Mutex::Autolock lock(mExtDispLock); 545 // for all the edid read, get the best mode 546 for(int i = 0; i < mModeCount; i++) { 547 int mode = mEDIDModes[i]; 548 int order = getModeOrder(mode); 549 if (order > bestOrder) { 550 bestOrder = order; 551 bestMode = mode; 552 } 553 } 554 return bestMode; 555 } 556 557 inline bool ExternalDisplay::isValidMode(int ID) 558 { 559 bool valid = false; 560 for (int i = 0; i < mModeCount; i++) { 561 if(ID == mEDIDModes[i]) { 562 valid = true; 563 break; 564 } 565 } 566 return valid; 567 } 568 569 // returns true if the mode(ID) is interlaced mode format 570 bool ExternalDisplay::isInterlacedMode(int ID) { 571 bool interlaced = false; 572 switch(ID) { 573 case m1440x480i60_4_3: 574 case m1440x480i60_16_9: 575 case m1440x576i50_4_3: 576 case m1440x576i50_16_9: 577 case m1920x1080i60_16_9: 578 interlaced = true; 579 default: 580 interlaced = false; 581 } 582 return interlaced; 583 } 584 585 void ExternalDisplay::setResolution(int ID) 586 { 587 int ret = 0; 588 ret = ioctl(mFd, FBIOGET_VSCREENINFO, &mVInfo); 589 if(ret < 0) { 590 ALOGD("In %s: FBIOGET_VSCREENINFO failed Err Str = %s", __FUNCTION__, 591 strerror(errno)); 592 } 593 594 ALOGD_IF(DEBUG, "%s: GET Info<ID=%d %dx%d (%d,%d,%d)," 595 "(%d,%d,%d) %dMHz>", __FUNCTION__, 596 mVInfo.reserved[3], mVInfo.xres, mVInfo.yres, 597 mVInfo.right_margin, mVInfo.hsync_len, mVInfo.left_margin, 598 mVInfo.lower_margin, mVInfo.vsync_len, mVInfo.upper_margin, 599 mVInfo.pixclock/1000/1000); 600 //If its a new ID - update var_screeninfo 601 if ((isValidMode(ID)) && mCurrentMode != ID) { 602 const struct disp_mode_timing_type *mode = 603 &supported_video_mode_lut[0]; 604 unsigned count = sizeof(supported_video_mode_lut)/sizeof 605 (*supported_video_mode_lut); 606 for (unsigned int i = 0; i < count; ++i) { 607 const struct disp_mode_timing_type *cur = 608 &supported_video_mode_lut[i]; 609 if (cur->video_format == ID) 610 mode = cur; 611 } 612 mode->set_info(mVInfo); 613 ALOGD_IF(DEBUG, "%s: SET Info<ID=%d => Info<ID=%d %dx %d" 614 "(%d,%d,%d), (%d,%d,%d) %dMHz>", __FUNCTION__, ID, 615 mode->video_format, mVInfo.xres, mVInfo.yres, 616 mVInfo.right_margin, mVInfo.hsync_len, mVInfo.left_margin, 617 mVInfo.lower_margin, mVInfo.vsync_len, mVInfo.upper_margin, 618 mVInfo.pixclock/1000/1000); 619 #ifdef FB_METADATA_VIDEO_INFO_CODE_SUPPORT 620 struct msmfb_metadata metadata; 621 memset(&metadata, 0 , sizeof(metadata)); 622 metadata.op = metadata_op_vic; 623 metadata.data.video_info_code = mode->video_format; 624 if (ioctl(mFd, MSMFB_METADATA_SET, &metadata) == -1) { 625 ALOGD("In %s: MSMFB_METADATA_SET failed Err Str = %s", 626 __FUNCTION__, strerror(errno)); 627 } 628 #endif 629 mVInfo.activate = FB_ACTIVATE_NOW | FB_ACTIVATE_ALL | FB_ACTIVATE_FORCE; 630 ret = ioctl(mFd, FBIOPUT_VSCREENINFO, &mVInfo); 631 if(ret < 0) { 632 ALOGD("In %s: FBIOPUT_VSCREENINFO failed Err Str = %s", 633 __FUNCTION__, strerror(errno)); 634 } 635 mCurrentMode = ID; 636 } 637 } 638 639 void ExternalDisplay::setExternalDisplay(bool connected, int extFbNum) 640 { 641 hwc_context_t* ctx = mHwcContext; 642 if(ctx) { 643 ALOGD_IF(DEBUG, "%s: connected = %d", __FUNCTION__, connected); 644 // Store the external display 645 mConnected = connected; 646 mConnectedFbNum = extFbNum; 647 mHwcContext->dpyAttr[mExtDpyNum].connected = connected; 648 // Update external fb number in Overlay context 649 overlay::Overlay::getInstance()->setExtFbNum(extFbNum); 650 } 651 } 652 653 int ExternalDisplay::getExtFbNum(int &fbNum) { 654 int ret = -1; 655 if(mConnected) { 656 fbNum = mConnectedFbNum; 657 ret = 0; 658 } 659 return ret; 660 } 661 662 bool ExternalDisplay::writeHPDOption(int userOption) const 663 { 664 bool ret = true; 665 char sysFsHPDFilePath[255]; 666 sprintf(sysFsHPDFilePath ,"/sys/devices/virtual/graphics/fb%d/hpd", 667 mHdmiFbNum); 668 int hdmiHPDFile = open(sysFsHPDFilePath,O_RDWR, 0); 669 if (hdmiHPDFile < 0) { 670 ALOGE("%s: state file '%s' not found : ret%d err str: %s", __FUNCTION__, 671 sysFsHPDFilePath, hdmiHPDFile, strerror(errno)); 672 ret = false; 673 } else { 674 int err = -1; 675 ALOGD_IF(DEBUG, "%s: option = %d", __FUNCTION__, userOption); 676 if(userOption) 677 err = write(hdmiHPDFile, "1", 2); 678 else 679 err = write(hdmiHPDFile, "0" , 2); 680 if (err <= 0) { 681 ALOGE("%s: file write failed '%s'", __FUNCTION__, sysFsHPDFilePath); 682 ret = false; 683 } 684 close(hdmiHPDFile); 685 } 686 return ret; 687 } 688 689 void ExternalDisplay::setDpyWfdAttr() { 690 if(mHwcContext) { 691 mHwcContext->dpyAttr[mExtDpyNum].xres = mVInfo.xres; 692 mHwcContext->dpyAttr[mExtDpyNum].yres = mVInfo.yres; 693 mHwcContext->dpyAttr[mExtDpyNum].vsync_period = 694 1000000000l /60; 695 ALOGD_IF(DEBUG,"%s: wfd...connected..!",__FUNCTION__); 696 } 697 } 698 699 void ExternalDisplay::setDpyHdmiAttr() { 700 int width = 0, height = 0, fps = 0; 701 getAttrForMode(width, height, fps); 702 if(mHwcContext) { 703 ALOGD("ExtDisplay setting xres = %d, yres = %d", width, height); 704 mHwcContext->dpyAttr[HWC_DISPLAY_EXTERNAL].xres = width; 705 mHwcContext->dpyAttr[HWC_DISPLAY_EXTERNAL].yres = height; 706 mHwcContext->dpyAttr[HWC_DISPLAY_EXTERNAL].vsync_period = 707 1000000000l / fps; 708 } 709 } 710 711 void ExternalDisplay::getAttrForMode(int& width, int& height, int& fps) { 712 switch (mCurrentMode) { 713 case m640x480p60_4_3: 714 width = 640; 715 height = 480; 716 fps = 60; 717 break; 718 case m720x480p60_4_3: 719 case m720x480p60_16_9: 720 width = 720; 721 height = 480; 722 fps = 60; 723 break; 724 case m720x576p50_4_3: 725 case m720x576p50_16_9: 726 width = 720; 727 height = 576; 728 fps = 50; 729 break; 730 case m1280x720p50_16_9: 731 width = 1280; 732 height = 720; 733 fps = 50; 734 break; 735 case m1280x720p60_16_9: 736 width = 1280; 737 height = 720; 738 fps = 60; 739 break; 740 case m1920x1080p24_16_9: 741 width = 1920; 742 height = 1080; 743 fps = 24; 744 break; 745 case m1920x1080p25_16_9: 746 width = 1920; 747 height = 1080; 748 fps = 25; 749 break; 750 case m1920x1080p30_16_9: 751 width = 1920; 752 height = 1080; 753 fps = 30; 754 break; 755 case m1920x1080p50_16_9: 756 width = 1920; 757 height = 1080; 758 fps = 50; 759 break; 760 case m1920x1080p60_16_9: 761 width = 1920; 762 height = 1080; 763 fps = 60; 764 break; 765 } 766 } 767 768 }; 769
