Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 1 | /* |
Gousemoodhin Nadaf | 087c310 | 2019-01-07 19:34:56 +0530 | [diff] [blame] | 2 | * Copyright (c) 2014-2019, The Linux Foundation. All rights reserved. |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 3 | * Not a Contribution. |
| 4 | * |
| 5 | * Copyright 2015 The Android Open Source Project |
| 6 | * |
| 7 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 8 | * you may not use this file except in compliance with the License. |
| 9 | * You may obtain a copy of the License at |
| 10 | * |
| 11 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 12 | * |
| 13 | * Unless required by applicable law or agreed to in writing, software |
| 14 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 15 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 16 | * See the License for the specific language governing permissions and |
| 17 | * limitations under the License. |
| 18 | */ |
| 19 | |
| 20 | #ifndef __HWC_DISPLAY_H__ |
| 21 | #define __HWC_DISPLAY_H__ |
| 22 | |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 23 | #include <QService.h> |
Gousemoodhin Nadaf | 0e56687 | 2019-05-13 16:14:54 +0530 | [diff] [blame] | 24 | #include <android/hardware/graphics/common/1.2/types.h> |
Arun Kumar K.R | 29cd658 | 2016-05-10 19:12:45 -0700 | [diff] [blame] | 25 | #include <core/core_interface.h> |
| 26 | #include <hardware/hwcomposer.h> |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 27 | #include <private/color_params.h> |
Arun Kumar K.R | 29cd658 | 2016-05-10 19:12:45 -0700 | [diff] [blame] | 28 | #include <qdMetaData.h> |
Naseer Ahmed | e7a7798 | 2018-06-04 10:56:04 -0400 | [diff] [blame] | 29 | #include <sys/stat.h> |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 30 | #include <map> |
Arun Kumar K.R | 29cd658 | 2016-05-10 19:12:45 -0700 | [diff] [blame] | 31 | #include <queue> |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 32 | #include <set> |
Naseer Ahmed | 2a3c7d9 | 2016-05-17 18:38:54 -0400 | [diff] [blame] | 33 | #include <string> |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 34 | #include <utility> |
Arun Kumar K.R | 29cd658 | 2016-05-10 19:12:45 -0700 | [diff] [blame] | 35 | #include <vector> |
Ramkumar Radhakrishnan | a38b760 | 2018-03-15 14:49:52 -0700 | [diff] [blame] | 36 | #include <bitset> |
Mahesh Aia | f3a1f99 | 2019-01-16 13:07:42 -0800 | [diff] [blame] | 37 | #include <algorithm> |
Naseer Ahmed | 4275221 | 2017-01-27 17:32:21 -0500 | [diff] [blame] | 38 | #include "hwc_buffer_allocator.h" |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 39 | #include "hwc_callbacks.h" |
| 40 | #include "hwc_layers.h" |
Varun Arora | 465c1f7 | 2018-02-08 16:18:50 -0800 | [diff] [blame] | 41 | #include "display_null.h" |
Varun Arora | 7c8ee54 | 2018-05-01 20:58:16 -0700 | [diff] [blame] | 42 | #include "hwc_display_event_handler.h" |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 43 | |
Gousemoodhin Nadaf | 0e56687 | 2019-05-13 16:14:54 +0530 | [diff] [blame] | 44 | using android::hardware::graphics::common::V1_2::ColorMode; |
Naseer Ahmed | e7a7798 | 2018-06-04 10:56:04 -0400 | [diff] [blame] | 45 | using android::hardware::graphics::common::V1_1::Dataspace; |
| 46 | using android::hardware::graphics::common::V1_1::RenderIntent; |
| 47 | |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 48 | namespace sdm { |
| 49 | |
Arun Kumar K.R | 51be3d1 | 2017-03-31 19:54:38 -0700 | [diff] [blame] | 50 | class HWCToneMapper; |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 51 | |
Xu Yang | 47f4409 | 2019-02-13 14:09:53 +0800 | [diff] [blame] | 52 | /* max customer extended render intent */ |
| 53 | #define MAX_EXTENDED_RENDER_INTENT 0x1ff |
| 54 | |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 55 | // Subclasses set this to their type. This has to be different from DisplayType. |
| 56 | // This is to avoid RTTI and dynamic_cast |
| 57 | enum DisplayClass { |
Dileep Marchya | f3ce11f | 2018-04-30 23:35:46 +0530 | [diff] [blame] | 58 | DISPLAY_CLASS_BUILTIN, |
| 59 | DISPLAY_CLASS_PLUGGABLE, |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 60 | DISPLAY_CLASS_VIRTUAL, |
| 61 | DISPLAY_CLASS_NULL |
| 62 | }; |
| 63 | |
Ramkumar Radhakrishnan | a38b760 | 2018-03-15 14:49:52 -0700 | [diff] [blame] | 64 | enum SecureSessionType { |
| 65 | kSecureDisplay, |
| 66 | kSecureCamera, |
| 67 | kSecureMax, |
| 68 | }; |
| 69 | |
Arun Kumar K.R | 29cd658 | 2016-05-10 19:12:45 -0700 | [diff] [blame] | 70 | class HWCColorMode { |
| 71 | public: |
| 72 | explicit HWCColorMode(DisplayInterface *display_intf); |
| 73 | ~HWCColorMode() {} |
| 74 | HWC2::Error Init(); |
| 75 | HWC2::Error DeInit(); |
Naseer Ahmed | 913502b | 2017-04-18 16:05:05 -0400 | [diff] [blame] | 76 | void Dump(std::ostringstream* os); |
Arun Kumar K.R | 29cd658 | 2016-05-10 19:12:45 -0700 | [diff] [blame] | 77 | uint32_t GetColorModeCount(); |
Naseer Ahmed | e7a7798 | 2018-06-04 10:56:04 -0400 | [diff] [blame] | 78 | uint32_t GetRenderIntentCount(ColorMode mode); |
| 79 | HWC2::Error GetColorModes(uint32_t *out_num_modes, ColorMode *out_modes); |
| 80 | HWC2::Error GetRenderIntents(ColorMode mode, uint32_t *out_num_intents, RenderIntent *out_modes); |
| 81 | HWC2::Error SetColorModeWithRenderIntent(ColorMode mode, RenderIntent intent); |
Naseer Ahmed | 6776dae | 2017-05-09 11:49:41 -0400 | [diff] [blame] | 82 | HWC2::Error SetColorModeById(int32_t color_mode_id); |
Xu Yang | 84e6141 | 2018-12-06 14:52:16 +0800 | [diff] [blame] | 83 | HWC2::Error SetColorModeFromClientApi(std::string mode_string); |
Arun Kumar K.R | 29cd658 | 2016-05-10 19:12:45 -0700 | [diff] [blame] | 84 | HWC2::Error SetColorTransform(const float *matrix, android_color_transform_t hint); |
Ch Ganesh Kumar | 5d43ff6 | 2017-10-13 19:01:47 +0530 | [diff] [blame] | 85 | HWC2::Error RestoreColorTransform(); |
Gousemoodhin Nadaf | 839f29d | 2018-06-04 10:56:04 -0400 | [diff] [blame] | 86 | ColorMode GetCurrentColorMode() { return current_color_mode_; } |
Xu Yang | 84e6141 | 2018-12-06 14:52:16 +0800 | [diff] [blame] | 87 | HWC2::Error ApplyCurrentColorModeWithRenderIntent(bool hdr_present); |
Sushil Chauhan | 8008d60 | 2018-09-04 14:43:27 -0700 | [diff] [blame] | 88 | HWC2::Error CacheColorModeWithRenderIntent(ColorMode mode, RenderIntent intent); |
Arun Kumar K.R | 29cd658 | 2016-05-10 19:12:45 -0700 | [diff] [blame] | 89 | |
| 90 | private: |
| 91 | static const uint32_t kColorTransformMatrixCount = 16; |
Arun Kumar K.R | 29cd658 | 2016-05-10 19:12:45 -0700 | [diff] [blame] | 92 | void PopulateColorModes(); |
Arun Kumar K.R | 29cd658 | 2016-05-10 19:12:45 -0700 | [diff] [blame] | 93 | template <class T> |
| 94 | void CopyColorTransformMatrix(const T *input_matrix, double *output_matrix) { |
| 95 | for (uint32_t i = 0; i < kColorTransformMatrixCount; i++) { |
| 96 | output_matrix[i] = static_cast<double>(input_matrix[i]); |
| 97 | } |
| 98 | } |
Qing Huang | 3f21afb | 2017-04-19 15:11:49 +0800 | [diff] [blame] | 99 | HWC2::Error ApplyDefaultColorMode(); |
Sushil Chauhan | 8008d60 | 2018-09-04 14:43:27 -0700 | [diff] [blame] | 100 | HWC2::Error ValidateColorModeWithRenderIntent(ColorMode mode, RenderIntent intent); |
Xu Yang | 84e6141 | 2018-12-06 14:52:16 +0800 | [diff] [blame] | 101 | HWC2::Error SetPreferredColorModeInternal(const std::string &mode_string, bool from_client, |
| 102 | ColorMode *color_mode, DynamicRangeType *dynamic_range); |
Arun Kumar K.R | 29cd658 | 2016-05-10 19:12:45 -0700 | [diff] [blame] | 103 | |
| 104 | DisplayInterface *display_intf_ = NULL; |
Sushil Chauhan | 7cd110d | 2018-08-24 17:17:55 -0700 | [diff] [blame] | 105 | bool apply_mode_ = false; |
Naseer Ahmed | e7a7798 | 2018-06-04 10:56:04 -0400 | [diff] [blame] | 106 | ColorMode current_color_mode_ = ColorMode::NATIVE; |
| 107 | RenderIntent current_render_intent_ = RenderIntent::COLORIMETRIC; |
Xu Yang | 84e6141 | 2018-12-06 14:52:16 +0800 | [diff] [blame] | 108 | DynamicRangeType curr_dynamic_range_ = kSdrType; |
| 109 | typedef std::map<DynamicRangeType, std::string> DynamicRangeMap; |
| 110 | typedef std::map<RenderIntent, DynamicRangeMap> RenderIntentMap; |
| 111 | // Initialize supported mode/render intent/dynamic range combination |
Naseer Ahmed | e7a7798 | 2018-06-04 10:56:04 -0400 | [diff] [blame] | 112 | std::map<ColorMode, RenderIntentMap> color_mode_map_ = {}; |
Naseer Ahmed | 7dcd137 | 2017-05-19 18:06:51 -0400 | [diff] [blame] | 113 | double color_matrix_[kColorTransformMatrixCount] = { 1.0, 0.0, 0.0, 0.0, \ |
| 114 | 0.0, 1.0, 0.0, 0.0, \ |
| 115 | 0.0, 0.0, 1.0, 0.0, \ |
| 116 | 0.0, 0.0, 0.0, 1.0 }; |
Xu Yang | 84e6141 | 2018-12-06 14:52:16 +0800 | [diff] [blame] | 117 | std::map<ColorMode, DynamicRangeMap> preferred_mode_ = {}; |
Arun Kumar K.R | 29cd658 | 2016-05-10 19:12:45 -0700 | [diff] [blame] | 118 | }; |
| 119 | |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 120 | class HWCDisplay : public DisplayEventHandler { |
| 121 | public: |
Dileep Marchya | 6860b2b | 2017-04-07 15:56:47 +0530 | [diff] [blame] | 122 | enum DisplayStatus { |
| 123 | kDisplayStatusInvalid = -1, |
| 124 | kDisplayStatusOffline, |
| 125 | kDisplayStatusOnline, |
| 126 | kDisplayStatusPause, |
| 127 | kDisplayStatusResume, |
| 128 | }; |
| 129 | |
Sushil Chauhan | e3a9fd0 | 2017-10-12 18:00:05 -0700 | [diff] [blame] | 130 | enum DisplayValidateState { |
| 131 | kNormalValidate, |
| 132 | kInternalValidate, |
| 133 | kSkipValidate, |
| 134 | }; |
| 135 | |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 136 | virtual ~HWCDisplay() {} |
| 137 | virtual int Init(); |
| 138 | virtual int Deinit(); |
| 139 | |
| 140 | // Framebuffer configurations |
| 141 | virtual void SetIdleTimeoutMs(uint32_t timeout_ms); |
Sushil Chauhan | 267a619 | 2018-06-06 18:41:47 -0700 | [diff] [blame] | 142 | virtual HWC2::Error SetFrameDumpConfig(uint32_t count, uint32_t bit_mask_layer_type, |
| 143 | int32_t format, bool post_processed); |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 144 | virtual DisplayError SetMaxMixerStages(uint32_t max_mixer_stages); |
Arun Kumar K.R | 17bbd04 | 2016-06-07 17:38:02 -0700 | [diff] [blame] | 145 | virtual DisplayError ControlPartialUpdate(bool enable, uint32_t *pending) { |
| 146 | return kErrorNotSupported; |
| 147 | } |
Varun Arora | f027a22 | 2018-11-14 17:38:16 -0800 | [diff] [blame] | 148 | virtual HWC2::PowerMode GetCurrentPowerMode(); |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 149 | virtual int SetFrameBufferResolution(uint32_t x_pixels, uint32_t y_pixels); |
| 150 | virtual void GetFrameBufferResolution(uint32_t *x_pixels, uint32_t *y_pixels); |
Dileep Marchya | 6860b2b | 2017-04-07 15:56:47 +0530 | [diff] [blame] | 151 | virtual int SetDisplayStatus(DisplayStatus display_status); |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 152 | virtual int OnMinHdcpEncryptionLevelChange(uint32_t min_enc_level); |
| 153 | virtual int Perform(uint32_t operation, ...); |
Ramkumar Radhakrishnan | a38b760 | 2018-03-15 14:49:52 -0700 | [diff] [blame] | 154 | virtual int HandleSecureSession(const std::bitset<kSecureMax> &secure_sessions, |
| 155 | bool *power_on_pending); |
| 156 | virtual int GetActiveSecureSession(std::bitset<kSecureMax> *secure_sessions); |
Arun Kumar K.R | 8da7f50 | 2016-06-07 17:45:50 -0700 | [diff] [blame] | 157 | virtual DisplayError SetMixerResolution(uint32_t width, uint32_t height); |
| 158 | virtual DisplayError GetMixerResolution(uint32_t *width, uint32_t *height); |
| 159 | virtual void GetPanelResolution(uint32_t *width, uint32_t *height); |
Saurabh Shah | 9c224a3 | 2017-11-09 12:17:44 -0800 | [diff] [blame] | 160 | virtual std::string Dump(); |
Gurpreet Singh Dhami | 1207e46 | 2018-12-27 20:02:02 -0500 | [diff] [blame] | 161 | virtual DisplayError TeardownConcurrentWriteback(void) { |
| 162 | return kErrorNotSupported; |
| 163 | } |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 164 | |
| 165 | // Captures frame output in the buffer specified by output_buffer_info. The API is |
| 166 | // non-blocking and the client is expected to check operation status later on. |
| 167 | // Returns -1 if the input is invalid. |
| 168 | virtual int FrameCaptureAsync(const BufferInfo &output_buffer_info, bool post_processed) { |
| 169 | return -1; |
| 170 | } |
Sushil Chauhan | 1d3b90c | 2018-12-11 16:52:35 -0800 | [diff] [blame] | 171 | // Returns the status of frame capture operation requested with FrameCaptureAsync(). |
| 172 | // -EAGAIN : No status obtain yet, call API again after another frame. |
| 173 | // < 0 : Operation happened but failed. |
| 174 | // 0 : Success. |
| 175 | virtual int GetFrameCaptureStatus() { return -EAGAIN; } |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 176 | |
Alan Kwong | 2e13633 | 2016-08-16 07:50:16 -0400 | [diff] [blame] | 177 | virtual DisplayError SetDetailEnhancerConfig(const DisplayDetailEnhancerData &de_data) { |
| 178 | return kErrorNotSupported; |
| 179 | } |
Sushil Chauhan | 0652158 | 2018-03-19 14:00:23 -0700 | [diff] [blame] | 180 | virtual HWC2::Error SetReadbackBuffer(const native_handle_t *buffer, int32_t acquire_fence, |
| 181 | bool post_processed_output) { |
| 182 | return HWC2::Error::Unsupported; |
| 183 | } |
| 184 | virtual HWC2::Error GetReadbackBufferFence(int32_t *release_fence) { |
| 185 | return HWC2::Error::Unsupported; |
| 186 | } |
Alan Kwong | 2e13633 | 2016-08-16 07:50:16 -0400 | [diff] [blame] | 187 | |
Yuchao Ma | 577f0f7 | 2018-07-09 11:20:00 +0800 | [diff] [blame] | 188 | virtual HWC2::Error SetDisplayDppsAdROI(uint32_t h_start, uint32_t h_end, |
| 189 | uint32_t v_start, uint32_t v_end, |
| 190 | uint32_t factor_in, uint32_t factor_out) { |
| 191 | return HWC2::Error::Unsupported; |
| 192 | } |
Xu Yang | 9dacc87 | 2018-12-25 11:04:28 +0800 | [diff] [blame] | 193 | virtual HWC2::Error SetFrameTriggerMode(uint32_t mode) { |
| 194 | return HWC2::Error::Unsupported; |
| 195 | } |
Yuchao Ma | 577f0f7 | 2018-07-09 11:20:00 +0800 | [diff] [blame] | 196 | |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 197 | // Display Configurations |
Mahesh Aia | f3a1f99 | 2019-01-16 13:07:42 -0800 | [diff] [blame] | 198 | static uint32_t GetThrottlingRefreshRate() { return HWCDisplay::throttling_refresh_rate_; } |
| 199 | static void SetThrottlingRefreshRate(uint32_t newRefreshRate) |
| 200 | { HWCDisplay::throttling_refresh_rate_ = newRefreshRate; } |
Dileep Marchya | 6860b2b | 2017-04-07 15:56:47 +0530 | [diff] [blame] | 201 | virtual int SetActiveDisplayConfig(uint32_t config); |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 202 | virtual int GetActiveDisplayConfig(uint32_t *config); |
| 203 | virtual int GetDisplayConfigCount(uint32_t *count); |
Arun Kumar K.R | 8da7f50 | 2016-06-07 17:45:50 -0700 | [diff] [blame] | 204 | virtual int GetDisplayAttributesForConfig(int config, |
| 205 | DisplayConfigVariableInfo *display_attributes); |
Dileep Marchya | d16da3e | 2017-05-20 01:56:21 +0530 | [diff] [blame] | 206 | virtual int SetState(bool connected) { |
| 207 | return kErrorNotSupported; |
| 208 | } |
Rajavenu Kyatham | 0987b0e | 2018-02-14 18:59:26 +0530 | [diff] [blame] | 209 | virtual DisplayError Flush() { |
| 210 | return kErrorNotSupported; |
| 211 | } |
| 212 | |
Mahesh Aia | f3a1f99 | 2019-01-16 13:07:42 -0800 | [diff] [blame] | 213 | uint32_t GetMaxRefreshRate() { return max_refresh_rate_; } |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 214 | int ToggleScreenUpdates(bool enable); |
| 215 | int ColorSVCRequestRoute(const PPDisplayAPIPayload &in_payload, PPDisplayAPIPayload *out_payload, |
| 216 | PPPendingParams *pending_action); |
Arun Kumar K.R | 536c7d6 | 2016-06-14 18:47:39 -0700 | [diff] [blame] | 217 | void SolidFillPrepare(); |
| 218 | void SolidFillCommit(); |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 219 | DisplayClass GetDisplayClass(); |
| 220 | int GetVisibleDisplayRect(hwc_rect_t *rect); |
| 221 | void BuildLayerStack(void); |
Arun Kumar K.R | 536c7d6 | 2016-06-14 18:47:39 -0700 | [diff] [blame] | 222 | void BuildSolidFillStack(void); |
Varun Arora | 2c23e58 | 2017-10-10 15:07:13 -0700 | [diff] [blame] | 223 | HWCLayer *GetHWCLayer(hwc2_layer_t layer_id); |
Saurabh Shah | a307e8c | 2017-09-28 18:05:40 -0700 | [diff] [blame] | 224 | void ResetValidation() { validated_ = false; } |
Sushil Chauhan | 409e844 | 2017-06-12 17:43:25 -0700 | [diff] [blame] | 225 | uint32_t GetGeometryChanges() { return geometry_changes_; } |
Sushil Chauhan | e3a9fd0 | 2017-10-12 18:00:05 -0700 | [diff] [blame] | 226 | bool CanSkipValidate(); |
Sushil Chauhan | e3a9fd0 | 2017-10-12 18:00:05 -0700 | [diff] [blame] | 227 | bool IsSkipValidateState() { return (validate_state_ == kSkipValidate); } |
| 228 | bool IsInternalValidateState() { return (validated_ && (validate_state_ == kInternalValidate)); } |
| 229 | void SetValidationState(DisplayValidateState state) { validate_state_ = state; } |
Sushil Chauhan | fea3e90 | 2018-07-31 15:34:48 -0700 | [diff] [blame] | 230 | ColorMode GetCurrentColorMode() { |
| 231 | return (color_mode_ ? color_mode_->GetCurrentColorMode() : ColorMode::SRGB); |
| 232 | } |
Sushil Chauhan | 181d950 | 2018-12-13 16:40:58 -0800 | [diff] [blame] | 233 | bool HWCClientNeedsValidate() { |
| 234 | return (has_client_composition_ || layer_stack_.flags.single_buffered_layer_present); |
| 235 | } |
Sushil Chauhan | 9c07ad0 | 2019-02-28 12:07:35 -0800 | [diff] [blame] | 236 | virtual void SetFastPathComposition(bool enable) { fast_path_composition_ = enable; } |
Xu Yang | 84e6141 | 2018-12-06 14:52:16 +0800 | [diff] [blame] | 237 | virtual HWC2::Error SetColorModeFromClientApi(int32_t color_mode_id) { |
| 238 | return HWC2::Error::Unsupported; |
| 239 | } |
Mathew Joseph Karimpanal | abe3b3d | 2018-11-27 17:25:40 +0530 | [diff] [blame] | 240 | bool IsFirstCommitDone() { return !first_cycle_; } |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 241 | |
| 242 | // HWC2 APIs |
| 243 | virtual HWC2::Error AcceptDisplayChanges(void); |
| 244 | virtual HWC2::Error GetActiveConfig(hwc2_config_t *out_config); |
| 245 | virtual HWC2::Error SetActiveConfig(hwc2_config_t config); |
| 246 | virtual HWC2::Error SetClientTarget(buffer_handle_t target, int32_t acquire_fence, |
Naseer Ahmed | a20c4c0 | 2016-06-03 17:48:28 -0400 | [diff] [blame] | 247 | int32_t dataspace, hwc_region_t damage); |
Naseer Ahmed | e7a7798 | 2018-06-04 10:56:04 -0400 | [diff] [blame] | 248 | virtual HWC2::Error SetColorMode(ColorMode mode) { return HWC2::Error::Unsupported; } |
| 249 | virtual HWC2::Error SetColorModeWithRenderIntent(ColorMode mode, RenderIntent intent) { |
Arun Kumar K.R | 29cd658 | 2016-05-10 19:12:45 -0700 | [diff] [blame] | 250 | return HWC2::Error::Unsupported; |
| 251 | } |
Naseer Ahmed | 6776dae | 2017-05-09 11:49:41 -0400 | [diff] [blame] | 252 | virtual HWC2::Error SetColorModeById(int32_t color_mode_id) { |
| 253 | return HWC2::Error::Unsupported; |
| 254 | } |
Ch Ganesh Kumar | 5d43ff6 | 2017-10-13 19:01:47 +0530 | [diff] [blame] | 255 | virtual HWC2::Error RestoreColorTransform() { |
| 256 | return HWC2::Error::Unsupported; |
| 257 | } |
Arun Kumar K.R | 29cd658 | 2016-05-10 19:12:45 -0700 | [diff] [blame] | 258 | virtual HWC2::Error SetColorTransform(const float *matrix, android_color_transform_t hint) { |
| 259 | return HWC2::Error::Unsupported; |
| 260 | } |
Naseer Ahmed | eae2812 | 2016-06-27 15:47:05 -0400 | [diff] [blame] | 261 | virtual HWC2::Error HandleColorModeTransform(android_color_mode_t mode, |
Arun Kumar K.R | 29cd658 | 2016-05-10 19:12:45 -0700 | [diff] [blame] | 262 | android_color_transform_t hint, |
| 263 | const double *matrix) { |
| 264 | return HWC2::Error::Unsupported; |
| 265 | } |
Pullakavi Srinivas | 9189e60 | 2018-12-19 16:58:07 +0530 | [diff] [blame] | 266 | virtual DisplayError SetDynamicDSIClock(uint64_t bitclk) { |
| 267 | return kErrorNotSupported; |
| 268 | } |
| 269 | virtual DisplayError GetDynamicDSIClock(uint64_t *bitclk) { |
| 270 | return kErrorNotSupported; |
| 271 | } |
| 272 | virtual DisplayError GetSupportedDSIClock(std::vector<uint64_t> *bitclk) { |
| 273 | return kErrorNotSupported; |
| 274 | } |
Padmanabhan Komanduru | e74cf4f | 2019-04-25 17:38:43 -0700 | [diff] [blame] | 275 | virtual HWC2::Error UpdateDisplayId(hwc2_display_t id) { |
| 276 | return HWC2::Error::Unsupported; |
| 277 | } |
| 278 | virtual HWC2::Error SetPendingRefresh() { |
| 279 | return HWC2::Error::Unsupported; |
| 280 | } |
Varun Arora | 75c05f0 | 2019-05-14 14:53:37 -0700 | [diff] [blame] | 281 | virtual HWC2::Error SetPanelBrightness(float brightness) { |
| 282 | return HWC2::Error::Unsupported; |
| 283 | } |
| 284 | virtual HWC2::Error GetPanelBrightness(float *brightness) { |
| 285 | return HWC2::Error::Unsupported; |
| 286 | } |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 287 | virtual HWC2::Error GetDisplayConfigs(uint32_t *out_num_configs, hwc2_config_t *out_configs); |
| 288 | virtual HWC2::Error GetDisplayAttribute(hwc2_config_t config, HWC2::Attribute attribute, |
| 289 | int32_t *out_value); |
| 290 | virtual HWC2::Error GetClientTargetSupport(uint32_t width, uint32_t height, int32_t format, |
| 291 | int32_t dataspace); |
Naseer Ahmed | e7a7798 | 2018-06-04 10:56:04 -0400 | [diff] [blame] | 292 | virtual HWC2::Error GetColorModes(uint32_t *outNumModes, ColorMode *outModes); |
| 293 | virtual HWC2::Error GetRenderIntents(ColorMode mode, uint32_t *out_num_intents, |
| 294 | RenderIntent *out_intents); |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 295 | virtual HWC2::Error GetChangedCompositionTypes(uint32_t *out_num_elements, |
| 296 | hwc2_layer_t *out_layers, int32_t *out_types); |
| 297 | virtual HWC2::Error GetDisplayRequests(int32_t *out_display_requests, uint32_t *out_num_elements, |
| 298 | hwc2_layer_t *out_layers, int32_t *out_layer_requests); |
| 299 | virtual HWC2::Error GetDisplayName(uint32_t *out_size, char *out_name); |
| 300 | virtual HWC2::Error GetDisplayType(int32_t *out_type); |
| 301 | virtual HWC2::Error SetCursorPosition(hwc2_layer_t layer, int x, int y); |
| 302 | virtual HWC2::Error SetVsyncEnabled(HWC2::Vsync enabled); |
Varun Arora | 78580b8 | 2018-09-10 13:59:57 -0700 | [diff] [blame] | 303 | virtual HWC2::Error SetPowerMode(HWC2::PowerMode mode, bool teardown); |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 304 | virtual HWC2::Error CreateLayer(hwc2_layer_t *out_layer_id); |
| 305 | virtual HWC2::Error DestroyLayer(hwc2_layer_t layer_id); |
| 306 | virtual HWC2::Error SetLayerZOrder(hwc2_layer_t layer_id, uint32_t z); |
| 307 | virtual HWC2::Error Validate(uint32_t *out_num_types, uint32_t *out_num_requests) = 0; |
| 308 | virtual HWC2::Error GetReleaseFences(uint32_t *out_num_elements, hwc2_layer_t *out_layers, |
| 309 | int32_t *out_fences); |
| 310 | virtual HWC2::Error Present(int32_t *out_retire_fence) = 0; |
Arun Kumar K.R | f28957a | 2017-01-10 17:36:52 -0800 | [diff] [blame] | 311 | virtual HWC2::Error GetHdrCapabilities(uint32_t *out_num_types, int32_t* out_types, |
| 312 | float* out_max_luminance, |
| 313 | float* out_max_average_luminance, |
| 314 | float* out_min_luminance); |
Naseer Ahmed | a6782e4 | 2018-06-04 10:56:04 -0400 | [diff] [blame] | 315 | virtual HWC2::Error GetPerFrameMetadataKeys(uint32_t *out_num_keys, |
| 316 | PerFrameMetadataKey *out_keys); |
Naseer Ahmed | a699e79 | 2017-11-09 15:08:31 -0500 | [diff] [blame] | 317 | virtual HWC2::Error SetDisplayAnimating(bool animating) { |
| 318 | animating_ = animating; |
Ramkumar Radhakrishnan | ae338ae | 2017-11-27 21:27:25 -0800 | [diff] [blame] | 319 | validated_ = false; |
Naseer Ahmed | a699e79 | 2017-11-09 15:08:31 -0500 | [diff] [blame] | 320 | return HWC2::Error::None; |
| 321 | } |
Sushil Chauhan | e3a9fd0 | 2017-10-12 18:00:05 -0700 | [diff] [blame] | 322 | virtual HWC2::Error GetValidateDisplayOutput(uint32_t *out_num_types, uint32_t *out_num_requests); |
Ramkumar Radhakrishnan | a38b760 | 2018-03-15 14:49:52 -0700 | [diff] [blame] | 323 | virtual bool IsDisplayCommandMode(); |
Sushil Chauhan | 380a59d | 2018-03-19 15:47:50 -0700 | [diff] [blame] | 324 | virtual HWC2::Error SetQSyncMode(QSyncMode qsync_mode) { |
| 325 | return HWC2::Error::Unsupported; |
| 326 | } |
Ramkumar Radhakrishnan | 4faf8a6 | 2018-11-15 17:15:37 -0800 | [diff] [blame] | 327 | virtual DisplayError ControlIdlePowerCollapse(bool enable, bool synchronous) { |
| 328 | return kErrorNone; |
Ramkumar Radhakrishnan | f985d48 | 2018-07-23 18:10:41 -0700 | [diff] [blame] | 329 | } |
Varun Arora | 6ba9eda | 2019-02-07 17:59:32 -0800 | [diff] [blame] | 330 | virtual HWC2::Error GetDisplayIdentificationData(uint8_t *out_port, uint32_t *out_data_size, |
| 331 | uint8_t *out_data); |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 332 | |
| 333 | protected: |
Mahesh Aia | f3a1f99 | 2019-01-16 13:07:42 -0800 | [diff] [blame] | 334 | static uint32_t throttling_refresh_rate_; |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 335 | // Maximum number of layers supported by display manager. |
| 336 | static const uint32_t kMaxLayerCount = 32; |
Dileep Marchya | f3ce11f | 2018-04-30 23:35:46 +0530 | [diff] [blame] | 337 | HWCDisplay(CoreInterface *core_intf, BufferAllocator *buffer_allocator, HWCCallbacks *callbacks, |
| 338 | HWCDisplayEventHandler *event_handler, qService::QService *qservice, DisplayType type, |
Gousemoodhin Nadaf | 087c310 | 2019-01-07 19:34:56 +0530 | [diff] [blame] | 339 | hwc2_display_t id, int32_t sdm_id, DisplayClass display_class); |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 340 | |
| 341 | // DisplayEventHandler methods |
| 342 | virtual DisplayError VSync(const DisplayEventVSync &vsync); |
| 343 | virtual DisplayError Refresh(); |
| 344 | virtual DisplayError CECMessage(char *message); |
Sushil Chauhan | 409e844 | 2017-06-12 17:43:25 -0700 | [diff] [blame] | 345 | virtual DisplayError HandleEvent(DisplayEvent event); |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 346 | virtual void DumpOutputBuffer(const BufferInfo &buffer_info, void *base, int fence); |
| 347 | virtual HWC2::Error PrepareLayerStack(uint32_t *out_num_types, uint32_t *out_num_requests); |
| 348 | virtual HWC2::Error CommitLayerStack(void); |
| 349 | virtual HWC2::Error PostCommitLayerStack(int32_t *out_retire_fence); |
Arun Kumar K.R | 17bbd04 | 2016-06-07 17:38:02 -0700 | [diff] [blame] | 350 | virtual DisplayError DisablePartialUpdateOneFrame() { |
| 351 | return kErrorNotSupported; |
| 352 | } |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 353 | const char *GetDisplayString(); |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 354 | void MarkLayersForGPUBypass(void); |
Arun Kumar K.R | 29cd658 | 2016-05-10 19:12:45 -0700 | [diff] [blame] | 355 | void MarkLayersForClientComposition(void); |
Pullakavi Srinivas | 9189e60 | 2018-12-19 16:58:07 +0530 | [diff] [blame] | 356 | void UpdateConfigs(); |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 357 | virtual void ApplyScanAdjustment(hwc_rect_t *display_frame); |
Ramakant Singh | 5db0dfb | 2017-08-23 12:34:57 +0530 | [diff] [blame] | 358 | uint32_t GetUpdatingLayersCount(void); |
Sushil Chauhan | 9735cf8 | 2018-07-10 12:06:01 -0700 | [diff] [blame] | 359 | bool IsLayerUpdating(HWCLayer *layer); |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 360 | uint32_t SanitizeRefreshRate(uint32_t req_refresh_rate); |
Sushil Chauhan | 409e844 | 2017-06-12 17:43:25 -0700 | [diff] [blame] | 361 | virtual void GetUnderScanConfig() { } |
Arun Kumar K.R | 5b82155 | 2018-12-07 08:00:15 +0530 | [diff] [blame] | 362 | int32_t SetClientTargetDataSpace(int32_t dataspace); |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 363 | |
| 364 | enum { |
| 365 | INPUT_LAYER_DUMP, |
| 366 | OUTPUT_LAYER_DUMP, |
| 367 | }; |
| 368 | |
Saurabh Shah | a307e8c | 2017-09-28 18:05:40 -0700 | [diff] [blame] | 369 | bool validated_ = false; |
Saurabh Shah | dccc0f4 | 2018-01-15 15:59:56 -0800 | [diff] [blame] | 370 | bool layer_stack_invalid_ = true; |
Naseer Ahmed | 72dea24 | 2016-05-03 19:13:07 -0400 | [diff] [blame] | 371 | CoreInterface *core_intf_ = nullptr; |
Dileep Marchya | f3ce11f | 2018-04-30 23:35:46 +0530 | [diff] [blame] | 372 | HWCBufferAllocator *buffer_allocator_ = NULL; |
Naseer Ahmed | 72dea24 | 2016-05-03 19:13:07 -0400 | [diff] [blame] | 373 | HWCCallbacks *callbacks_ = nullptr; |
Varun Arora | 7c8ee54 | 2018-05-01 20:58:16 -0700 | [diff] [blame] | 374 | HWCDisplayEventHandler *event_handler_ = nullptr; |
Dileep Marchya | f3ce11f | 2018-04-30 23:35:46 +0530 | [diff] [blame] | 375 | DisplayType type_ = kDisplayTypeMax; |
| 376 | hwc2_display_t id_ = UINT64_MAX; |
| 377 | int32_t sdm_id_ = -1; |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 378 | DisplayInterface *display_intf_ = NULL; |
| 379 | LayerStack layer_stack_; |
Naseer Ahmed | 72dea24 | 2016-05-03 19:13:07 -0400 | [diff] [blame] | 380 | HWCLayer *client_target_ = nullptr; // Also known as framebuffer target |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 381 | std::map<hwc2_layer_t, HWCLayer *> layer_map_; // Look up by Id - TODO |
| 382 | std::multiset<HWCLayer *, SortLayersByZ> layer_set_; // Maintain a set sorted by Z |
| 383 | std::map<hwc2_layer_t, HWC2::Composition> layer_changes_; |
| 384 | std::map<hwc2_layer_t, HWC2::LayerRequest> layer_requests_; |
| 385 | bool flush_on_error_ = false; |
| 386 | bool flush_ = false; |
| 387 | uint32_t dump_frame_count_ = 0; |
| 388 | uint32_t dump_frame_index_ = 0; |
| 389 | bool dump_input_layers_ = false; |
Varun Arora | f027a22 | 2018-11-14 17:38:16 -0800 | [diff] [blame] | 390 | HWC2::PowerMode current_power_mode_ = HWC2::PowerMode::Off; |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 391 | bool swap_interval_zero_ = false; |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 392 | bool display_paused_ = false; |
| 393 | uint32_t min_refresh_rate_ = 0; |
| 394 | uint32_t max_refresh_rate_ = 0; |
| 395 | uint32_t current_refresh_rate_ = 0; |
| 396 | bool use_metadata_refresh_rate_ = false; |
| 397 | uint32_t metadata_refresh_rate_ = 0; |
| 398 | uint32_t force_refresh_rate_ = 0; |
| 399 | bool boot_animation_completed_ = false; |
| 400 | bool shutdown_pending_ = false; |
Ramkumar Radhakrishnan | a38b760 | 2018-03-15 14:49:52 -0700 | [diff] [blame] | 401 | std::bitset<kSecureMax> active_secure_sessions_ = 0; |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 402 | bool solid_fill_enable_ = false; |
Arun Kumar K.R | 536c7d6 | 2016-06-14 18:47:39 -0700 | [diff] [blame] | 403 | Layer *solid_fill_layer_ = NULL; |
| 404 | LayerRect solid_fill_rect_ = {}; |
Gopikrishnaiah Anandan | cc12306 | 2017-07-31 17:21:03 -0700 | [diff] [blame] | 405 | LayerSolidFill solid_fill_color_ = {}; |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 406 | LayerRect display_rect_; |
Arun Kumar K.R | 29cd658 | 2016-05-10 19:12:45 -0700 | [diff] [blame] | 407 | bool color_tranform_failed_ = false; |
| 408 | HWCColorMode *color_mode_ = NULL; |
Arun Kumar K.R | 51be3d1 | 2017-03-31 19:54:38 -0700 | [diff] [blame] | 409 | HWCToneMapper *tone_mapper_ = nullptr; |
Rajavenu Kyatham | 40fc538 | 2017-07-12 18:36:55 +0530 | [diff] [blame] | 410 | uint32_t num_configs_ = 0; |
Arun Kumar K.R | 2be0bf8 | 2017-05-24 15:14:41 +0530 | [diff] [blame] | 411 | int disable_hdr_handling_ = 0; // disables HDR handling. |
Namit Solanki | 5b428dc | 2018-02-27 11:39:05 +0530 | [diff] [blame] | 412 | bool pending_commit_ = false; |
Tharaga Balachandran | 04192a6 | 2018-08-29 16:23:25 -0400 | [diff] [blame] | 413 | bool is_cmd_mode_ = false; |
| 414 | bool partial_update_enabled_ = false; |
Sushil Chauhan | 7bd2066 | 2018-08-20 17:51:32 -0700 | [diff] [blame] | 415 | bool fast_path_composition_ = false; |
Padmanabhan Komanduru | e74cf4f | 2019-04-25 17:38:43 -0700 | [diff] [blame] | 416 | bool skip_commit_ = false; |
Pullakavi Srinivas | 9189e60 | 2018-12-19 16:58:07 +0530 | [diff] [blame] | 417 | std::map<uint32_t, DisplayConfigVariableInfo> variable_config_map_; |
| 418 | std::vector<uint32_t> hwc_config_map_; |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 419 | |
| 420 | private: |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 421 | void DumpInputBuffers(void); |
Sushil Chauhan | 36c059a | 2018-06-28 11:39:01 -0700 | [diff] [blame] | 422 | bool CanSkipSdmPrepare(uint32_t *num_types, uint32_t *num_requests); |
Pullakavi Srinivas | 3dbb0d9 | 2018-03-07 15:15:14 +0530 | [diff] [blame] | 423 | void UpdateRefreshRate(); |
Rajavenu Kyatham | af26f40 | 2019-02-13 15:04:03 +0530 | [diff] [blame] | 424 | void WaitOnPreviousFence(); |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 425 | qService::QService *qservice_ = NULL; |
| 426 | DisplayClass display_class_; |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 427 | uint32_t geometry_changes_ = GeometryChanges::kNone; |
Naseer Ahmed | a699e79 | 2017-11-09 15:08:31 -0500 | [diff] [blame] | 428 | bool animating_ = false; |
Varun Arora | 465c1f7 | 2018-02-08 16:18:50 -0800 | [diff] [blame] | 429 | int null_display_mode_ = 0; |
Sushil Chauhan | e3a9fd0 | 2017-10-12 18:00:05 -0700 | [diff] [blame] | 430 | bool has_client_composition_ = false; |
| 431 | DisplayValidateState validate_state_ = kNormalValidate; |
Sushil Chauhan | 7bd2066 | 2018-08-20 17:51:32 -0700 | [diff] [blame] | 432 | bool fast_path_enabled_ = true; |
Mathew Joseph Karimpanal | abe3b3d | 2018-11-27 17:25:40 +0530 | [diff] [blame] | 433 | bool first_cycle_ = true; // false if a display commit has succeeded on the device. |
Rajavenu Kyatham | 9d50958 | 2019-02-13 15:29:55 +0530 | [diff] [blame] | 434 | int fbt_release_fence_ = -1; |
Naseer Ahmed | b92e73f | 2016-03-12 02:03:48 -0500 | [diff] [blame] | 435 | }; |
| 436 | |
| 437 | inline int HWCDisplay::Perform(uint32_t operation, ...) { |
| 438 | return 0; |
| 439 | } |
| 440 | |
| 441 | } // namespace sdm |
| 442 | |
| 443 | #endif // __HWC_DISPLAY_H__ |