Home | History | Annotate | Download | only in hwc2 
      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   output_buffer->width = output_buffer_info.buffer_config.width;
    407   output_buffer->height = output_buffer_info.buffer_config.height;
    408   output_buffer->format = output_buffer_info.buffer_config.format;
    409   output_buffer->planes[0].fd = output_buffer_info.alloc_buffer_info.fd;
    410   output_buffer->planes[0].stride = output_buffer_info.alloc_buffer_info.stride;
    411 }
    412 
    413 void HWCDisplayPrimary::HandleFrameOutput() {
    414   if (frame_capture_buffer_queued_) {
    415     HandleFrameCapture();
    416   } else if (dump_output_to_file_) {
    417     HandleFrameDump();
    418   }
    419 }
    420 
    421 void HWCDisplayPrimary::HandleFrameCapture() {
    422   if (output_buffer_.release_fence_fd >= 0) {
    423     frame_capture_status_ = sync_wait(output_buffer_.release_fence_fd, 1000);
    424     ::close(output_buffer_.release_fence_fd);
    425     output_buffer_.release_fence_fd = -1;
    426   }
    427 
    428   frame_capture_buffer_queued_ = false;
    429   post_processed_output_ = false;
    430   output_buffer_ = {};
    431 }
    432 
    433 void HWCDisplayPrimary::HandleFrameDump() {
    434   if (dump_frame_count_ && output_buffer_.release_fence_fd >= 0) {
    435     int ret = sync_wait(output_buffer_.release_fence_fd, 1000);
    436     ::close(output_buffer_.release_fence_fd);
    437     output_buffer_.release_fence_fd = -1;
    438     if (ret < 0) {
    439       DLOGE("sync_wait error errno = %d, desc = %s", errno, strerror(errno));
    440     } else {
    441       DumpOutputBuffer(output_buffer_info_, output_buffer_base_, layer_stack_.retire_fence_fd);
    442     }
    443   }
    444 
    445   if (0 == dump_frame_count_) {
    446     dump_output_to_file_ = false;
    447     // Unmap and Free buffer
    448     if (munmap(output_buffer_base_, output_buffer_info_.alloc_buffer_info.size) != 0) {
    449       DLOGE("unmap failed with err %d", errno);
    450     }
    451     if (buffer_allocator_->FreeBuffer(&output_buffer_info_) != 0) {
    452       DLOGE("FreeBuffer failed");
    453     }
    454 
    455     post_processed_output_ = false;
    456     output_buffer_ = {};
    457     output_buffer_info_ = {};
    458     output_buffer_base_ = nullptr;
    459   }
    460 }
    461 
    462 void HWCDisplayPrimary::SetFrameDumpConfig(uint32_t count, uint32_t bit_mask_layer_type) {
    463   HWCDisplay::SetFrameDumpConfig(count, bit_mask_layer_type);
    464   dump_output_to_file_ = bit_mask_layer_type & (1 << OUTPUT_LAYER_DUMP);
    465   DLOGI("output_layer_dump_enable %d", dump_output_to_file_);
    466 
    467   if (!count || !dump_output_to_file_) {
    468     return;
    469   }
    470 
    471   // Allocate and map output buffer
    472   output_buffer_info_ = {};
    473   // Since we dump DSPP output use Panel resolution.
    474   GetPanelResolution(&output_buffer_info_.buffer_config.width,
    475                      &output_buffer_info_.buffer_config.height);
    476   output_buffer_info_.buffer_config.format = kFormatRGB888;
    477   output_buffer_info_.buffer_config.buffer_count = 1;
    478   if (buffer_allocator_->AllocateBuffer(&output_buffer_info_) != 0) {
    479     DLOGE("Buffer allocation failed");
    480     output_buffer_info_ = {};
    481     return;
    482   }
    483 
    484   void *buffer = mmap(NULL, output_buffer_info_.alloc_buffer_info.size, PROT_READ | PROT_WRITE,
    485                       MAP_SHARED, output_buffer_info_.alloc_buffer_info.fd, 0);
    486 
    487   if (buffer == MAP_FAILED) {
    488     DLOGE("mmap failed with err %d", errno);
    489     buffer_allocator_->FreeBuffer(&output_buffer_info_);
    490     output_buffer_info_ = {};
    491     return;
    492   }
    493 
    494   output_buffer_base_ = buffer;
    495   post_processed_output_ = true;
    496   DisablePartialUpdateOneFrame();
    497 }
    498 
    499 int HWCDisplayPrimary::FrameCaptureAsync(const BufferInfo &output_buffer_info,
    500                                          bool post_processed_output) {
    501   // Note: This function is called in context of a binder thread and a lock is already held
    502   if (output_buffer_info.alloc_buffer_info.fd < 0) {
    503     DLOGE("Invalid fd %d", output_buffer_info.alloc_buffer_info.fd);
    504     return -1;
    505   }
    506 
    507   auto panel_width = 0u;
    508   auto panel_height = 0u;
    509   auto fb_width = 0u;
    510   auto fb_height = 0u;
    511 
    512   GetPanelResolution(&panel_width, &panel_height);
    513   GetFrameBufferResolution(&fb_width, &fb_height);
    514 
    515   if (post_processed_output && (output_buffer_info_.buffer_config.width < panel_width ||
    516                                 output_buffer_info_.buffer_config.height < panel_height)) {
    517     DLOGE("Buffer dimensions should not be less than panel resolution");
    518     return -1;
    519   } else if (!post_processed_output && (output_buffer_info_.buffer_config.width < fb_width ||
    520                                         output_buffer_info_.buffer_config.height < fb_height)) {
    521     DLOGE("Buffer dimensions should not be less than FB resolution");
    522     return -1;
    523   }
    524 
    525   SetLayerBuffer(output_buffer_info, &output_buffer_);
    526   post_processed_output_ = post_processed_output;
    527   frame_capture_buffer_queued_ = true;
    528   // Status is only cleared on a new call to dump and remains valid otherwise
    529   frame_capture_status_ = -EAGAIN;
    530   DisablePartialUpdateOneFrame();
    531 
    532   return 0;
    533 }
    534 
    535 DisplayError HWCDisplayPrimary::ControlPartialUpdate(bool enable, uint32_t *pending) {
    536   DisplayError error = kErrorNone;
    537 
    538   if (display_intf_) {
    539     error = display_intf_->ControlPartialUpdate(enable, pending);
    540   }
    541 
    542   return error;
    543 }
    544 
    545 DisplayError HWCDisplayPrimary::DisablePartialUpdateOneFrame() {
    546   DisplayError error = kErrorNone;
    547 
    548   if (display_intf_) {
    549     error = display_intf_->DisablePartialUpdateOneFrame();
    550   }
    551 
    552   return error;
    553 }
    554 
    555 
    556 DisplayError HWCDisplayPrimary::SetMixerResolution(uint32_t width, uint32_t height) {
    557   return display_intf_->SetMixerResolution(width, height);
    558 }
    559 
    560 DisplayError HWCDisplayPrimary::GetMixerResolution(uint32_t *width, uint32_t *height) {
    561   return display_intf_->GetMixerResolution(width, height);
    562 }
    563 
    564 }  // namespace sdm
    565