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, buffer_allocator),
     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   validated_ = false;
    248   auto status = color_mode_->SetColorMode(mode);
    249   if (status != HWC2::Error::None) {
    250     DLOGE("failed for mode = %d", mode);
    251     return status;
    252   }
    253 
    254   callbacks_->Refresh(HWC_DISPLAY_PRIMARY);
    255 
    256   return status;
    257 }
    258 
    259 HWC2::Error HWCDisplayPrimary::SetColorTransform(const float *matrix,
    260                                                  android_color_transform_t hint) {
    261   validated_ = false;
    262   if (!matrix) {
    263     return HWC2::Error::BadParameter;
    264   }
    265 
    266   auto status = color_mode_->SetColorTransform(matrix, hint);
    267   if (status != HWC2::Error::None) {
    268     DLOGE("failed for hint = %d", hint);
    269     color_tranform_failed_ = true;
    270     return status;
    271   }
    272 
    273   callbacks_->Refresh(HWC_DISPLAY_PRIMARY);
    274   color_tranform_failed_ = false;
    275 
    276   return status;
    277 }
    278 
    279 int HWCDisplayPrimary::Perform(uint32_t operation, ...) {
    280   va_list args;
    281   va_start(args, operation);
    282   int val = 0;
    283   LayerRect *rect = NULL;
    284 
    285   switch (operation) {
    286     case SET_METADATA_DYN_REFRESH_RATE:
    287       val = va_arg(args, int32_t);
    288       SetMetaDataRefreshRateFlag(val);
    289       break;
    290     case SET_BINDER_DYN_REFRESH_RATE:
    291       val = va_arg(args, int32_t);
    292       ForceRefreshRate(UINT32(val));
    293       break;
    294     case SET_DISPLAY_MODE:
    295       val = va_arg(args, int32_t);
    296       SetDisplayMode(UINT32(val));
    297       break;
    298     case SET_QDCM_SOLID_FILL_INFO:
    299       val = va_arg(args, int32_t);
    300       SetQDCMSolidFillInfo(true, UINT32(val));
    301       break;
    302     case UNSET_QDCM_SOLID_FILL_INFO:
    303       val = va_arg(args, int32_t);
    304       SetQDCMSolidFillInfo(false, UINT32(val));
    305       break;
    306     case SET_QDCM_SOLID_FILL_RECT:
    307       rect = va_arg(args, LayerRect*);
    308       solid_fill_rect_ = *rect;
    309       break;
    310     default:
    311       DLOGW("Invalid operation %d", operation);
    312       va_end(args);
    313       return -EINVAL;
    314   }
    315   va_end(args);
    316 
    317   return 0;
    318 }
    319 
    320 DisplayError HWCDisplayPrimary::SetDisplayMode(uint32_t mode) {
    321   DisplayError error = kErrorNone;
    322 
    323   if (display_intf_) {
    324     error = display_intf_->SetDisplayMode(mode);
    325   }
    326 
    327   return error;
    328 }
    329 
    330 void HWCDisplayPrimary::SetMetaDataRefreshRateFlag(bool enable) {
    331   int disable_metadata_dynfps = 0;
    332 
    333   HWCDebugHandler::Get()->GetProperty("persist.metadata_dynfps.disable", &disable_metadata_dynfps);
    334   if (disable_metadata_dynfps) {
    335     return;
    336   }
    337   use_metadata_refresh_rate_ = enable;
    338 }
    339 
    340 void HWCDisplayPrimary::SetQDCMSolidFillInfo(bool enable, uint32_t color) {
    341   solid_fill_enable_ = enable;
    342   solid_fill_color_ = color;
    343 }
    344 
    345 void HWCDisplayPrimary::ToggleCPUHint(bool set) {
    346   if (!cpu_hint_) {
    347     return;
    348   }
    349 
    350   if (set) {
    351     cpu_hint_->Set();
    352   } else {
    353     cpu_hint_->Reset();
    354   }
    355 }
    356 
    357 void HWCDisplayPrimary::SetSecureDisplay(bool secure_display_active) {
    358   if (secure_display_active_ != secure_display_active) {
    359     // Skip Prepare and call Flush for null commit
    360     DLOGI("SecureDisplay state changed from %d to %d Needs Flush!!", secure_display_active_,
    361           secure_display_active);
    362     secure_display_active_ = secure_display_active;
    363     skip_prepare_ = true;
    364   }
    365   return;
    366 }
    367 
    368 void HWCDisplayPrimary::ForceRefreshRate(uint32_t refresh_rate) {
    369   if ((refresh_rate && (refresh_rate < min_refresh_rate_ || refresh_rate > max_refresh_rate_)) ||
    370       force_refresh_rate_ == refresh_rate) {
    371     // Cannot honor force refresh rate, as its beyond the range or new request is same
    372     return;
    373   }
    374 
    375   force_refresh_rate_ = refresh_rate;
    376 
    377   callbacks_->Refresh(HWC_DISPLAY_PRIMARY);
    378 
    379   return;
    380 }
    381 
    382 uint32_t HWCDisplayPrimary::GetOptimalRefreshRate(bool one_updating_layer) {
    383   if (force_refresh_rate_) {
    384     return force_refresh_rate_;
    385   } else if (handle_idle_timeout_) {
    386     return min_refresh_rate_;
    387   } else if (use_metadata_refresh_rate_ && one_updating_layer && metadata_refresh_rate_) {
    388     return metadata_refresh_rate_;
    389   }
    390 
    391   return max_refresh_rate_;
    392 }
    393 
    394 DisplayError HWCDisplayPrimary::Refresh() {
    395   DisplayError error = kErrorNone;
    396 
    397   callbacks_->Refresh(HWC_DISPLAY_PRIMARY);
    398   handle_idle_timeout_ = true;
    399 
    400   return error;
    401 }
    402 
    403 void HWCDisplayPrimary::SetIdleTimeoutMs(uint32_t timeout_ms) {
    404   display_intf_->SetIdleTimeoutMs(timeout_ms);
    405 }
    406 
    407 static void SetLayerBuffer(const BufferInfo &output_buffer_info, LayerBuffer *output_buffer) {
    408   output_buffer->width = output_buffer_info.buffer_config.width;
    409   output_buffer->height = output_buffer_info.buffer_config.height;
    410   output_buffer->format = output_buffer_info.buffer_config.format;
    411   output_buffer->planes[0].fd = output_buffer_info.alloc_buffer_info.fd;
    412   output_buffer->planes[0].stride = output_buffer_info.alloc_buffer_info.stride;
    413 }
    414 
    415 void HWCDisplayPrimary::HandleFrameOutput() {
    416   if (frame_capture_buffer_queued_) {
    417     HandleFrameCapture();
    418   } else if (dump_output_to_file_) {
    419     HandleFrameDump();
    420   }
    421 }
    422 
    423 void HWCDisplayPrimary::HandleFrameCapture() {
    424   if (output_buffer_.release_fence_fd >= 0) {
    425     frame_capture_status_ = sync_wait(output_buffer_.release_fence_fd, 1000);
    426     ::close(output_buffer_.release_fence_fd);
    427     output_buffer_.release_fence_fd = -1;
    428   }
    429 
    430   frame_capture_buffer_queued_ = false;
    431   post_processed_output_ = false;
    432   output_buffer_ = {};
    433 }
    434 
    435 void HWCDisplayPrimary::HandleFrameDump() {
    436   if (dump_frame_count_ && output_buffer_.release_fence_fd >= 0) {
    437     int ret = sync_wait(output_buffer_.release_fence_fd, 1000);
    438     ::close(output_buffer_.release_fence_fd);
    439     output_buffer_.release_fence_fd = -1;
    440     if (ret < 0) {
    441       DLOGE("sync_wait error errno = %d, desc = %s", errno, strerror(errno));
    442     } else {
    443       DumpOutputBuffer(output_buffer_info_, output_buffer_base_, layer_stack_.retire_fence_fd);
    444     }
    445   }
    446 
    447   if (0 == dump_frame_count_) {
    448     dump_output_to_file_ = false;
    449     // Unmap and Free buffer
    450     if (munmap(output_buffer_base_, output_buffer_info_.alloc_buffer_info.size) != 0) {
    451       DLOGE("unmap failed with err %d", errno);
    452     }
    453     if (buffer_allocator_->FreeBuffer(&output_buffer_info_) != 0) {
    454       DLOGE("FreeBuffer failed");
    455     }
    456 
    457     post_processed_output_ = false;
    458     output_buffer_ = {};
    459     output_buffer_info_ = {};
    460     output_buffer_base_ = nullptr;
    461   }
    462 }
    463 
    464 void HWCDisplayPrimary::SetFrameDumpConfig(uint32_t count, uint32_t bit_mask_layer_type) {
    465   HWCDisplay::SetFrameDumpConfig(count, bit_mask_layer_type);
    466   dump_output_to_file_ = bit_mask_layer_type & (1 << OUTPUT_LAYER_DUMP);
    467   DLOGI("output_layer_dump_enable %d", dump_output_to_file_);
    468 
    469   if (!count || !dump_output_to_file_) {
    470     return;
    471   }
    472 
    473   // Allocate and map output buffer
    474   output_buffer_info_ = {};
    475   // Since we dump DSPP output use Panel resolution.
    476   GetPanelResolution(&output_buffer_info_.buffer_config.width,
    477                      &output_buffer_info_.buffer_config.height);
    478   output_buffer_info_.buffer_config.format = kFormatRGB888;
    479   output_buffer_info_.buffer_config.buffer_count = 1;
    480   if (buffer_allocator_->AllocateBuffer(&output_buffer_info_) != 0) {
    481     DLOGE("Buffer allocation failed");
    482     output_buffer_info_ = {};
    483     return;
    484   }
    485 
    486   void *buffer = mmap(NULL, output_buffer_info_.alloc_buffer_info.size, PROT_READ | PROT_WRITE,
    487                       MAP_SHARED, output_buffer_info_.alloc_buffer_info.fd, 0);
    488 
    489   if (buffer == MAP_FAILED) {
    490     DLOGE("mmap failed with err %d", errno);
    491     buffer_allocator_->FreeBuffer(&output_buffer_info_);
    492     output_buffer_info_ = {};
    493     return;
    494   }
    495 
    496   output_buffer_base_ = buffer;
    497   post_processed_output_ = true;
    498   DisablePartialUpdateOneFrame();
    499 }
    500 
    501 int HWCDisplayPrimary::FrameCaptureAsync(const BufferInfo &output_buffer_info,
    502                                          bool post_processed_output) {
    503   // Note: This function is called in context of a binder thread and a lock is already held
    504   if (output_buffer_info.alloc_buffer_info.fd < 0) {
    505     DLOGE("Invalid fd %d", output_buffer_info.alloc_buffer_info.fd);
    506     return -1;
    507   }
    508 
    509   auto panel_width = 0u;
    510   auto panel_height = 0u;
    511   auto fb_width = 0u;
    512   auto fb_height = 0u;
    513 
    514   GetPanelResolution(&panel_width, &panel_height);
    515   GetFrameBufferResolution(&fb_width, &fb_height);
    516 
    517   if (post_processed_output && (output_buffer_info_.buffer_config.width < panel_width ||
    518                                 output_buffer_info_.buffer_config.height < panel_height)) {
    519     DLOGE("Buffer dimensions should not be less than panel resolution");
    520     return -1;
    521   } else if (!post_processed_output && (output_buffer_info_.buffer_config.width < fb_width ||
    522                                         output_buffer_info_.buffer_config.height < fb_height)) {
    523     DLOGE("Buffer dimensions should not be less than FB resolution");
    524     return -1;
    525   }
    526 
    527   SetLayerBuffer(output_buffer_info, &output_buffer_);
    528   post_processed_output_ = post_processed_output;
    529   frame_capture_buffer_queued_ = true;
    530   // Status is only cleared on a new call to dump and remains valid otherwise
    531   frame_capture_status_ = -EAGAIN;
    532   DisablePartialUpdateOneFrame();
    533 
    534   return 0;
    535 }
    536 
    537 DisplayError HWCDisplayPrimary::ControlPartialUpdate(bool enable, uint32_t *pending) {
    538   DisplayError error = kErrorNone;
    539 
    540   if (display_intf_) {
    541     error = display_intf_->ControlPartialUpdate(enable, pending);
    542   }
    543 
    544   return error;
    545 }
    546 
    547 DisplayError HWCDisplayPrimary::DisablePartialUpdateOneFrame() {
    548   DisplayError error = kErrorNone;
    549 
    550   if (display_intf_) {
    551     error = display_intf_->DisablePartialUpdateOneFrame();
    552   }
    553 
    554   return error;
    555 }
    556 
    557 
    558 DisplayError HWCDisplayPrimary::SetMixerResolution(uint32_t width, uint32_t height) {
    559   return display_intf_->SetMixerResolution(width, height);
    560 }
    561 
    562 DisplayError HWCDisplayPrimary::GetMixerResolution(uint32_t *width, uint32_t *height) {
    563   return display_intf_->GetMixerResolution(width, height);
    564 }
    565 
    566 }  // namespace sdm
    567