1 /*
2 * Copyright (c) 2014-2019, The Linux Foundation. All rights reserved.
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
23 #include <QService.h>
24 #include <android/hardware/graphics/common/1.1/types.h>
25 #include <core/core_interface.h>
26 #include <hardware/hwcomposer.h>
27 #include <private/color_params.h>
28 #include <qdMetaData.h>
29 #include <sys/stat.h>
30 #include <map>
31 #include <queue>
32 #include <set>
33 #include <string>
34 #include <utility>
35 #include <vector>
36 #include <bitset>
37 #include <algorithm>
38 #include "hwc_buffer_allocator.h"
39 #include "hwc_callbacks.h"
40 #include "hwc_layers.h"
41 #include "display_null.h"
42 #include "hwc_display_event_handler.h"
43 #include "histogram_collector.h"
44
45 using android::hardware::graphics::common::V1_1::ColorMode;
46 using android::hardware::graphics::common::V1_1::Dataspace;
47 using android::hardware::graphics::common::V1_1::RenderIntent;
48
49 namespace sdm {
50
51 class BlitEngine;
52 class HWCToneMapper;
53
54 // Subclasses set this to their type. This has to be different from DisplayType.
55 // This is to avoid RTTI and dynamic_cast
56 enum DisplayClass {
57 DISPLAY_CLASS_BUILTIN,
58 DISPLAY_CLASS_PLUGGABLE,
59 DISPLAY_CLASS_VIRTUAL,
60 DISPLAY_CLASS_NULL
61 };
62
63 enum SecureSessionType {
64 kSecureDisplay,
65 kSecureCamera,
66 kSecureMax,
67 };
68
69 class HWCColorMode {
70 public:
71 explicit HWCColorMode(DisplayInterface *display_intf);
~HWCColorMode()72 ~HWCColorMode() {}
73 HWC2::Error Init();
74 HWC2::Error DeInit();
75 void Dump(std::ostringstream* os);
76 uint32_t GetColorModeCount();
77 uint32_t GetRenderIntentCount(ColorMode mode);
78 HWC2::Error GetColorModes(uint32_t *out_num_modes, ColorMode *out_modes);
79 HWC2::Error GetRenderIntents(ColorMode mode, uint32_t *out_num_intents, RenderIntent *out_modes);
80 HWC2::Error SetColorModeWithRenderIntent(ColorMode mode, RenderIntent intent);
81 HWC2::Error SetColorModeById(int32_t color_mode_id);
82 HWC2::Error SetColorModeFromClientApi(std::string mode_string);
83 HWC2::Error SetColorTransform(const float *matrix, android_color_transform_t hint);
84 HWC2::Error RestoreColorTransform();
GetCurrentColorMode()85 ColorMode GetCurrentColorMode() { return current_color_mode_; }
86 HWC2::Error ApplyCurrentColorModeWithRenderIntent(bool hdr_present);
87 HWC2::Error CacheColorModeWithRenderIntent(ColorMode mode, RenderIntent intent);
88
89 private:
90 static const uint32_t kColorTransformMatrixCount = 16;
91 void PopulateColorModes();
92 template <class T>
CopyColorTransformMatrix(const T * input_matrix,double * output_matrix)93 void CopyColorTransformMatrix(const T *input_matrix, double *output_matrix) {
94 for (uint32_t i = 0; i < kColorTransformMatrixCount; i++) {
95 output_matrix[i] = static_cast<double>(input_matrix[i]);
96 }
97 }
98 HWC2::Error ValidateColorModeWithRenderIntent(ColorMode mode, RenderIntent intent);
99 HWC2::Error SetPreferredColorModeInternal(const std::string &mode_string, bool from_client,
100 ColorMode *color_mode, DynamicRangeType *dynamic_range);
101
102 DisplayInterface *display_intf_ = NULL;
103 bool apply_mode_ = false;
104 ColorMode current_color_mode_ = ColorMode::NATIVE;
105 RenderIntent current_render_intent_ = RenderIntent::COLORIMETRIC;
106 DynamicRangeType curr_dynamic_range_ = kSdrType;
107 typedef std::map<DynamicRangeType, std::string> DynamicRangeMap;
108 typedef std::map<RenderIntent, DynamicRangeMap> RenderIntentMap;
109 // Initialize supported mode/render intent/dynamic range combination
110 std::map<ColorMode, RenderIntentMap> color_mode_map_ = {};
111 double color_matrix_[kColorTransformMatrixCount] = { 1.0, 0.0, 0.0, 0.0, \
112 0.0, 1.0, 0.0, 0.0, \
113 0.0, 0.0, 1.0, 0.0, \
114 0.0, 0.0, 0.0, 1.0 };
115 std::map<ColorMode, DynamicRangeMap> preferred_mode_ = {};
116 };
117
118 class HWCDisplay : public DisplayEventHandler {
119 public:
120 enum DisplayStatus {
121 kDisplayStatusInvalid = -1,
122 kDisplayStatusOffline,
123 kDisplayStatusOnline,
124 kDisplayStatusPause,
125 kDisplayStatusResume,
126 };
127
128 enum DisplayValidateState {
129 kNormalValidate,
130 kInternalValidate,
131 kSkipValidate,
132 };
133
~HWCDisplay()134 virtual ~HWCDisplay() {}
135 virtual int Init();
136 virtual int Deinit();
137
138 // Framebuffer configurations
139 virtual void SetIdleTimeoutMs(uint32_t timeout_ms);
140 virtual HWC2::Error SetFrameDumpConfig(uint32_t count, uint32_t bit_mask_layer_type,
141 int32_t format, bool post_processed);
142 virtual DisplayError SetMaxMixerStages(uint32_t max_mixer_stages);
ControlPartialUpdate(bool enable,uint32_t * pending)143 virtual DisplayError ControlPartialUpdate(bool enable, uint32_t *pending) {
144 return kErrorNotSupported;
145 }
146 virtual HWC2::PowerMode GetCurrentPowerMode();
147 virtual int SetFrameBufferResolution(uint32_t x_pixels, uint32_t y_pixels);
148 virtual void GetFrameBufferResolution(uint32_t *x_pixels, uint32_t *y_pixels);
149 virtual int SetDisplayStatus(DisplayStatus display_status);
150 virtual int OnMinHdcpEncryptionLevelChange(uint32_t min_enc_level);
151 virtual int Perform(uint32_t operation, ...);
152 virtual int HandleSecureSession(const std::bitset<kSecureMax> &secure_sessions,
153 bool *power_on_pending);
154 virtual int GetActiveSecureSession(std::bitset<kSecureMax> *secure_sessions);
155 virtual DisplayError SetMixerResolution(uint32_t width, uint32_t height);
156 virtual DisplayError GetMixerResolution(uint32_t *width, uint32_t *height);
157 virtual void GetPanelResolution(uint32_t *width, uint32_t *height);
158 virtual std::string Dump();
TeardownConcurrentWriteback(void)159 virtual DisplayError TeardownConcurrentWriteback(void) {
160 return kErrorNotSupported;
161 }
162
163 // Captures frame output in the buffer specified by output_buffer_info. The API is
164 // non-blocking and the client is expected to check operation status later on.
165 // Returns -1 if the input is invalid.
FrameCaptureAsync(const BufferInfo & output_buffer_info,bool post_processed)166 virtual int FrameCaptureAsync(const BufferInfo &output_buffer_info, bool post_processed) {
167 return -1;
168 }
169 // Returns the status of frame capture operation requested with FrameCaptureAsync().
170 // -EAGAIN : No status obtain yet, call API again after another frame.
171 // < 0 : Operation happened but failed.
172 // 0 : Success.
GetFrameCaptureStatus()173 virtual int GetFrameCaptureStatus() { return -EAGAIN; }
174
SetDetailEnhancerConfig(const DisplayDetailEnhancerData & de_data)175 virtual DisplayError SetDetailEnhancerConfig(const DisplayDetailEnhancerData &de_data) {
176 return kErrorNotSupported;
177 }
SetReadbackBuffer(const native_handle_t * buffer,int32_t acquire_fence,bool post_processed_output)178 virtual HWC2::Error SetReadbackBuffer(const native_handle_t *buffer, int32_t acquire_fence,
179 bool post_processed_output) {
180 return HWC2::Error::Unsupported;
181 }
GetReadbackBufferFence(int32_t * release_fence)182 virtual HWC2::Error GetReadbackBufferFence(int32_t *release_fence) {
183 return HWC2::Error::Unsupported;
184 }
185
SetDisplayDppsAdROI(uint32_t h_start,uint32_t h_end,uint32_t v_start,uint32_t v_end,uint32_t factor_in,uint32_t factor_out)186 virtual HWC2::Error SetDisplayDppsAdROI(uint32_t h_start, uint32_t h_end,
187 uint32_t v_start, uint32_t v_end,
188 uint32_t factor_in, uint32_t factor_out) {
189 return HWC2::Error::Unsupported;
190 }
191
192 // Display Configurations
GetThrottlingRefreshRate()193 static uint32_t GetThrottlingRefreshRate() { return HWCDisplay::throttling_refresh_rate_; }
SetThrottlingRefreshRate(uint32_t newRefreshRate)194 static void SetThrottlingRefreshRate(uint32_t newRefreshRate)
195 { HWCDisplay::throttling_refresh_rate_ = newRefreshRate; }
196 virtual int SetActiveDisplayConfig(uint32_t config);
197 virtual int GetActiveDisplayConfig(uint32_t *config);
198 virtual int GetDisplayConfigCount(uint32_t *count);
199 virtual int GetDisplayAttributesForConfig(int config,
200 DisplayConfigVariableInfo *display_attributes);
SetState(bool connected)201 virtual int SetState(bool connected) {
202 return kErrorNotSupported;
203 }
Flush()204 virtual DisplayError Flush() {
205 return kErrorNotSupported;
206 }
207
GetMaxRefreshRate()208 uint32_t GetMaxRefreshRate() { return max_refresh_rate_; }
209 int SetPanelBrightness(int level);
210 int GetPanelBrightness(int *level);
211 int ToggleScreenUpdates(bool enable);
212 int ColorSVCRequestRoute(const PPDisplayAPIPayload &in_payload, PPDisplayAPIPayload *out_payload,
213 PPPendingParams *pending_action);
214 void SolidFillPrepare();
215 void SolidFillCommit();
216 DisplayClass GetDisplayClass();
217 int GetVisibleDisplayRect(hwc_rect_t *rect);
218 void BuildLayerStack(void);
219 void BuildSolidFillStack(void);
220 HWCLayer *GetHWCLayer(hwc2_layer_t layer_id);
ResetValidation()221 void ResetValidation() { validated_ = false; }
GetGeometryChanges()222 uint32_t GetGeometryChanges() { return geometry_changes_; }
223 bool CanSkipValidate();
IsSkipValidateState()224 bool IsSkipValidateState() { return (validate_state_ == kSkipValidate); }
IsInternalValidateState()225 bool IsInternalValidateState() { return (validated_ && (validate_state_ == kInternalValidate)); }
SetValidationState(DisplayValidateState state)226 void SetValidationState(DisplayValidateState state) { validate_state_ = state; }
GetCurrentColorMode()227 ColorMode GetCurrentColorMode() {
228 return (color_mode_ ? color_mode_->GetCurrentColorMode() : ColorMode::SRGB);
229 }
HasClientComposition()230 bool HasClientComposition() { return has_client_composition_; }
HWCClientNeedsValidate()231 bool HWCClientNeedsValidate() {
232 return (has_client_composition_ || layer_stack_.flags.single_buffered_layer_present);
233 }
SetFastPathComposition(bool enable)234 virtual void SetFastPathComposition(bool enable) { fast_path_composition_ = enable; }
SetColorModeFromClientApi(int32_t color_mode_id)235 virtual HWC2::Error SetColorModeFromClientApi(int32_t color_mode_id) {
236 return HWC2::Error::Unsupported;
237 }
IsFirstCommitDone()238 bool IsFirstCommitDone() { return !first_cycle_; }
239
240 // HWC2 APIs
241 virtual HWC2::Error AcceptDisplayChanges(void);
242 virtual HWC2::Error GetActiveConfig(hwc2_config_t *out_config);
243 virtual HWC2::Error SetActiveConfig(hwc2_config_t config);
244 virtual HWC2::Error SetClientTarget(buffer_handle_t target, int32_t acquire_fence,
245 int32_t dataspace, hwc_region_t damage);
SetColorMode(ColorMode mode)246 virtual HWC2::Error SetColorMode(ColorMode mode) { return HWC2::Error::Unsupported; }
SetColorModeWithRenderIntent(ColorMode mode,RenderIntent intent)247 virtual HWC2::Error SetColorModeWithRenderIntent(ColorMode mode, RenderIntent intent) {
248 return HWC2::Error::Unsupported;
249 }
SetColorModeById(int32_t color_mode_id)250 virtual HWC2::Error SetColorModeById(int32_t color_mode_id) {
251 return HWC2::Error::Unsupported;
252 }
RestoreColorTransform()253 virtual HWC2::Error RestoreColorTransform() {
254 return HWC2::Error::Unsupported;
255 }
SetColorTransform(const float * matrix,android_color_transform_t hint)256 virtual HWC2::Error SetColorTransform(const float *matrix, android_color_transform_t hint) {
257 return HWC2::Error::Unsupported;
258 }
HandleColorModeTransform(android_color_mode_t mode,android_color_transform_t hint,const double * matrix)259 virtual HWC2::Error HandleColorModeTransform(android_color_mode_t mode,
260 android_color_transform_t hint,
261 const double *matrix) {
262 return HWC2::Error::Unsupported;
263 }
SetDynamicDSIClock(uint64_t bitclk)264 virtual DisplayError SetDynamicDSIClock(uint64_t bitclk) {
265 return kErrorNotSupported;
266 }
GetDynamicDSIClock(uint64_t * bitclk)267 virtual DisplayError GetDynamicDSIClock(uint64_t *bitclk) {
268 return kErrorNotSupported;
269 }
GetSupportedDSIClock(std::vector<uint64_t> * bitclk)270 virtual DisplayError GetSupportedDSIClock(std::vector<uint64_t> *bitclk) {
271 return kErrorNotSupported;
272 }
UpdateDisplayId(hwc2_display_t id)273 virtual HWC2::Error UpdateDisplayId(hwc2_display_t id) {
274 return HWC2::Error::Unsupported;
275 }
SetPendingRefresh()276 virtual HWC2::Error SetPendingRefresh() {
277 return HWC2::Error::Unsupported;
278 }
279 virtual HWC2::Error GetDisplayConfigs(uint32_t *out_num_configs, hwc2_config_t *out_configs);
280 virtual HWC2::Error GetDisplayAttribute(hwc2_config_t config, HWC2::Attribute attribute,
281 int32_t *out_value);
282 virtual HWC2::Error GetClientTargetSupport(uint32_t width, uint32_t height, int32_t format,
283 int32_t dataspace);
284 virtual HWC2::Error GetColorModes(uint32_t *outNumModes, ColorMode *outModes);
285 virtual HWC2::Error GetRenderIntents(ColorMode mode, uint32_t *out_num_intents,
286 RenderIntent *out_intents);
287 virtual HWC2::Error GetChangedCompositionTypes(uint32_t *out_num_elements,
288 hwc2_layer_t *out_layers, int32_t *out_types);
289 virtual HWC2::Error GetDisplayRequests(int32_t *out_display_requests, uint32_t *out_num_elements,
290 hwc2_layer_t *out_layers, int32_t *out_layer_requests);
291 virtual HWC2::Error GetDisplayName(uint32_t *out_size, char *out_name);
292 virtual HWC2::Error GetDisplayType(int32_t *out_type);
293 virtual HWC2::Error SetCursorPosition(hwc2_layer_t layer, int x, int y);
294 virtual HWC2::Error SetVsyncEnabled(HWC2::Vsync enabled);
295 virtual HWC2::Error SetPowerMode(HWC2::PowerMode mode, bool teardown);
296 virtual HWC2::Error CreateLayer(hwc2_layer_t *out_layer_id);
297 virtual HWC2::Error DestroyLayer(hwc2_layer_t layer_id);
298 virtual HWC2::Error SetLayerZOrder(hwc2_layer_t layer_id, uint32_t z);
299 virtual HWC2::Error Validate(uint32_t *out_num_types, uint32_t *out_num_requests) = 0;
300 virtual HWC2::Error GetReleaseFences(uint32_t *out_num_elements, hwc2_layer_t *out_layers,
301 int32_t *out_fences);
302 virtual HWC2::Error Present(int32_t *out_retire_fence) = 0;
303 virtual HWC2::Error GetHdrCapabilities(uint32_t *out_num_types, int32_t* out_types,
304 float* out_max_luminance,
305 float* out_max_average_luminance,
306 float* out_min_luminance);
307 virtual HWC2::Error GetPerFrameMetadataKeys(uint32_t *out_num_keys,
308 PerFrameMetadataKey *out_keys);
SetDisplayAnimating(bool animating)309 virtual HWC2::Error SetDisplayAnimating(bool animating) {
310 animating_ = animating;
311 validated_ = false;
312 return HWC2::Error::None;
313 }
314 virtual HWC2::Error GetValidateDisplayOutput(uint32_t *out_num_types, uint32_t *out_num_requests);
315 virtual bool IsDisplayCommandMode();
SetQSyncMode(QSyncMode qsync_mode)316 virtual HWC2::Error SetQSyncMode(QSyncMode qsync_mode) {
317 return HWC2::Error::Unsupported;
318 }
ControlIdlePowerCollapse(bool enable,bool synchronous)319 virtual DisplayError ControlIdlePowerCollapse(bool enable, bool synchronous) {
320 return kErrorNone;
321 }
322 virtual HWC2::Error GetDisplayIdentificationData(uint8_t *out_port, uint32_t *out_data_size,
323 uint8_t *out_data);
324
325 virtual HWC2::Error SetDisplayedContentSamplingEnabledVndService(bool enabled);
326 virtual HWC2::Error SetDisplayedContentSamplingEnabled(int32_t enabled, uint8_t component_mask, uint64_t max_frames);
327 virtual HWC2::Error GetDisplayedContentSamplingAttributes(int32_t* format,
328 int32_t* dataspace,
329 uint8_t* supported_components);
330 virtual HWC2::Error GetDisplayedContentSample(uint64_t max_frames,
331 uint64_t timestamp,
332 uint64_t* numFrames,
333 int32_t samples_size[NUM_HISTOGRAM_COLOR_COMPONENTS],
334 uint64_t* samples[NUM_HISTOGRAM_COLOR_COMPONENTS]);
335
336 protected:
337 static uint32_t throttling_refresh_rate_;
338 // Maximum number of layers supported by display manager.
339 static const uint32_t kMaxLayerCount = 32;
340 HWCDisplay(CoreInterface *core_intf, BufferAllocator *buffer_allocator, HWCCallbacks *callbacks,
341 HWCDisplayEventHandler *event_handler, qService::QService *qservice, DisplayType type,
342 hwc2_display_t id, int32_t sdm_id, bool needs_blit, DisplayClass display_class);
343
344 // DisplayEventHandler methods
345 virtual DisplayError VSync(const DisplayEventVSync &vsync);
346 virtual DisplayError Refresh();
347 virtual DisplayError CECMessage(char *message);
348 virtual DisplayError HistogramEvent(int source_fd, uint32_t blob_id) override;
349 virtual DisplayError HandleEvent(DisplayEvent event);
350 virtual void DumpOutputBuffer(const BufferInfo &buffer_info, void *base, int fence);
351 virtual HWC2::Error PrepareLayerStack(uint32_t *out_num_types, uint32_t *out_num_requests);
352 virtual HWC2::Error CommitLayerStack(void);
353 virtual HWC2::Error PostCommitLayerStack(int32_t *out_retire_fence);
DisablePartialUpdateOneFrame()354 virtual DisplayError DisablePartialUpdateOneFrame() {
355 return kErrorNotSupported;
356 }
357 const char *GetDisplayString();
358 void MarkLayersForGPUBypass(void);
359 void MarkLayersForClientComposition(void);
360 void UpdateConfigs();
361 virtual void ApplyScanAdjustment(hwc_rect_t *display_frame);
362 uint32_t GetUpdatingLayersCount(void);
363 bool IsLayerUpdating(HWCLayer *layer);
364 uint32_t SanitizeRefreshRate(uint32_t req_refresh_rate);
GetUnderScanConfig()365 virtual void GetUnderScanConfig() { }
366 int32_t SetClientTargetDataSpace(int32_t dataspace);
367
368 enum {
369 INPUT_LAYER_DUMP,
370 OUTPUT_LAYER_DUMP,
371 };
372
373 bool validated_ = false;
374 bool layer_stack_invalid_ = true;
375 CoreInterface *core_intf_ = nullptr;
376 HWCBufferAllocator *buffer_allocator_ = NULL;
377 HWCCallbacks *callbacks_ = nullptr;
378 HWCDisplayEventHandler *event_handler_ = nullptr;
379 DisplayType type_ = kDisplayTypeMax;
380 hwc2_display_t id_ = UINT64_MAX;
381 int32_t sdm_id_ = -1;
382 bool needs_blit_ = false;
383 DisplayInterface *display_intf_ = NULL;
384 LayerStack layer_stack_;
385 HWCLayer *client_target_ = nullptr; // Also known as framebuffer target
386 std::map<hwc2_layer_t, HWCLayer *> layer_map_; // Look up by Id - TODO
387 std::multiset<HWCLayer *, SortLayersByZ> layer_set_; // Maintain a set sorted by Z
388 std::map<hwc2_layer_t, HWC2::Composition> layer_changes_;
389 std::map<hwc2_layer_t, HWC2::LayerRequest> layer_requests_;
390 bool flush_on_error_ = false;
391 bool flush_ = false;
392 uint32_t dump_frame_count_ = 0;
393 uint32_t dump_frame_index_ = 0;
394 bool dump_input_layers_ = false;
395 HWC2::PowerMode current_power_mode_ = HWC2::PowerMode::Off;
396 bool swap_interval_zero_ = false;
397 bool display_paused_ = false;
398 uint32_t min_refresh_rate_ = 0;
399 uint32_t max_refresh_rate_ = 0;
400 uint32_t current_refresh_rate_ = 0;
401 bool use_metadata_refresh_rate_ = false;
402 uint32_t metadata_refresh_rate_ = 0;
403 uint32_t force_refresh_rate_ = 0;
404 bool boot_animation_completed_ = false;
405 bool shutdown_pending_ = false;
406 bool use_blit_comp_ = false;
407 std::bitset<kSecureMax> active_secure_sessions_ = 0;
408 bool solid_fill_enable_ = false;
409 Layer *solid_fill_layer_ = NULL;
410 LayerRect solid_fill_rect_ = {};
411 LayerSolidFill solid_fill_color_ = {};
412 LayerRect display_rect_;
413 bool color_tranform_failed_ = false;
414 HWCColorMode *color_mode_ = NULL;
415 HWCToneMapper *tone_mapper_ = nullptr;
416 uint32_t num_configs_ = 0;
417 int disable_hdr_handling_ = 0; // disables HDR handling.
418 bool pending_commit_ = false;
419 bool is_cmd_mode_ = false;
420 bool partial_update_enabled_ = false;
421 bool skip_commit_ = false;
422 std::map<uint32_t, DisplayConfigVariableInfo> variable_config_map_;
423 std::vector<uint32_t> hwc_config_map_;
424 float hdr_largest_layer_px_ = 0.0f;
425 bool fast_path_composition_ = false;
426
427 private:
428 void DumpInputBuffers(void);
429 bool CanSkipSdmPrepare(uint32_t *num_types, uint32_t *num_requests);
430 void UpdateRefreshRate();
431 void WaitOnPreviousFence();
432 qService::QService *qservice_ = NULL;
433 DisplayClass display_class_;
434 uint32_t geometry_changes_ = GeometryChanges::kNone;
435 bool animating_ = false;
436 int null_display_mode_ = 0;
437 bool has_client_composition_ = false;
438 DisplayValidateState validate_state_ = kNormalValidate;
439 bool fast_path_enabled_ = true;
440 bool first_cycle_ = true; // false if a display commit has succeeded on the device.
441 int fbt_release_fence_ = -1;
442 };
443
Perform(uint32_t operation,...)444 inline int HWCDisplay::Perform(uint32_t operation, ...) {
445 return 0;
446 }
447
448 } // namespace sdm
449
450 #endif // __HWC_DISPLAY_H__
451