1 /* 2 * Copyright (c) 2014 - 2016, The Linux Foundation. All rights reserved. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions are 6 * met: 7 * * Redistributions of source code must retain the above copyright 8 * notice, this list of conditions and the following disclaimer. 9 * * Redistributions in binary form must reproduce the above 10 * copyright notice, this list of conditions and the following 11 * disclaimer in the documentation and/or other materials provided 12 * with the distribution. 13 * * Neither the name of The Linux Foundation nor the names of its 14 * contributors may be used to endorse or promote products derived 15 * from this software without specific prior written permission. 16 * 17 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED 18 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 19 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS 21 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 22 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 23 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 24 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 25 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 26 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN 27 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 */ 29 30 #include <cutils/properties.h> 31 #include <sync/sync.h> 32 #include <utils/constants.h> 33 #include <utils/debug.h> 34 #include <stdarg.h> 35 #include <sys/mman.h> 36 37 #include <map> 38 #include <string> 39 #include <vector> 40 41 #include "hwc_display_primary.h" 42 #include "hwc_debugger.h" 43 44 #define __CLASS__ "HWCDisplayPrimary" 45 46 namespace sdm { 47 48 int HWCDisplayPrimary::Create(CoreInterface *core_intf, BufferAllocator *buffer_allocator, 49 HWCCallbacks *callbacks, qService::QService *qservice, 50 HWCDisplay **hwc_display) { 51 int status = 0; 52 uint32_t primary_width = 0; 53 uint32_t primary_height = 0; 54 55 HWCDisplay *hwc_display_primary = 56 new HWCDisplayPrimary(core_intf, buffer_allocator, callbacks, qservice); 57 status = hwc_display_primary->Init(); 58 if (status) { 59 delete hwc_display_primary; 60 return status; 61 } 62 63 hwc_display_primary->GetMixerResolution(&primary_width, &primary_height); 64 int width = 0, height = 0; 65 HWCDebugHandler::Get()->GetProperty("sdm.fb_size_width", &width); 66 HWCDebugHandler::Get()->GetProperty("sdm.fb_size_height", &height); 67 if (width > 0 && height > 0) { 68 primary_width = UINT32(width); 69 primary_height = UINT32(height); 70 } 71 72 status = hwc_display_primary->SetFrameBufferResolution(primary_width, primary_height); 73 if (status) { 74 Destroy(hwc_display_primary); 75 return status; 76 } 77 78 *hwc_display = hwc_display_primary; 79 80 return status; 81 } 82 83 void HWCDisplayPrimary::Destroy(HWCDisplay *hwc_display) { 84 hwc_display->Deinit(); 85 delete hwc_display; 86 } 87 88 HWCDisplayPrimary::HWCDisplayPrimary(CoreInterface *core_intf, BufferAllocator *buffer_allocator, 89 HWCCallbacks *callbacks, qService::QService *qservice) 90 : HWCDisplay(core_intf, callbacks, kPrimary, HWC_DISPLAY_PRIMARY, true, qservice, 91 DISPLAY_CLASS_PRIMARY), 92 buffer_allocator_(buffer_allocator), 93 cpu_hint_(NULL) { 94 } 95 96 int HWCDisplayPrimary::Init() { 97 cpu_hint_ = new CPUHint(); 98 if (cpu_hint_->Init(static_cast<HWCDebugHandler *>(HWCDebugHandler::Get())) != kErrorNone) { 99 delete cpu_hint_; 100 cpu_hint_ = NULL; 101 } 102 103 use_metadata_refresh_rate_ = true; 104 int disable_metadata_dynfps = 0; 105 HWCDebugHandler::Get()->GetProperty("persist.metadata_dynfps.disable", &disable_metadata_dynfps); 106 if (disable_metadata_dynfps) { 107 use_metadata_refresh_rate_ = false; 108 } 109 110 int status = HWCDisplay::Init(); 111 if (status) { 112 return status; 113 } 114 color_mode_ = new HWCColorMode(display_intf_); 115 116 return INT(color_mode_->Init()); 117 } 118 119 void HWCDisplayPrimary::ProcessBootAnimCompleted() { 120 uint32_t numBootUpLayers = 0; 121 // TODO(user): Remove this hack 122 123 numBootUpLayers = static_cast<uint32_t>(Debug::GetBootAnimLayerCount()); 124 125 if (numBootUpLayers == 0) { 126 numBootUpLayers = 2; 127 } 128 /* All other checks namely "init.svc.bootanim" or 129 * HWC_GEOMETRY_CHANGED fail in correctly identifying the 130 * exact bootup transition to homescreen 131 */ 132 char property[PROPERTY_VALUE_MAX]; 133 bool isEncrypted = false; 134 bool main_class_services_started = false; 135 property_get("ro.crypto.state", property, "unencrypted"); 136 if (!strcmp(property, "encrypted")) { 137 property_get("ro.crypto.type", property, "block"); 138 if (!strcmp(property, "block")) { 139 isEncrypted = true; 140 property_get("vold.decrypt", property, ""); 141 if (!strcmp(property, "trigger_restart_framework")) { 142 main_class_services_started = true; 143 } 144 } 145 } 146 147 if ((!isEncrypted || (isEncrypted && main_class_services_started)) && 148 (layer_set_.size() > numBootUpLayers)) { 149 DLOGI("Applying default mode"); 150 boot_animation_completed_ = true; 151 // Applying default mode after bootanimation is finished And 152 // If Data is Encrypted, it is ready for access. 153 if (display_intf_) 154 display_intf_->ApplyDefaultDisplayMode(); 155 } 156 } 157 158 HWC2::Error HWCDisplayPrimary::Validate(uint32_t *out_num_types, uint32_t *out_num_requests) { 159 auto status = HWC2::Error::None; 160 DisplayError error = kErrorNone; 161 162 if (display_paused_) { 163 MarkLayersForGPUBypass(); 164 return status; 165 } 166 167 if (color_tranform_failed_) { 168 // Must fall back to client composition 169 MarkLayersForClientComposition(); 170 } 171 172 // Fill in the remaining blanks in the layers and add them to the SDM layerstack 173 BuildLayerStack(); 174 // Checks and replaces layer stack for solid fill 175 SolidFillPrepare(); 176 177 bool pending_output_dump = dump_frame_count_ && dump_output_to_file_; 178 179 if (frame_capture_buffer_queued_ || pending_output_dump) { 180 // RHS values were set in FrameCaptureAsync() called from a binder thread. They are picked up 181 // here in a subsequent draw round. 182 layer_stack_.output_buffer = &output_buffer_; 183 layer_stack_.flags.post_processed_output = post_processed_output_; 184 } 185 186 bool one_updating_layer = SingleLayerUpdating(); 187 ToggleCPUHint(one_updating_layer); 188 189 uint32_t refresh_rate = GetOptimalRefreshRate(one_updating_layer); 190 if (current_refresh_rate_ != refresh_rate) { 191 error = display_intf_->SetRefreshRate(refresh_rate); 192 } 193 194 if (error == kErrorNone) { 195 // On success, set current refresh rate to new refresh rate 196 current_refresh_rate_ = refresh_rate; 197 } 198 199 if (handle_idle_timeout_) { 200 handle_idle_timeout_ = false; 201 } 202 203 if (layer_set_.empty()) { 204 flush_ = true; 205 return status; 206 } 207 208 status = PrepareLayerStack(out_num_types, out_num_requests); 209 return status; 210 } 211 212 HWC2::Error HWCDisplayPrimary::Present(int32_t *out_retire_fence) { 213 auto status = HWC2::Error::None; 214 if (display_paused_) { 215 // TODO(user): From old HWC implementation 216 // If we do not handle the frame set retireFenceFd to outbufAcquireFenceFd 217 // Revisit this when validating display_paused 218 DisplayError error = display_intf_->Flush(); 219 if (error != kErrorNone) { 220 DLOGE("Flush failed. Error = %d", error); 221 } 222 } else { 223 status = HWCDisplay::CommitLayerStack(); 224 if (status == HWC2::Error::None) { 225 HandleFrameOutput(); 226 SolidFillCommit(); 227 status = HWCDisplay::PostCommitLayerStack(out_retire_fence); 228 } 229 } 230 231 CloseAcquireFds(); 232 return status; 233 } 234 235 HWC2::Error HWCDisplayPrimary::GetColorModes(uint32_t *out_num_modes, 236 android_color_mode_t *out_modes) { 237 if (out_modes == nullptr) { 238 *out_num_modes = color_mode_->GetColorModeCount(); 239 } else { 240 color_mode_->GetColorModes(out_num_modes, out_modes); 241 } 242 243 return HWC2::Error::None; 244 } 245 246 HWC2::Error HWCDisplayPrimary::SetColorMode(android_color_mode_t mode) { 247 auto status = color_mode_->SetColorMode(mode); 248 if (status != HWC2::Error::None) { 249 DLOGE("failed for mode = %d", mode); 250 return status; 251 } 252 253 callbacks_->Refresh(HWC_DISPLAY_PRIMARY); 254 255 return status; 256 } 257 258 HWC2::Error HWCDisplayPrimary::SetColorTransform(const float *matrix, 259 android_color_transform_t hint) { 260 if (!matrix) { 261 return HWC2::Error::BadParameter; 262 } 263 264 auto status = color_mode_->SetColorTransform(matrix, hint); 265 if (status != HWC2::Error::None) { 266 DLOGE("failed for hint = %d", hint); 267 color_tranform_failed_ = true; 268 return status; 269 } 270 271 callbacks_->Refresh(HWC_DISPLAY_PRIMARY); 272 color_tranform_failed_ = false; 273 274 return status; 275 } 276 277 int HWCDisplayPrimary::Perform(uint32_t operation, ...) { 278 va_list args; 279 va_start(args, operation); 280 int val = 0; 281 LayerRect *rect = NULL; 282 283 switch (operation) { 284 case SET_METADATA_DYN_REFRESH_RATE: 285 val = va_arg(args, int32_t); 286 SetMetaDataRefreshRateFlag(val); 287 break; 288 case SET_BINDER_DYN_REFRESH_RATE: 289 val = va_arg(args, int32_t); 290 ForceRefreshRate(UINT32(val)); 291 break; 292 case SET_DISPLAY_MODE: 293 val = va_arg(args, int32_t); 294 SetDisplayMode(UINT32(val)); 295 break; 296 case SET_QDCM_SOLID_FILL_INFO: 297 val = va_arg(args, int32_t); 298 SetQDCMSolidFillInfo(true, UINT32(val)); 299 break; 300 case UNSET_QDCM_SOLID_FILL_INFO: 301 val = va_arg(args, int32_t); 302 SetQDCMSolidFillInfo(false, UINT32(val)); 303 break; 304 case SET_QDCM_SOLID_FILL_RECT: 305 rect = va_arg(args, LayerRect*); 306 solid_fill_rect_ = *rect; 307 break; 308 default: 309 DLOGW("Invalid operation %d", operation); 310 va_end(args); 311 return -EINVAL; 312 } 313 va_end(args); 314 315 return 0; 316 } 317 318 DisplayError HWCDisplayPrimary::SetDisplayMode(uint32_t mode) { 319 DisplayError error = kErrorNone; 320 321 if (display_intf_) { 322 error = display_intf_->SetDisplayMode(mode); 323 } 324 325 return error; 326 } 327 328 void HWCDisplayPrimary::SetMetaDataRefreshRateFlag(bool enable) { 329 int disable_metadata_dynfps = 0; 330 331 HWCDebugHandler::Get()->GetProperty("persist.metadata_dynfps.disable", &disable_metadata_dynfps); 332 if (disable_metadata_dynfps) { 333 return; 334 } 335 use_metadata_refresh_rate_ = enable; 336 } 337 338 void HWCDisplayPrimary::SetQDCMSolidFillInfo(bool enable, uint32_t color) { 339 solid_fill_enable_ = enable; 340 solid_fill_color_ = color; 341 } 342 343 void HWCDisplayPrimary::ToggleCPUHint(bool set) { 344 if (!cpu_hint_) { 345 return; 346 } 347 348 if (set) { 349 cpu_hint_->Set(); 350 } else { 351 cpu_hint_->Reset(); 352 } 353 } 354 355 void HWCDisplayPrimary::SetSecureDisplay(bool secure_display_active) { 356 if (secure_display_active_ != secure_display_active) { 357 // Skip Prepare and call Flush for null commit 358 DLOGI("SecureDisplay state changed from %d to %d Needs Flush!!", secure_display_active_, 359 secure_display_active); 360 secure_display_active_ = secure_display_active; 361 skip_prepare_ = true; 362 } 363 return; 364 } 365 366 void HWCDisplayPrimary::ForceRefreshRate(uint32_t refresh_rate) { 367 if ((refresh_rate && (refresh_rate < min_refresh_rate_ || refresh_rate > max_refresh_rate_)) || 368 force_refresh_rate_ == refresh_rate) { 369 // Cannot honor force refresh rate, as its beyond the range or new request is same 370 return; 371 } 372 373 force_refresh_rate_ = refresh_rate; 374 375 callbacks_->Refresh(HWC_DISPLAY_PRIMARY); 376 377 return; 378 } 379 380 uint32_t HWCDisplayPrimary::GetOptimalRefreshRate(bool one_updating_layer) { 381 if (force_refresh_rate_) { 382 return force_refresh_rate_; 383 } else if (handle_idle_timeout_) { 384 return min_refresh_rate_; 385 } else if (use_metadata_refresh_rate_ && one_updating_layer && metadata_refresh_rate_) { 386 return metadata_refresh_rate_; 387 } 388 389 return max_refresh_rate_; 390 } 391 392 DisplayError HWCDisplayPrimary::Refresh() { 393 DisplayError error = kErrorNone; 394 395 callbacks_->Refresh(HWC_DISPLAY_PRIMARY); 396 handle_idle_timeout_ = true; 397 398 return error; 399 } 400 401 void HWCDisplayPrimary::SetIdleTimeoutMs(uint32_t timeout_ms) { 402 display_intf_->SetIdleTimeoutMs(timeout_ms); 403 } 404 405 static void SetLayerBuffer(const BufferInfo &output_buffer_info, LayerBuffer *output_buffer) { 406 const BufferConfig& buffer_config = output_buffer_info.buffer_config; 407 const AllocatedBufferInfo &alloc_buffer_info = output_buffer_info.alloc_buffer_info; 408 409 output_buffer->width = alloc_buffer_info.aligned_width; 410 output_buffer->height = alloc_buffer_info.aligned_height; 411 output_buffer->unaligned_width = buffer_config.width; 412 output_buffer->unaligned_height = buffer_config.height; 413 output_buffer->format = buffer_config.format; 414 output_buffer->planes[0].fd = alloc_buffer_info.fd; 415 output_buffer->planes[0].stride = alloc_buffer_info.stride; 416 } 417 418 void HWCDisplayPrimary::HandleFrameOutput() { 419 if (frame_capture_buffer_queued_) { 420 HandleFrameCapture(); 421 } else if (dump_output_to_file_) { 422 HandleFrameDump(); 423 } 424 } 425 426 void HWCDisplayPrimary::HandleFrameCapture() { 427 if (output_buffer_.release_fence_fd >= 0) { 428 frame_capture_status_ = sync_wait(output_buffer_.release_fence_fd, 1000); 429 ::close(output_buffer_.release_fence_fd); 430 output_buffer_.release_fence_fd = -1; 431 } 432 433 frame_capture_buffer_queued_ = false; 434 post_processed_output_ = false; 435 output_buffer_ = {}; 436 } 437 438 void HWCDisplayPrimary::HandleFrameDump() { 439 if (dump_frame_count_ && output_buffer_.release_fence_fd >= 0) { 440 int ret = sync_wait(output_buffer_.release_fence_fd, 1000); 441 ::close(output_buffer_.release_fence_fd); 442 output_buffer_.release_fence_fd = -1; 443 if (ret < 0) { 444 DLOGE("sync_wait error errno = %d, desc = %s", errno, strerror(errno)); 445 } else { 446 DumpOutputBuffer(output_buffer_info_, output_buffer_base_, layer_stack_.retire_fence_fd); 447 } 448 } 449 450 if (0 == dump_frame_count_) { 451 dump_output_to_file_ = false; 452 // Unmap and Free buffer 453 if (munmap(output_buffer_base_, output_buffer_info_.alloc_buffer_info.size) != 0) { 454 DLOGE("unmap failed with err %d", errno); 455 } 456 if (buffer_allocator_->FreeBuffer(&output_buffer_info_) != 0) { 457 DLOGE("FreeBuffer failed"); 458 } 459 460 post_processed_output_ = false; 461 output_buffer_ = {}; 462 output_buffer_info_ = {}; 463 output_buffer_base_ = nullptr; 464 } 465 } 466 467 void HWCDisplayPrimary::SetFrameDumpConfig(uint32_t count, uint32_t bit_mask_layer_type) { 468 HWCDisplay::SetFrameDumpConfig(count, bit_mask_layer_type); 469 dump_output_to_file_ = bit_mask_layer_type & (1 << OUTPUT_LAYER_DUMP); 470 DLOGI("output_layer_dump_enable %d", dump_output_to_file_); 471 472 if (!count || !dump_output_to_file_) { 473 return; 474 } 475 476 // Allocate and map output buffer 477 output_buffer_info_ = {}; 478 // Since we dump DSPP output use Panel resolution. 479 GetPanelResolution(&output_buffer_info_.buffer_config.width, 480 &output_buffer_info_.buffer_config.height); 481 output_buffer_info_.buffer_config.format = kFormatRGB888; 482 output_buffer_info_.buffer_config.buffer_count = 1; 483 if (buffer_allocator_->AllocateBuffer(&output_buffer_info_) != 0) { 484 DLOGE("Buffer allocation failed"); 485 output_buffer_info_ = {}; 486 return; 487 } 488 489 void *buffer = mmap(NULL, output_buffer_info_.alloc_buffer_info.size, PROT_READ | PROT_WRITE, 490 MAP_SHARED, output_buffer_info_.alloc_buffer_info.fd, 0); 491 492 if (buffer == MAP_FAILED) { 493 DLOGE("mmap failed with err %d", errno); 494 buffer_allocator_->FreeBuffer(&output_buffer_info_); 495 output_buffer_info_ = {}; 496 return; 497 } 498 499 output_buffer_base_ = buffer; 500 post_processed_output_ = true; 501 DisablePartialUpdateOneFrame(); 502 } 503 504 int HWCDisplayPrimary::FrameCaptureAsync(const BufferInfo &output_buffer_info, 505 bool post_processed_output) { 506 // Note: This function is called in context of a binder thread and a lock is already held 507 if (output_buffer_info.alloc_buffer_info.fd < 0) { 508 DLOGE("Invalid fd %d", output_buffer_info.alloc_buffer_info.fd); 509 return -1; 510 } 511 512 auto panel_width = 0u; 513 auto panel_height = 0u; 514 auto fb_width = 0u; 515 auto fb_height = 0u; 516 517 GetPanelResolution(&panel_width, &panel_height); 518 GetFrameBufferResolution(&fb_width, &fb_height); 519 520 if (post_processed_output && (output_buffer_info_.buffer_config.width < panel_width || 521 output_buffer_info_.buffer_config.height < panel_height)) { 522 DLOGE("Buffer dimensions should not be less than panel resolution"); 523 return -1; 524 } else if (!post_processed_output && (output_buffer_info_.buffer_config.width < fb_width || 525 output_buffer_info_.buffer_config.height < fb_height)) { 526 DLOGE("Buffer dimensions should not be less than FB resolution"); 527 return -1; 528 } 529 530 SetLayerBuffer(output_buffer_info, &output_buffer_); 531 post_processed_output_ = post_processed_output; 532 frame_capture_buffer_queued_ = true; 533 // Status is only cleared on a new call to dump and remains valid otherwise 534 frame_capture_status_ = -EAGAIN; 535 DisablePartialUpdateOneFrame(); 536 537 return 0; 538 } 539 540 DisplayError HWCDisplayPrimary::SetDetailEnhancerConfig 541 (const DisplayDetailEnhancerData &de_data) { 542 DisplayError error = kErrorNotSupported; 543 544 if (display_intf_) { 545 error = display_intf_->SetDetailEnhancerData(de_data); 546 } 547 return error; 548 } 549 550 DisplayError HWCDisplayPrimary::ControlPartialUpdate(bool enable, uint32_t *pending) { 551 DisplayError error = kErrorNone; 552 553 if (display_intf_) { 554 error = display_intf_->ControlPartialUpdate(enable, pending); 555 } 556 557 return error; 558 } 559 560 DisplayError HWCDisplayPrimary::DisablePartialUpdateOneFrame() { 561 DisplayError error = kErrorNone; 562 563 if (display_intf_) { 564 error = display_intf_->DisablePartialUpdateOneFrame(); 565 } 566 567 return error; 568 } 569 570 571 DisplayError HWCDisplayPrimary::SetMixerResolution(uint32_t width, uint32_t height) { 572 return display_intf_->SetMixerResolution(width, height); 573 } 574 575 DisplayError HWCDisplayPrimary::GetMixerResolution(uint32_t *width, uint32_t *height) { 576 return display_intf_->GetMixerResolution(width, height); 577 } 578 579 } // namespace sdm 580