1 /*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #define ATRACE_TAG ATRACE_TAG_GRAPHICS
18 #define LOG_TAG "hwc-drm-two"
19
20 #include "drmdisplaycomposition.h"
21 #include "drmhwcomposer.h"
22 #include "drmhwctwo.h"
23 #include "platform.h"
24 #include "vsyncworker.h"
25
26 #include <inttypes.h>
27 #include <string>
28
29 #include <cutils/log.h>
30 #include <cutils/properties.h>
31 #include <hardware/hardware.h>
32 #include <hardware/hwcomposer2.h>
33
34 namespace android {
35
36 class DrmVsyncCallback : public VsyncCallback {
37 public:
DrmVsyncCallback(hwc2_callback_data_t data,hwc2_function_pointer_t hook)38 DrmVsyncCallback(hwc2_callback_data_t data, hwc2_function_pointer_t hook)
39 : data_(data), hook_(hook) {
40 }
41
Callback(int display,int64_t timestamp)42 void Callback(int display, int64_t timestamp) {
43 auto hook = reinterpret_cast<HWC2_PFN_VSYNC>(hook_);
44 hook(data_, display, timestamp);
45 }
46
47 private:
48 hwc2_callback_data_t data_;
49 hwc2_function_pointer_t hook_;
50 };
51
DrmHwcTwo()52 DrmHwcTwo::DrmHwcTwo() {
53 common.tag = HARDWARE_DEVICE_TAG;
54 common.version = HWC_DEVICE_API_VERSION_2_0;
55 common.close = HookDevClose;
56 getCapabilities = HookDevGetCapabilities;
57 getFunction = HookDevGetFunction;
58 }
59
Init()60 HWC2::Error DrmHwcTwo::Init() {
61 int ret = drm_.Init();
62 if (ret) {
63 ALOGE("Can't initialize drm object %d", ret);
64 return HWC2::Error::NoResources;
65 }
66
67 importer_.reset(Importer::CreateInstance(&drm_));
68 if (!importer_) {
69 ALOGE("Failed to create importer instance");
70 return HWC2::Error::NoResources;
71 }
72
73 ret = hw_get_module(GRALLOC_HARDWARE_MODULE_ID,
74 (const hw_module_t **)&gralloc_);
75 if (ret) {
76 ALOGE("Failed to open gralloc module %d", ret);
77 return HWC2::Error::NoResources;
78 }
79
80 displays_.emplace(std::piecewise_construct,
81 std::forward_as_tuple(HWC_DISPLAY_PRIMARY),
82 std::forward_as_tuple(&drm_, importer_, gralloc_,
83 HWC_DISPLAY_PRIMARY,
84 HWC2::DisplayType::Physical));
85
86 DrmCrtc *crtc = drm_.GetCrtcForDisplay(static_cast<int>(HWC_DISPLAY_PRIMARY));
87 if (!crtc) {
88 ALOGE("Failed to get crtc for display %d",
89 static_cast<int>(HWC_DISPLAY_PRIMARY));
90 return HWC2::Error::BadDisplay;
91 }
92
93 std::vector<DrmPlane *> display_planes;
94 for (auto &plane : drm_.planes()) {
95 if (plane->GetCrtcSupported(*crtc))
96 display_planes.push_back(plane.get());
97 }
98 displays_.at(HWC_DISPLAY_PRIMARY).Init(&display_planes);
99 return HWC2::Error::None;
100 }
101
102 template <typename... Args>
unsupported(char const * func,Args...)103 static inline HWC2::Error unsupported(char const *func, Args... /*args*/) {
104 ALOGV("Unsupported function: %s", func);
105 return HWC2::Error::Unsupported;
106 }
107
supported(char const * func)108 static inline void supported(char const *func) {
109 ALOGV("Supported function: %s", func);
110 }
111
CreateVirtualDisplay(uint32_t width,uint32_t height,int32_t * format,hwc2_display_t * display)112 HWC2::Error DrmHwcTwo::CreateVirtualDisplay(uint32_t width, uint32_t height,
113 int32_t *format,
114 hwc2_display_t *display) {
115 // TODO: Implement virtual display
116 return unsupported(__func__, width, height, format, display);
117 }
118
DestroyVirtualDisplay(hwc2_display_t display)119 HWC2::Error DrmHwcTwo::DestroyVirtualDisplay(hwc2_display_t display) {
120 // TODO: Implement virtual display
121 return unsupported(__func__, display);
122 }
123
Dump(uint32_t * size,char * buffer)124 void DrmHwcTwo::Dump(uint32_t *size, char *buffer) {
125 // TODO: Implement dump
126 unsupported(__func__, size, buffer);
127 }
128
GetMaxVirtualDisplayCount()129 uint32_t DrmHwcTwo::GetMaxVirtualDisplayCount() {
130 // TODO: Implement virtual display
131 unsupported(__func__);
132 return 0;
133 }
134
RegisterCallback(int32_t descriptor,hwc2_callback_data_t data,hwc2_function_pointer_t function)135 HWC2::Error DrmHwcTwo::RegisterCallback(int32_t descriptor,
136 hwc2_callback_data_t data,
137 hwc2_function_pointer_t function) {
138 supported(__func__);
139 auto callback = static_cast<HWC2::Callback>(descriptor);
140 callbacks_.emplace(callback, HwcCallback(data, function));
141
142 switch (callback) {
143 case HWC2::Callback::Hotplug: {
144 auto hotplug = reinterpret_cast<HWC2_PFN_HOTPLUG>(function);
145 hotplug(data, HWC_DISPLAY_PRIMARY,
146 static_cast<int32_t>(HWC2::Connection::Connected));
147 break;
148 }
149 case HWC2::Callback::Vsync: {
150 for (std::pair<const hwc2_display_t, DrmHwcTwo::HwcDisplay> &d :
151 displays_)
152 d.second.RegisterVsyncCallback(data, function);
153 break;
154 }
155 default:
156 break;
157 }
158 return HWC2::Error::None;
159 }
160
HwcDisplay(DrmResources * drm,std::shared_ptr<Importer> importer,const gralloc_module_t * gralloc,hwc2_display_t handle,HWC2::DisplayType type)161 DrmHwcTwo::HwcDisplay::HwcDisplay(DrmResources *drm,
162 std::shared_ptr<Importer> importer,
163 const gralloc_module_t *gralloc,
164 hwc2_display_t handle, HWC2::DisplayType type)
165 : drm_(drm),
166 importer_(importer),
167 gralloc_(gralloc),
168 handle_(handle),
169 type_(type) {
170 supported(__func__);
171 }
172
Init(std::vector<DrmPlane * > * planes)173 HWC2::Error DrmHwcTwo::HwcDisplay::Init(std::vector<DrmPlane *> *planes) {
174 supported(__func__);
175 planner_ = Planner::CreateInstance(drm_);
176 if (!planner_) {
177 ALOGE("Failed to create planner instance for composition");
178 return HWC2::Error::NoResources;
179 }
180
181 int display = static_cast<int>(handle_);
182 int ret = compositor_.Init(drm_, display);
183 if (ret) {
184 ALOGE("Failed display compositor init for display %d (%d)", display, ret);
185 return HWC2::Error::NoResources;
186 }
187
188 // Split up the given display planes into primary and overlay to properly
189 // interface with the composition
190 char use_overlay_planes_prop[PROPERTY_VALUE_MAX];
191 property_get("hwc.drm.use_overlay_planes", use_overlay_planes_prop, "1");
192 bool use_overlay_planes = atoi(use_overlay_planes_prop);
193 for (auto &plane : *planes) {
194 if (plane->type() == DRM_PLANE_TYPE_PRIMARY)
195 primary_planes_.push_back(plane);
196 else if (use_overlay_planes && (plane)->type() == DRM_PLANE_TYPE_OVERLAY)
197 overlay_planes_.push_back(plane);
198 }
199
200 crtc_ = drm_->GetCrtcForDisplay(display);
201 if (!crtc_) {
202 ALOGE("Failed to get crtc for display %d", display);
203 return HWC2::Error::BadDisplay;
204 }
205
206 connector_ = drm_->GetConnectorForDisplay(display);
207 if (!connector_) {
208 ALOGE("Failed to get connector for display %d", display);
209 return HWC2::Error::BadDisplay;
210 }
211
212 // Fetch the number of modes from the display
213 uint32_t num_configs;
214 HWC2::Error err = GetDisplayConfigs(&num_configs, NULL);
215 if (err != HWC2::Error::None || !num_configs)
216 return err;
217
218 // Grab the first mode, we'll choose this as the active mode
219 // TODO: Should choose the preferred mode here
220 hwc2_config_t default_config;
221 num_configs = 1;
222 err = GetDisplayConfigs(&num_configs, &default_config);
223 if (err != HWC2::Error::None)
224 return err;
225
226 ret = vsync_worker_.Init(drm_, display);
227 if (ret) {
228 ALOGE("Failed to create event worker for d=%d %d\n", display, ret);
229 return HWC2::Error::BadDisplay;
230 }
231
232 return SetActiveConfig(default_config);
233 }
234
RegisterVsyncCallback(hwc2_callback_data_t data,hwc2_function_pointer_t func)235 HWC2::Error DrmHwcTwo::HwcDisplay::RegisterVsyncCallback(
236 hwc2_callback_data_t data, hwc2_function_pointer_t func) {
237 supported(__func__);
238 auto callback = std::make_shared<DrmVsyncCallback>(data, func);
239 vsync_worker_.RegisterCallback(std::move(callback));
240 return HWC2::Error::None;
241 }
242
AcceptDisplayChanges()243 HWC2::Error DrmHwcTwo::HwcDisplay::AcceptDisplayChanges() {
244 supported(__func__);
245 uint32_t num_changes = 0;
246 for (std::pair<const hwc2_layer_t, DrmHwcTwo::HwcLayer> &l : layers_)
247 l.second.accept_type_change();
248 return HWC2::Error::None;
249 }
250
CreateLayer(hwc2_layer_t * layer)251 HWC2::Error DrmHwcTwo::HwcDisplay::CreateLayer(hwc2_layer_t *layer) {
252 supported(__func__);
253 layers_.emplace(static_cast<hwc2_layer_t>(layer_idx_), HwcLayer());
254 *layer = static_cast<hwc2_layer_t>(layer_idx_);
255 ++layer_idx_;
256 return HWC2::Error::None;
257 }
258
DestroyLayer(hwc2_layer_t layer)259 HWC2::Error DrmHwcTwo::HwcDisplay::DestroyLayer(hwc2_layer_t layer) {
260 supported(__func__);
261 layers_.erase(layer);
262 return HWC2::Error::None;
263 }
264
GetActiveConfig(hwc2_config_t * config)265 HWC2::Error DrmHwcTwo::HwcDisplay::GetActiveConfig(hwc2_config_t *config) {
266 supported(__func__);
267 DrmMode const &mode = connector_->active_mode();
268 if (mode.id() == 0)
269 return HWC2::Error::BadConfig;
270
271 *config = mode.id();
272 return HWC2::Error::None;
273 }
274
GetChangedCompositionTypes(uint32_t * num_elements,hwc2_layer_t * layers,int32_t * types)275 HWC2::Error DrmHwcTwo::HwcDisplay::GetChangedCompositionTypes(
276 uint32_t *num_elements, hwc2_layer_t *layers, int32_t *types) {
277 supported(__func__);
278 uint32_t num_changes = 0;
279 for (std::pair<const hwc2_layer_t, DrmHwcTwo::HwcLayer> &l : layers_) {
280 if (l.second.type_changed()) {
281 if (layers && num_changes < *num_elements)
282 layers[num_changes] = l.first;
283 if (types && num_changes < *num_elements)
284 types[num_changes] = static_cast<int32_t>(l.second.validated_type());
285 ++num_changes;
286 }
287 }
288 if (!layers && !types)
289 *num_elements = num_changes;
290 return HWC2::Error::None;
291 }
292
GetClientTargetSupport(uint32_t width,uint32_t height,int32_t,int32_t dataspace)293 HWC2::Error DrmHwcTwo::HwcDisplay::GetClientTargetSupport(uint32_t width,
294 uint32_t height,
295 int32_t /*format*/,
296 int32_t dataspace) {
297 supported(__func__);
298 std::pair<uint32_t, uint32_t> min = drm_->min_resolution();
299 std::pair<uint32_t, uint32_t> max = drm_->max_resolution();
300
301 if (width < min.first || height < min.second)
302 return HWC2::Error::Unsupported;
303
304 if (width > max.first || height > max.second)
305 return HWC2::Error::Unsupported;
306
307 if (dataspace != HAL_DATASPACE_UNKNOWN &&
308 dataspace != HAL_DATASPACE_STANDARD_UNSPECIFIED)
309 return HWC2::Error::Unsupported;
310
311 // TODO: Validate format can be handled by either GL or planes
312 return HWC2::Error::None;
313 }
314
GetColorModes(uint32_t * num_modes,int32_t * modes)315 HWC2::Error DrmHwcTwo::HwcDisplay::GetColorModes(uint32_t *num_modes,
316 int32_t *modes) {
317 supported(__func__);
318 if (!modes)
319 *num_modes = 1;
320
321 if (modes)
322 *modes = HAL_COLOR_MODE_NATIVE;
323
324 return HWC2::Error::None;
325 }
326
GetDisplayAttribute(hwc2_config_t config,int32_t attribute_in,int32_t * value)327 HWC2::Error DrmHwcTwo::HwcDisplay::GetDisplayAttribute(hwc2_config_t config,
328 int32_t attribute_in,
329 int32_t *value) {
330 supported(__func__);
331 auto mode =
332 std::find_if(connector_->modes().begin(), connector_->modes().end(),
333 [config](DrmMode const &m) { return m.id() == config; });
334 if (mode == connector_->modes().end()) {
335 ALOGE("Could not find active mode for %d", config);
336 return HWC2::Error::BadConfig;
337 }
338
339 static const int32_t kUmPerInch = 25400;
340 uint32_t mm_width = connector_->mm_width();
341 uint32_t mm_height = connector_->mm_height();
342 auto attribute = static_cast<HWC2::Attribute>(attribute_in);
343 switch (attribute) {
344 case HWC2::Attribute::Width:
345 *value = mode->h_display();
346 break;
347 case HWC2::Attribute::Height:
348 *value = mode->v_display();
349 break;
350 case HWC2::Attribute::VsyncPeriod:
351 // in nanoseconds
352 *value = 1000 * 1000 * 1000 / mode->v_refresh();
353 break;
354 case HWC2::Attribute::DpiX:
355 // Dots per 1000 inches
356 *value = mm_width ? (mode->h_display() * kUmPerInch) / mm_width : -1;
357 break;
358 case HWC2::Attribute::DpiY:
359 // Dots per 1000 inches
360 *value = mm_height ? (mode->v_display() * kUmPerInch) / mm_height : -1;
361 break;
362 default:
363 *value = -1;
364 return HWC2::Error::BadConfig;
365 }
366 return HWC2::Error::None;
367 }
368
GetDisplayConfigs(uint32_t * num_configs,hwc2_config_t * configs)369 HWC2::Error DrmHwcTwo::HwcDisplay::GetDisplayConfigs(uint32_t *num_configs,
370 hwc2_config_t *configs) {
371 supported(__func__);
372 // Since this callback is normally invoked twice (once to get the count, and
373 // once to populate configs), we don't really want to read the edid
374 // redundantly. Instead, only update the modes on the first invocation. While
375 // it's possible this will result in stale modes, it'll all come out in the
376 // wash when we try to set the active config later.
377 if (!configs) {
378 int ret = connector_->UpdateModes();
379 if (ret) {
380 ALOGE("Failed to update display modes %d", ret);
381 return HWC2::Error::BadDisplay;
382 }
383 }
384
385 auto num_modes = static_cast<uint32_t>(connector_->modes().size());
386 if (!configs) {
387 *num_configs = num_modes;
388 return HWC2::Error::None;
389 }
390
391 uint32_t idx = 0;
392 for (const DrmMode &mode : connector_->modes()) {
393 if (idx >= *num_configs)
394 break;
395 configs[idx++] = mode.id();
396 }
397 *num_configs = idx;
398 return HWC2::Error::None;
399 }
400
GetDisplayName(uint32_t * size,char * name)401 HWC2::Error DrmHwcTwo::HwcDisplay::GetDisplayName(uint32_t *size, char *name) {
402 supported(__func__);
403 std::ostringstream stream;
404 stream << "display-" << connector_->id();
405 std::string string = stream.str();
406 size_t length = string.length();
407 if (!name) {
408 *size = length;
409 return HWC2::Error::None;
410 }
411
412 *size = std::min<uint32_t>(static_cast<uint32_t>(length - 1), *size);
413 strncpy(name, string.c_str(), *size);
414 return HWC2::Error::None;
415 }
416
GetDisplayRequests(int32_t * display_requests,uint32_t * num_elements,hwc2_layer_t * layers,int32_t * layer_requests)417 HWC2::Error DrmHwcTwo::HwcDisplay::GetDisplayRequests(int32_t *display_requests,
418 uint32_t *num_elements,
419 hwc2_layer_t *layers,
420 int32_t *layer_requests) {
421 supported(__func__);
422 // TODO: I think virtual display should request
423 // HWC2_DISPLAY_REQUEST_WRITE_CLIENT_TARGET_TO_OUTPUT here
424 unsupported(__func__, display_requests, num_elements, layers, layer_requests);
425 *num_elements = 0;
426 return HWC2::Error::None;
427 }
428
GetDisplayType(int32_t * type)429 HWC2::Error DrmHwcTwo::HwcDisplay::GetDisplayType(int32_t *type) {
430 supported(__func__);
431 *type = static_cast<int32_t>(type_);
432 return HWC2::Error::None;
433 }
434
GetDozeSupport(int32_t * support)435 HWC2::Error DrmHwcTwo::HwcDisplay::GetDozeSupport(int32_t *support) {
436 supported(__func__);
437 *support = 0;
438 return HWC2::Error::None;
439 }
440
GetHdrCapabilities(uint32_t * num_types,int32_t *,float *,float *,float *)441 HWC2::Error DrmHwcTwo::HwcDisplay::GetHdrCapabilities(
442 uint32_t *num_types, int32_t */*types*/, float */*max_luminance*/,
443 float */*max_average_luminance*/, float */*min_luminance*/) {
444 supported(__func__);
445 *num_types = 0;
446 return HWC2::Error::None;
447 }
448
GetReleaseFences(uint32_t * num_elements,hwc2_layer_t * layers,int32_t * fences)449 HWC2::Error DrmHwcTwo::HwcDisplay::GetReleaseFences(uint32_t *num_elements,
450 hwc2_layer_t *layers,
451 int32_t *fences) {
452 supported(__func__);
453 uint32_t num_layers = 0;
454
455 for (std::pair<const hwc2_layer_t, DrmHwcTwo::HwcLayer> &l : layers_) {
456 ++num_layers;
457 if (layers == NULL || fences == NULL) {
458 continue;
459 } else if (num_layers > *num_elements) {
460 ALOGW("Overflow num_elements %d/%d", num_layers, *num_elements);
461 return HWC2::Error::None;
462 }
463
464 layers[num_layers - 1] = l.first;
465 fences[num_layers - 1] = l.second.take_release_fence();
466 }
467 *num_elements = num_layers;
468 return HWC2::Error::None;
469 }
470
AddFenceToRetireFence(int fd)471 void DrmHwcTwo::HwcDisplay::AddFenceToRetireFence(int fd) {
472 supported(__func__);
473 if (fd < 0)
474 return;
475
476 if (next_retire_fence_.get() >= 0) {
477 int old_fence = next_retire_fence_.get();
478 next_retire_fence_.Set(sync_merge("dc_retire", old_fence, fd));
479 } else {
480 next_retire_fence_.Set(dup(fd));
481 }
482 }
483
PresentDisplay(int32_t * retire_fence)484 HWC2::Error DrmHwcTwo::HwcDisplay::PresentDisplay(int32_t *retire_fence) {
485 supported(__func__);
486 std::vector<DrmCompositionDisplayLayersMap> layers_map;
487 layers_map.emplace_back();
488 DrmCompositionDisplayLayersMap &map = layers_map.back();
489
490 map.display = static_cast<int>(handle_);
491 map.geometry_changed = true; // TODO: Fix this
492
493 // order the layers by z-order
494 bool use_client_layer = false;
495 uint32_t client_z_order = 0;
496 std::map<uint32_t, DrmHwcTwo::HwcLayer *> z_map;
497 for (std::pair<const hwc2_layer_t, DrmHwcTwo::HwcLayer> &l : layers_) {
498 switch (l.second.validated_type()) {
499 case HWC2::Composition::Device:
500 z_map.emplace(std::make_pair(l.second.z_order(), &l.second));
501 break;
502 case HWC2::Composition::Client:
503 // Place it at the z_order of the highest client layer
504 use_client_layer = true;
505 client_z_order = std::max(client_z_order, l.second.z_order());
506 break;
507 default:
508 continue;
509 }
510 }
511 if (use_client_layer)
512 z_map.emplace(std::make_pair(client_z_order, &client_layer_));
513
514 // now that they're ordered by z, add them to the composition
515 for (std::pair<const uint32_t, DrmHwcTwo::HwcLayer *> &l : z_map) {
516 DrmHwcLayer layer;
517 l.second->PopulateDrmLayer(&layer);
518 int ret = layer.ImportBuffer(importer_.get(), gralloc_);
519 if (ret) {
520 ALOGE("Failed to import layer, ret=%d", ret);
521 return HWC2::Error::NoResources;
522 }
523 map.layers.emplace_back(std::move(layer));
524 }
525 if (map.layers.empty()) {
526 *retire_fence = -1;
527 return HWC2::Error::None;
528 }
529
530 std::unique_ptr<DrmDisplayComposition> composition =
531 compositor_.CreateComposition();
532 composition->Init(drm_, crtc_, importer_.get(), planner_.get(), frame_no_);
533
534 // TODO: Don't always assume geometry changed
535 int ret = composition->SetLayers(map.layers.data(), map.layers.size(), true);
536 if (ret) {
537 ALOGE("Failed to set layers in the composition ret=%d", ret);
538 return HWC2::Error::BadLayer;
539 }
540
541 std::vector<DrmPlane *> primary_planes(primary_planes_);
542 std::vector<DrmPlane *> overlay_planes(overlay_planes_);
543 ret = composition->Plan(compositor_.squash_state(), &primary_planes,
544 &overlay_planes);
545 if (ret) {
546 ALOGE("Failed to plan the composition ret=%d", ret);
547 return HWC2::Error::BadConfig;
548 }
549
550 // Disable the planes we're not using
551 for (auto i = primary_planes.begin(); i != primary_planes.end();) {
552 composition->AddPlaneDisable(*i);
553 i = primary_planes.erase(i);
554 }
555 for (auto i = overlay_planes.begin(); i != overlay_planes.end();) {
556 composition->AddPlaneDisable(*i);
557 i = overlay_planes.erase(i);
558 }
559
560 ret = compositor_.QueueComposition(std::move(composition));
561 if (ret) {
562 ALOGE("Failed to apply the frame composition ret=%d", ret);
563 return HWC2::Error::BadParameter;
564 }
565
566 // Now that the release fences have been generated by the compositor, make
567 // sure they're managed properly
568 for (std::pair<const uint32_t, DrmHwcTwo::HwcLayer *> &l : z_map) {
569 l.second->manage_release_fence();
570 AddFenceToRetireFence(l.second->release_fence());
571 }
572
573 // The retire fence returned here is for the last frame, so return it and
574 // promote the next retire fence
575 *retire_fence = retire_fence_.Release();
576 retire_fence_ = std::move(next_retire_fence_);
577
578 ++frame_no_;
579 return HWC2::Error::None;
580 }
581
SetActiveConfig(hwc2_config_t config)582 HWC2::Error DrmHwcTwo::HwcDisplay::SetActiveConfig(hwc2_config_t config) {
583 supported(__func__);
584 auto mode =
585 std::find_if(connector_->modes().begin(), connector_->modes().end(),
586 [config](DrmMode const &m) { return m.id() == config; });
587 if (mode == connector_->modes().end()) {
588 ALOGE("Could not find active mode for %d", config);
589 return HWC2::Error::BadConfig;
590 }
591
592 std::unique_ptr<DrmDisplayComposition> composition =
593 compositor_.CreateComposition();
594 composition->Init(drm_, crtc_, importer_.get(), planner_.get(), frame_no_);
595 int ret = composition->SetDisplayMode(*mode);
596 ret = compositor_.QueueComposition(std::move(composition));
597 if (ret) {
598 ALOGE("Failed to queue dpms composition on %d", ret);
599 return HWC2::Error::BadConfig;
600 }
601 if (connector_->active_mode().id() == 0)
602 connector_->set_active_mode(*mode);
603
604 // Setup the client layer's dimensions
605 hwc_rect_t display_frame = {.left = 0,
606 .top = 0,
607 .right = static_cast<int>(mode->h_display()),
608 .bottom = static_cast<int>(mode->v_display())};
609 client_layer_.SetLayerDisplayFrame(display_frame);
610 hwc_frect_t source_crop = {.left = 0.0f,
611 .top = 0.0f,
612 .right = mode->h_display() + 0.0f,
613 .bottom = mode->v_display() + 0.0f};
614 client_layer_.SetLayerSourceCrop(source_crop);
615
616 return HWC2::Error::None;
617 }
618
SetClientTarget(buffer_handle_t target,int32_t acquire_fence,int32_t dataspace,hwc_region_t damage)619 HWC2::Error DrmHwcTwo::HwcDisplay::SetClientTarget(buffer_handle_t target,
620 int32_t acquire_fence,
621 int32_t dataspace,
622 hwc_region_t damage) {
623 supported(__func__);
624 UniqueFd uf(acquire_fence);
625
626 client_layer_.set_buffer(target);
627 client_layer_.set_acquire_fence(uf.get());
628 client_layer_.SetLayerDataspace(dataspace);
629 return HWC2::Error::None;
630 }
631
SetColorMode(int32_t mode)632 HWC2::Error DrmHwcTwo::HwcDisplay::SetColorMode(int32_t mode) {
633 supported(__func__);
634
635 if (mode != HAL_COLOR_MODE_NATIVE)
636 return HWC2::Error::Unsupported;
637
638 color_mode_ = mode;
639 return HWC2::Error::None;
640 }
641
SetColorTransform(const float * matrix,int32_t hint)642 HWC2::Error DrmHwcTwo::HwcDisplay::SetColorTransform(const float *matrix,
643 int32_t hint) {
644 supported(__func__);
645 // TODO: Force client composition if we get this
646 return unsupported(__func__, matrix, hint);
647 }
648
SetOutputBuffer(buffer_handle_t buffer,int32_t release_fence)649 HWC2::Error DrmHwcTwo::HwcDisplay::SetOutputBuffer(buffer_handle_t buffer,
650 int32_t release_fence) {
651 supported(__func__);
652 // TODO: Need virtual display support
653 return unsupported(__func__, buffer, release_fence);
654 }
655
SetPowerMode(int32_t mode_in)656 HWC2::Error DrmHwcTwo::HwcDisplay::SetPowerMode(int32_t mode_in) {
657 supported(__func__);
658 uint64_t dpms_value = 0;
659 auto mode = static_cast<HWC2::PowerMode>(mode_in);
660 switch (mode) {
661 case HWC2::PowerMode::Off:
662 dpms_value = DRM_MODE_DPMS_OFF;
663 break;
664 case HWC2::PowerMode::On:
665 dpms_value = DRM_MODE_DPMS_ON;
666 break;
667 default:
668 ALOGI("Power mode %d is unsupported\n", mode);
669 return HWC2::Error::Unsupported;
670 };
671
672 std::unique_ptr<DrmDisplayComposition> composition =
673 compositor_.CreateComposition();
674 composition->Init(drm_, crtc_, importer_.get(), planner_.get(), frame_no_);
675 composition->SetDpmsMode(dpms_value);
676 int ret = compositor_.QueueComposition(std::move(composition));
677 if (ret) {
678 ALOGE("Failed to apply the dpms composition ret=%d", ret);
679 return HWC2::Error::BadParameter;
680 }
681 return HWC2::Error::None;
682 }
683
SetVsyncEnabled(int32_t enabled)684 HWC2::Error DrmHwcTwo::HwcDisplay::SetVsyncEnabled(int32_t enabled) {
685 supported(__func__);
686 vsync_worker_.VSyncControl(enabled);
687 return HWC2::Error::None;
688 }
689
ValidateDisplay(uint32_t * num_types,uint32_t * num_requests)690 HWC2::Error DrmHwcTwo::HwcDisplay::ValidateDisplay(uint32_t *num_types,
691 uint32_t *num_requests) {
692 supported(__func__);
693 *num_types = 0;
694 *num_requests = 0;
695 for (std::pair<const hwc2_layer_t, DrmHwcTwo::HwcLayer> &l : layers_) {
696 DrmHwcTwo::HwcLayer &layer = l.second;
697 switch (layer.sf_type()) {
698 case HWC2::Composition::SolidColor:
699 case HWC2::Composition::Cursor:
700 case HWC2::Composition::Sideband:
701 layer.set_validated_type(HWC2::Composition::Client);
702 ++*num_types;
703 break;
704 default:
705 layer.set_validated_type(layer.sf_type());
706 break;
707 }
708 }
709 return HWC2::Error::None;
710 }
711
SetCursorPosition(int32_t x,int32_t y)712 HWC2::Error DrmHwcTwo::HwcLayer::SetCursorPosition(int32_t x, int32_t y) {
713 supported(__func__);
714 cursor_x_ = x;
715 cursor_y_ = y;
716 return HWC2::Error::None;
717 }
718
SetLayerBlendMode(int32_t mode)719 HWC2::Error DrmHwcTwo::HwcLayer::SetLayerBlendMode(int32_t mode) {
720 supported(__func__);
721 blending_ = static_cast<HWC2::BlendMode>(mode);
722 return HWC2::Error::None;
723 }
724
SetLayerBuffer(buffer_handle_t buffer,int32_t acquire_fence)725 HWC2::Error DrmHwcTwo::HwcLayer::SetLayerBuffer(buffer_handle_t buffer,
726 int32_t acquire_fence) {
727 supported(__func__);
728 UniqueFd uf(acquire_fence);
729
730 // The buffer and acquire_fence are handled elsewhere
731 if (sf_type_ == HWC2::Composition::Client ||
732 sf_type_ == HWC2::Composition::Sideband ||
733 sf_type_ == HWC2::Composition::SolidColor)
734 return HWC2::Error::None;
735
736 set_buffer(buffer);
737 set_acquire_fence(uf.get());
738 return HWC2::Error::None;
739 }
740
SetLayerColor(hwc_color_t color)741 HWC2::Error DrmHwcTwo::HwcLayer::SetLayerColor(hwc_color_t color) {
742 // TODO: Punt to client composition here?
743 return unsupported(__func__, color);
744 }
745
SetLayerCompositionType(int32_t type)746 HWC2::Error DrmHwcTwo::HwcLayer::SetLayerCompositionType(int32_t type) {
747 sf_type_ = static_cast<HWC2::Composition>(type);
748 return HWC2::Error::None;
749 }
750
SetLayerDataspace(int32_t dataspace)751 HWC2::Error DrmHwcTwo::HwcLayer::SetLayerDataspace(int32_t dataspace) {
752 supported(__func__);
753 dataspace_ = static_cast<android_dataspace_t>(dataspace);
754 return HWC2::Error::None;
755 }
756
SetLayerDisplayFrame(hwc_rect_t frame)757 HWC2::Error DrmHwcTwo::HwcLayer::SetLayerDisplayFrame(hwc_rect_t frame) {
758 supported(__func__);
759 display_frame_ = frame;
760 return HWC2::Error::None;
761 }
762
SetLayerPlaneAlpha(float alpha)763 HWC2::Error DrmHwcTwo::HwcLayer::SetLayerPlaneAlpha(float alpha) {
764 supported(__func__);
765 alpha_ = alpha;
766 return HWC2::Error::None;
767 }
768
SetLayerSidebandStream(const native_handle_t * stream)769 HWC2::Error DrmHwcTwo::HwcLayer::SetLayerSidebandStream(
770 const native_handle_t *stream) {
771 supported(__func__);
772 // TODO: We don't support sideband
773 return unsupported(__func__, stream);
774 }
775
SetLayerSourceCrop(hwc_frect_t crop)776 HWC2::Error DrmHwcTwo::HwcLayer::SetLayerSourceCrop(hwc_frect_t crop) {
777 supported(__func__);
778 source_crop_ = crop;
779 return HWC2::Error::None;
780 }
781
SetLayerSurfaceDamage(hwc_region_t damage)782 HWC2::Error DrmHwcTwo::HwcLayer::SetLayerSurfaceDamage(hwc_region_t damage) {
783 supported(__func__);
784 // TODO: We don't use surface damage, marking as unsupported
785 unsupported(__func__, damage);
786 return HWC2::Error::None;
787 }
788
SetLayerTransform(int32_t transform)789 HWC2::Error DrmHwcTwo::HwcLayer::SetLayerTransform(int32_t transform) {
790 supported(__func__);
791 transform_ = static_cast<HWC2::Transform>(transform);
792 return HWC2::Error::None;
793 }
794
SetLayerVisibleRegion(hwc_region_t visible)795 HWC2::Error DrmHwcTwo::HwcLayer::SetLayerVisibleRegion(hwc_region_t visible) {
796 supported(__func__);
797 // TODO: We don't use this information, marking as unsupported
798 unsupported(__func__, visible);
799 return HWC2::Error::None;
800 }
801
SetLayerZOrder(uint32_t order)802 HWC2::Error DrmHwcTwo::HwcLayer::SetLayerZOrder(uint32_t order) {
803 supported(__func__);
804 z_order_ = order;
805 return HWC2::Error::None;
806 }
807
PopulateDrmLayer(DrmHwcLayer * layer)808 void DrmHwcTwo::HwcLayer::PopulateDrmLayer(DrmHwcLayer *layer) {
809 supported(__func__);
810 switch (blending_) {
811 case HWC2::BlendMode::None:
812 layer->blending = DrmHwcBlending::kNone;
813 break;
814 case HWC2::BlendMode::Premultiplied:
815 layer->blending = DrmHwcBlending::kPreMult;
816 break;
817 case HWC2::BlendMode::Coverage:
818 layer->blending = DrmHwcBlending::kCoverage;
819 break;
820 default:
821 ALOGE("Unknown blending mode b=%d", blending_);
822 layer->blending = DrmHwcBlending::kNone;
823 break;
824 }
825
826 OutputFd release_fence = release_fence_output();
827
828 layer->sf_handle = buffer_;
829 layer->acquire_fence = acquire_fence_.Release();
830 layer->release_fence = std::move(release_fence);
831 layer->SetDisplayFrame(display_frame_);
832 layer->alpha = static_cast<uint8_t>(255.0f * alpha_ + 0.5f);
833 layer->SetSourceCrop(source_crop_);
834 layer->SetTransform(static_cast<int32_t>(transform_));
835 }
836
837 // static
HookDevClose(hw_device_t *)838 int DrmHwcTwo::HookDevClose(hw_device_t * /*dev*/) {
839 unsupported(__func__);
840 return 0;
841 }
842
843 // static
HookDevGetCapabilities(hwc2_device_t *,uint32_t * out_count,int32_t *)844 void DrmHwcTwo::HookDevGetCapabilities(hwc2_device_t * /*dev*/,
845 uint32_t *out_count,
846 int32_t * /*out_capabilities*/) {
847 supported(__func__);
848 *out_count = 0;
849 }
850
851 // static
HookDevGetFunction(struct hwc2_device *,int32_t descriptor)852 hwc2_function_pointer_t DrmHwcTwo::HookDevGetFunction(
853 struct hwc2_device * /*dev*/, int32_t descriptor) {
854 supported(__func__);
855 auto func = static_cast<HWC2::FunctionDescriptor>(descriptor);
856 switch (func) {
857 // Device functions
858 case HWC2::FunctionDescriptor::CreateVirtualDisplay:
859 return ToHook<HWC2_PFN_CREATE_VIRTUAL_DISPLAY>(
860 DeviceHook<int32_t, decltype(&DrmHwcTwo::CreateVirtualDisplay),
861 &DrmHwcTwo::CreateVirtualDisplay, uint32_t, uint32_t,
862 int32_t*, hwc2_display_t *>);
863 case HWC2::FunctionDescriptor::DestroyVirtualDisplay:
864 return ToHook<HWC2_PFN_DESTROY_VIRTUAL_DISPLAY>(
865 DeviceHook<int32_t, decltype(&DrmHwcTwo::DestroyVirtualDisplay),
866 &DrmHwcTwo::DestroyVirtualDisplay, hwc2_display_t>);
867 case HWC2::FunctionDescriptor::Dump:
868 return ToHook<HWC2_PFN_DUMP>(
869 DeviceHook<void, decltype(&DrmHwcTwo::Dump), &DrmHwcTwo::Dump,
870 uint32_t *, char *>);
871 case HWC2::FunctionDescriptor::GetMaxVirtualDisplayCount:
872 return ToHook<HWC2_PFN_GET_MAX_VIRTUAL_DISPLAY_COUNT>(
873 DeviceHook<uint32_t, decltype(&DrmHwcTwo::GetMaxVirtualDisplayCount),
874 &DrmHwcTwo::GetMaxVirtualDisplayCount>);
875 case HWC2::FunctionDescriptor::RegisterCallback:
876 return ToHook<HWC2_PFN_REGISTER_CALLBACK>(
877 DeviceHook<int32_t, decltype(&DrmHwcTwo::RegisterCallback),
878 &DrmHwcTwo::RegisterCallback, int32_t,
879 hwc2_callback_data_t, hwc2_function_pointer_t>);
880
881 // Display functions
882 case HWC2::FunctionDescriptor::AcceptDisplayChanges:
883 return ToHook<HWC2_PFN_ACCEPT_DISPLAY_CHANGES>(
884 DisplayHook<decltype(&HwcDisplay::AcceptDisplayChanges),
885 &HwcDisplay::AcceptDisplayChanges>);
886 case HWC2::FunctionDescriptor::CreateLayer:
887 return ToHook<HWC2_PFN_CREATE_LAYER>(
888 DisplayHook<decltype(&HwcDisplay::CreateLayer),
889 &HwcDisplay::CreateLayer, hwc2_layer_t *>);
890 case HWC2::FunctionDescriptor::DestroyLayer:
891 return ToHook<HWC2_PFN_DESTROY_LAYER>(
892 DisplayHook<decltype(&HwcDisplay::DestroyLayer),
893 &HwcDisplay::DestroyLayer, hwc2_layer_t>);
894 case HWC2::FunctionDescriptor::GetActiveConfig:
895 return ToHook<HWC2_PFN_GET_ACTIVE_CONFIG>(
896 DisplayHook<decltype(&HwcDisplay::GetActiveConfig),
897 &HwcDisplay::GetActiveConfig, hwc2_config_t *>);
898 case HWC2::FunctionDescriptor::GetChangedCompositionTypes:
899 return ToHook<HWC2_PFN_GET_CHANGED_COMPOSITION_TYPES>(
900 DisplayHook<decltype(&HwcDisplay::GetChangedCompositionTypes),
901 &HwcDisplay::GetChangedCompositionTypes, uint32_t *,
902 hwc2_layer_t *, int32_t *>);
903 case HWC2::FunctionDescriptor::GetClientTargetSupport:
904 return ToHook<HWC2_PFN_GET_CLIENT_TARGET_SUPPORT>(
905 DisplayHook<decltype(&HwcDisplay::GetClientTargetSupport),
906 &HwcDisplay::GetClientTargetSupport, uint32_t, uint32_t,
907 int32_t, int32_t>);
908 case HWC2::FunctionDescriptor::GetColorModes:
909 return ToHook<HWC2_PFN_GET_COLOR_MODES>(
910 DisplayHook<decltype(&HwcDisplay::GetColorModes),
911 &HwcDisplay::GetColorModes, uint32_t *, int32_t *>);
912 case HWC2::FunctionDescriptor::GetDisplayAttribute:
913 return ToHook<HWC2_PFN_GET_DISPLAY_ATTRIBUTE>(DisplayHook<
914 decltype(&HwcDisplay::GetDisplayAttribute),
915 &HwcDisplay::GetDisplayAttribute, hwc2_config_t, int32_t, int32_t *>);
916 case HWC2::FunctionDescriptor::GetDisplayConfigs:
917 return ToHook<HWC2_PFN_GET_DISPLAY_CONFIGS>(DisplayHook<
918 decltype(&HwcDisplay::GetDisplayConfigs),
919 &HwcDisplay::GetDisplayConfigs, uint32_t *, hwc2_config_t *>);
920 case HWC2::FunctionDescriptor::GetDisplayName:
921 return ToHook<HWC2_PFN_GET_DISPLAY_NAME>(
922 DisplayHook<decltype(&HwcDisplay::GetDisplayName),
923 &HwcDisplay::GetDisplayName, uint32_t *, char *>);
924 case HWC2::FunctionDescriptor::GetDisplayRequests:
925 return ToHook<HWC2_PFN_GET_DISPLAY_REQUESTS>(
926 DisplayHook<decltype(&HwcDisplay::GetDisplayRequests),
927 &HwcDisplay::GetDisplayRequests, int32_t *, uint32_t *,
928 hwc2_layer_t *, int32_t *>);
929 case HWC2::FunctionDescriptor::GetDisplayType:
930 return ToHook<HWC2_PFN_GET_DISPLAY_TYPE>(
931 DisplayHook<decltype(&HwcDisplay::GetDisplayType),
932 &HwcDisplay::GetDisplayType, int32_t *>);
933 case HWC2::FunctionDescriptor::GetDozeSupport:
934 return ToHook<HWC2_PFN_GET_DOZE_SUPPORT>(
935 DisplayHook<decltype(&HwcDisplay::GetDozeSupport),
936 &HwcDisplay::GetDozeSupport, int32_t *>);
937 case HWC2::FunctionDescriptor::GetHdrCapabilities:
938 return ToHook<HWC2_PFN_GET_HDR_CAPABILITIES>(
939 DisplayHook<decltype(&HwcDisplay::GetHdrCapabilities),
940 &HwcDisplay::GetHdrCapabilities, uint32_t *, int32_t *,
941 float *, float *, float *>);
942 case HWC2::FunctionDescriptor::GetReleaseFences:
943 return ToHook<HWC2_PFN_GET_RELEASE_FENCES>(
944 DisplayHook<decltype(&HwcDisplay::GetReleaseFences),
945 &HwcDisplay::GetReleaseFences, uint32_t *, hwc2_layer_t *,
946 int32_t *>);
947 case HWC2::FunctionDescriptor::PresentDisplay:
948 return ToHook<HWC2_PFN_PRESENT_DISPLAY>(
949 DisplayHook<decltype(&HwcDisplay::PresentDisplay),
950 &HwcDisplay::PresentDisplay, int32_t *>);
951 case HWC2::FunctionDescriptor::SetActiveConfig:
952 return ToHook<HWC2_PFN_SET_ACTIVE_CONFIG>(
953 DisplayHook<decltype(&HwcDisplay::SetActiveConfig),
954 &HwcDisplay::SetActiveConfig, hwc2_config_t>);
955 case HWC2::FunctionDescriptor::SetClientTarget:
956 return ToHook<HWC2_PFN_SET_CLIENT_TARGET>(DisplayHook<
957 decltype(&HwcDisplay::SetClientTarget), &HwcDisplay::SetClientTarget,
958 buffer_handle_t, int32_t, int32_t, hwc_region_t>);
959 case HWC2::FunctionDescriptor::SetColorMode:
960 return ToHook<HWC2_PFN_SET_COLOR_MODE>(
961 DisplayHook<decltype(&HwcDisplay::SetColorMode),
962 &HwcDisplay::SetColorMode, int32_t>);
963 case HWC2::FunctionDescriptor::SetColorTransform:
964 return ToHook<HWC2_PFN_SET_COLOR_TRANSFORM>(
965 DisplayHook<decltype(&HwcDisplay::SetColorTransform),
966 &HwcDisplay::SetColorTransform, const float *, int32_t>);
967 case HWC2::FunctionDescriptor::SetOutputBuffer:
968 return ToHook<HWC2_PFN_SET_OUTPUT_BUFFER>(
969 DisplayHook<decltype(&HwcDisplay::SetOutputBuffer),
970 &HwcDisplay::SetOutputBuffer, buffer_handle_t, int32_t>);
971 case HWC2::FunctionDescriptor::SetPowerMode:
972 return ToHook<HWC2_PFN_SET_POWER_MODE>(
973 DisplayHook<decltype(&HwcDisplay::SetPowerMode),
974 &HwcDisplay::SetPowerMode, int32_t>);
975 case HWC2::FunctionDescriptor::SetVsyncEnabled:
976 return ToHook<HWC2_PFN_SET_VSYNC_ENABLED>(
977 DisplayHook<decltype(&HwcDisplay::SetVsyncEnabled),
978 &HwcDisplay::SetVsyncEnabled, int32_t>);
979 case HWC2::FunctionDescriptor::ValidateDisplay:
980 return ToHook<HWC2_PFN_VALIDATE_DISPLAY>(
981 DisplayHook<decltype(&HwcDisplay::ValidateDisplay),
982 &HwcDisplay::ValidateDisplay, uint32_t *, uint32_t *>);
983
984 // Layer functions
985 case HWC2::FunctionDescriptor::SetCursorPosition:
986 return ToHook<HWC2_PFN_SET_CURSOR_POSITION>(
987 LayerHook<decltype(&HwcLayer::SetCursorPosition),
988 &HwcLayer::SetCursorPosition, int32_t, int32_t>);
989 case HWC2::FunctionDescriptor::SetLayerBlendMode:
990 return ToHook<HWC2_PFN_SET_LAYER_BLEND_MODE>(
991 LayerHook<decltype(&HwcLayer::SetLayerBlendMode),
992 &HwcLayer::SetLayerBlendMode, int32_t>);
993 case HWC2::FunctionDescriptor::SetLayerBuffer:
994 return ToHook<HWC2_PFN_SET_LAYER_BUFFER>(
995 LayerHook<decltype(&HwcLayer::SetLayerBuffer),
996 &HwcLayer::SetLayerBuffer, buffer_handle_t, int32_t>);
997 case HWC2::FunctionDescriptor::SetLayerColor:
998 return ToHook<HWC2_PFN_SET_LAYER_COLOR>(
999 LayerHook<decltype(&HwcLayer::SetLayerColor),
1000 &HwcLayer::SetLayerColor, hwc_color_t>);
1001 case HWC2::FunctionDescriptor::SetLayerCompositionType:
1002 return ToHook<HWC2_PFN_SET_LAYER_COMPOSITION_TYPE>(
1003 LayerHook<decltype(&HwcLayer::SetLayerCompositionType),
1004 &HwcLayer::SetLayerCompositionType, int32_t>);
1005 case HWC2::FunctionDescriptor::SetLayerDataspace:
1006 return ToHook<HWC2_PFN_SET_LAYER_DATASPACE>(
1007 LayerHook<decltype(&HwcLayer::SetLayerDataspace),
1008 &HwcLayer::SetLayerDataspace, int32_t>);
1009 case HWC2::FunctionDescriptor::SetLayerDisplayFrame:
1010 return ToHook<HWC2_PFN_SET_LAYER_DISPLAY_FRAME>(
1011 LayerHook<decltype(&HwcLayer::SetLayerDisplayFrame),
1012 &HwcLayer::SetLayerDisplayFrame, hwc_rect_t>);
1013 case HWC2::FunctionDescriptor::SetLayerPlaneAlpha:
1014 return ToHook<HWC2_PFN_SET_LAYER_PLANE_ALPHA>(
1015 LayerHook<decltype(&HwcLayer::SetLayerPlaneAlpha),
1016 &HwcLayer::SetLayerPlaneAlpha, float>);
1017 case HWC2::FunctionDescriptor::SetLayerSidebandStream:
1018 return ToHook<HWC2_PFN_SET_LAYER_SIDEBAND_STREAM>(LayerHook<
1019 decltype(&HwcLayer::SetLayerSidebandStream),
1020 &HwcLayer::SetLayerSidebandStream, const native_handle_t *>);
1021 case HWC2::FunctionDescriptor::SetLayerSourceCrop:
1022 return ToHook<HWC2_PFN_SET_LAYER_SOURCE_CROP>(
1023 LayerHook<decltype(&HwcLayer::SetLayerSourceCrop),
1024 &HwcLayer::SetLayerSourceCrop, hwc_frect_t>);
1025 case HWC2::FunctionDescriptor::SetLayerSurfaceDamage:
1026 return ToHook<HWC2_PFN_SET_LAYER_SURFACE_DAMAGE>(
1027 LayerHook<decltype(&HwcLayer::SetLayerSurfaceDamage),
1028 &HwcLayer::SetLayerSurfaceDamage, hwc_region_t>);
1029 case HWC2::FunctionDescriptor::SetLayerTransform:
1030 return ToHook<HWC2_PFN_SET_LAYER_TRANSFORM>(
1031 LayerHook<decltype(&HwcLayer::SetLayerTransform),
1032 &HwcLayer::SetLayerTransform, int32_t>);
1033 case HWC2::FunctionDescriptor::SetLayerVisibleRegion:
1034 return ToHook<HWC2_PFN_SET_LAYER_VISIBLE_REGION>(
1035 LayerHook<decltype(&HwcLayer::SetLayerVisibleRegion),
1036 &HwcLayer::SetLayerVisibleRegion, hwc_region_t>);
1037 case HWC2::FunctionDescriptor::SetLayerZOrder:
1038 return ToHook<HWC2_PFN_SET_LAYER_Z_ORDER>(
1039 LayerHook<decltype(&HwcLayer::SetLayerZOrder),
1040 &HwcLayer::SetLayerZOrder, uint32_t>);
1041 case HWC2::FunctionDescriptor::Invalid:
1042 default:
1043 return NULL;
1044 }
1045 }
1046
1047 // static
HookDevOpen(const struct hw_module_t * module,const char * name,struct hw_device_t ** dev)1048 int DrmHwcTwo::HookDevOpen(const struct hw_module_t *module, const char *name,
1049 struct hw_device_t **dev) {
1050 supported(__func__);
1051 if (strcmp(name, HWC_HARDWARE_COMPOSER)) {
1052 ALOGE("Invalid module name- %s", name);
1053 return -EINVAL;
1054 }
1055
1056 std::unique_ptr<DrmHwcTwo> ctx(new DrmHwcTwo());
1057 if (!ctx) {
1058 ALOGE("Failed to allocate DrmHwcTwo");
1059 return -ENOMEM;
1060 }
1061
1062 HWC2::Error err = ctx->Init();
1063 if (err != HWC2::Error::None) {
1064 ALOGE("Failed to initialize DrmHwcTwo err=%d\n", err);
1065 return -EINVAL;
1066 }
1067
1068 ctx->common.module = const_cast<hw_module_t *>(module);
1069 *dev = &ctx->common;
1070 ctx.release();
1071 return 0;
1072 }
1073 }
1074
1075 static struct hw_module_methods_t hwc2_module_methods = {
1076 .open = android::DrmHwcTwo::HookDevOpen,
1077 };
1078
1079 hw_module_t HAL_MODULE_INFO_SYM = {
1080 .tag = HARDWARE_MODULE_TAG,
1081 .module_api_version = HARDWARE_MODULE_API_VERSION(2, 0),
1082 .id = HWC_HARDWARE_MODULE_ID,
1083 .name = "DrmHwcTwo module",
1084 .author = "The Android Open Source Project",
1085 .methods = &hwc2_module_methods,
1086 .dso = NULL,
1087 .reserved = {0},
1088 };
1089