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
46namespace sdm {
47
48int 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
83void HWCDisplayPrimary::Destroy(HWCDisplay *hwc_display) {
84  hwc_display->Deinit();
85  delete hwc_display;
86}
87
88HWCDisplayPrimary::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
96int 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
119void 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
158HWC2::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
212HWC2::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
235HWC2::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
246HWC2::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
258HWC2::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
277int 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
318DisplayError 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
328void 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
338void HWCDisplayPrimary::SetQDCMSolidFillInfo(bool enable, uint32_t color) {
339  solid_fill_enable_ = enable;
340  solid_fill_color_ = color;
341}
342
343void 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
355void 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
366void 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
380uint32_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
392DisplayError HWCDisplayPrimary::Refresh() {
393  DisplayError error = kErrorNone;
394
395  callbacks_->Refresh(HWC_DISPLAY_PRIMARY);
396  handle_idle_timeout_ = true;
397
398  return error;
399}
400
401void HWCDisplayPrimary::SetIdleTimeoutMs(uint32_t timeout_ms) {
402  display_intf_->SetIdleTimeoutMs(timeout_ms);
403}
404
405static 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
418void HWCDisplayPrimary::HandleFrameOutput() {
419  if (frame_capture_buffer_queued_) {
420    HandleFrameCapture();
421  } else if (dump_output_to_file_) {
422    HandleFrameDump();
423  }
424}
425
426void 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
438void 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
467void 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
504int 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
540DisplayError 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
550DisplayError 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
560DisplayError HWCDisplayPrimary::DisablePartialUpdateOneFrame() {
561  DisplayError error = kErrorNone;
562
563  if (display_intf_) {
564    error = display_intf_->DisablePartialUpdateOneFrame();
565  }
566
567  return error;
568}
569
570
571DisplayError HWCDisplayPrimary::SetMixerResolution(uint32_t width, uint32_t height) {
572  return display_intf_->SetMixerResolution(width, height);
573}
574
575DisplayError HWCDisplayPrimary::GetMixerResolution(uint32_t *width, uint32_t *height) {
576  return display_intf_->GetMixerResolution(width, height);
577}
578
579}  // namespace sdm
580