| /* |
| * Copyright (C) 2022 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| // NOLINTNEXTLINE(cppcoreguidelines-macro-usage) |
| // #define LOG_NDEBUG 0 // Uncomment to see HWC2 API calls in logcat |
| |
| #define LOG_TAG "hwc2-device" |
| |
| #include <cinttypes> |
| |
| #include "DrmHwcTwo.h" |
| #include "backend/Backend.h" |
| #include "utils/log.h" |
| |
| namespace android { |
| |
| /* Converts long __PRETTY_FUNCTION__ result, e.g.: |
| * "int32_t android::LayerHook(hwc2_device_t *, hwc2_display_t, hwc2_layer_t," |
| * "Args...) [HookType = HWC2::Error (android::HwcLayer::*)(const native_handle" |
| * "*,int), func = &android::HwcLayer::SetLayerBuffer, Args = <const |
| * "native_handle, int>" |
| * to the short "android::HwcLayer::SetLayerBuffer" for better logs readability |
| */ |
| static std::string GetFuncName(const char *pretty_function) { |
| std::string str(pretty_function); |
| const char *start = "func = &"; |
| size_t p1 = str.find(start); |
| p1 += strlen(start); |
| size_t p2 = str.find(',', p1); |
| return str.substr(p1, p2 - p1); |
| } |
| |
| struct Drmhwc2Device : hwc2_device { |
| DrmHwcTwo drmhwctwo; |
| }; |
| |
| static DrmHwcTwo *ToDrmHwcTwo(hwc2_device_t *dev) { |
| // NOLINTNEXTLINE(cppcoreguidelines-pro-type-static-cast-downcast): |
| return &static_cast<Drmhwc2Device *>(dev)->drmhwctwo; |
| } |
| |
| template <typename PFN, typename T> |
| static hwc2_function_pointer_t ToHook(T function) { |
| static_assert(std::is_same<PFN, T>::value, "Incompatible fn pointer"); |
| // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast): |
| return reinterpret_cast<hwc2_function_pointer_t>(function); |
| } |
| |
| template <typename T, typename HookType, HookType func, typename... Args> |
| static T DeviceHook(hwc2_device_t *dev, Args... args) { |
| ALOGV("Device hook: %s", GetFuncName(__PRETTY_FUNCTION__).c_str()); |
| DrmHwcTwo *hwc = ToDrmHwcTwo(dev); |
| const std::lock_guard<std::mutex> lock(hwc->GetResMan().GetMainLock()); |
| return static_cast<T>(((*hwc).*func)(std::forward<Args>(args)...)); |
| } |
| |
| template <typename HookType, HookType func, typename... Args> |
| static int32_t DisplayHook(hwc2_device_t *dev, hwc2_display_t display_handle, |
| Args... args) { |
| ALOGV("Display #%" PRIu64 " hook: %s", display_handle, |
| GetFuncName(__PRETTY_FUNCTION__).c_str()); |
| DrmHwcTwo *hwc = ToDrmHwcTwo(dev); |
| const std::lock_guard<std::mutex> lock(hwc->GetResMan().GetMainLock()); |
| auto *display = hwc->GetDisplay(display_handle); |
| if (display == nullptr) |
| return static_cast<int32_t>(HWC2::Error::BadDisplay); |
| |
| return static_cast<int32_t>((display->*func)(std::forward<Args>(args)...)); |
| } |
| |
| template <typename HookType, HookType func, typename... Args> |
| static int32_t LayerHook(hwc2_device_t *dev, hwc2_display_t display_handle, |
| hwc2_layer_t layer_handle, Args... args) { |
| ALOGV("Display #%" PRIu64 " Layer: #%" PRIu64 " hook: %s", display_handle, |
| layer_handle, GetFuncName(__PRETTY_FUNCTION__).c_str()); |
| DrmHwcTwo *hwc = ToDrmHwcTwo(dev); |
| const std::lock_guard<std::mutex> lock(hwc->GetResMan().GetMainLock()); |
| auto *display = hwc->GetDisplay(display_handle); |
| if (display == nullptr) |
| return static_cast<int32_t>(HWC2::Error::BadDisplay); |
| |
| HwcLayer *layer = display->get_layer(layer_handle); |
| if (!layer) |
| return static_cast<int32_t>(HWC2::Error::BadLayer); |
| |
| return static_cast<int32_t>((layer->*func)(std::forward<Args>(args)...)); |
| } |
| |
| static int HookDevClose(hw_device_t *dev) { |
| // NOLINTNEXTLINE (cppcoreguidelines-pro-type-reinterpret-cast): Safe |
| auto *hwc2_dev = reinterpret_cast<hwc2_device_t *>(dev); |
| std::unique_ptr<DrmHwcTwo> ctx(ToDrmHwcTwo(hwc2_dev)); |
| return 0; |
| } |
| |
| static void HookDevGetCapabilities(hwc2_device_t * /*dev*/, uint32_t *out_count, |
| int32_t * /*out_capabilities*/) { |
| *out_count = 0; |
| } |
| |
| static hwc2_function_pointer_t HookDevGetFunction(struct hwc2_device * /*dev*/, |
| int32_t descriptor) { |
| auto func = static_cast<HWC2::FunctionDescriptor>(descriptor); |
| switch (func) { |
| // Device functions |
| case HWC2::FunctionDescriptor::CreateVirtualDisplay: |
| return ToHook<HWC2_PFN_CREATE_VIRTUAL_DISPLAY>( |
| DeviceHook<int32_t, decltype(&DrmHwcTwo::CreateVirtualDisplay), |
| &DrmHwcTwo::CreateVirtualDisplay, uint32_t, uint32_t, |
| int32_t *, hwc2_display_t *>); |
| case HWC2::FunctionDescriptor::DestroyVirtualDisplay: |
| return ToHook<HWC2_PFN_DESTROY_VIRTUAL_DISPLAY>( |
| DeviceHook<int32_t, decltype(&DrmHwcTwo::DestroyVirtualDisplay), |
| &DrmHwcTwo::DestroyVirtualDisplay, hwc2_display_t>); |
| case HWC2::FunctionDescriptor::Dump: |
| return ToHook<HWC2_PFN_DUMP>( |
| DeviceHook<void, decltype(&DrmHwcTwo::Dump), &DrmHwcTwo::Dump, |
| uint32_t *, char *>); |
| case HWC2::FunctionDescriptor::GetMaxVirtualDisplayCount: |
| return ToHook<HWC2_PFN_GET_MAX_VIRTUAL_DISPLAY_COUNT>( |
| DeviceHook<uint32_t, decltype(&DrmHwcTwo::GetMaxVirtualDisplayCount), |
| &DrmHwcTwo::GetMaxVirtualDisplayCount>); |
| case HWC2::FunctionDescriptor::RegisterCallback: |
| return ToHook<HWC2_PFN_REGISTER_CALLBACK>( |
| DeviceHook<int32_t, decltype(&DrmHwcTwo::RegisterCallback), |
| &DrmHwcTwo::RegisterCallback, int32_t, |
| hwc2_callback_data_t, hwc2_function_pointer_t>); |
| |
| // Display functions |
| case HWC2::FunctionDescriptor::AcceptDisplayChanges: |
| return ToHook<HWC2_PFN_ACCEPT_DISPLAY_CHANGES>( |
| DisplayHook<decltype(&HwcDisplay::AcceptDisplayChanges), |
| &HwcDisplay::AcceptDisplayChanges>); |
| case HWC2::FunctionDescriptor::CreateLayer: |
| return ToHook<HWC2_PFN_CREATE_LAYER>( |
| DisplayHook<decltype(&HwcDisplay::CreateLayer), |
| &HwcDisplay::CreateLayer, hwc2_layer_t *>); |
| case HWC2::FunctionDescriptor::DestroyLayer: |
| return ToHook<HWC2_PFN_DESTROY_LAYER>( |
| DisplayHook<decltype(&HwcDisplay::DestroyLayer), |
| &HwcDisplay::DestroyLayer, hwc2_layer_t>); |
| case HWC2::FunctionDescriptor::GetActiveConfig: |
| return ToHook<HWC2_PFN_GET_ACTIVE_CONFIG>( |
| DisplayHook<decltype(&HwcDisplay::GetActiveConfig), |
| &HwcDisplay::GetActiveConfig, hwc2_config_t *>); |
| case HWC2::FunctionDescriptor::GetChangedCompositionTypes: |
| return ToHook<HWC2_PFN_GET_CHANGED_COMPOSITION_TYPES>( |
| DisplayHook<decltype(&HwcDisplay::GetChangedCompositionTypes), |
| &HwcDisplay::GetChangedCompositionTypes, uint32_t *, |
| hwc2_layer_t *, int32_t *>); |
| case HWC2::FunctionDescriptor::GetClientTargetSupport: |
| return ToHook<HWC2_PFN_GET_CLIENT_TARGET_SUPPORT>( |
| DisplayHook<decltype(&HwcDisplay::GetClientTargetSupport), |
| &HwcDisplay::GetClientTargetSupport, uint32_t, uint32_t, |
| int32_t, int32_t>); |
| case HWC2::FunctionDescriptor::GetColorModes: |
| return ToHook<HWC2_PFN_GET_COLOR_MODES>( |
| DisplayHook<decltype(&HwcDisplay::GetColorModes), |
| &HwcDisplay::GetColorModes, uint32_t *, int32_t *>); |
| case HWC2::FunctionDescriptor::GetDisplayAttribute: |
| return ToHook<HWC2_PFN_GET_DISPLAY_ATTRIBUTE>( |
| DisplayHook<decltype(&HwcDisplay::GetDisplayAttribute), |
| &HwcDisplay::GetDisplayAttribute, hwc2_config_t, int32_t, |
| int32_t *>); |
| case HWC2::FunctionDescriptor::GetDisplayConfigs: |
| return ToHook<HWC2_PFN_GET_DISPLAY_CONFIGS>( |
| DisplayHook<decltype(&HwcDisplay::GetDisplayConfigs), |
| &HwcDisplay::GetDisplayConfigs, uint32_t *, |
| hwc2_config_t *>); |
| case HWC2::FunctionDescriptor::GetDisplayName: |
| return ToHook<HWC2_PFN_GET_DISPLAY_NAME>( |
| DisplayHook<decltype(&HwcDisplay::GetDisplayName), |
| &HwcDisplay::GetDisplayName, uint32_t *, char *>); |
| case HWC2::FunctionDescriptor::GetDisplayRequests: |
| return ToHook<HWC2_PFN_GET_DISPLAY_REQUESTS>( |
| DisplayHook<decltype(&HwcDisplay::GetDisplayRequests), |
| &HwcDisplay::GetDisplayRequests, int32_t *, uint32_t *, |
| hwc2_layer_t *, int32_t *>); |
| case HWC2::FunctionDescriptor::GetDisplayType: |
| return ToHook<HWC2_PFN_GET_DISPLAY_TYPE>( |
| DisplayHook<decltype(&HwcDisplay::GetDisplayType), |
| &HwcDisplay::GetDisplayType, int32_t *>); |
| case HWC2::FunctionDescriptor::GetDozeSupport: |
| return ToHook<HWC2_PFN_GET_DOZE_SUPPORT>( |
| DisplayHook<decltype(&HwcDisplay::GetDozeSupport), |
| &HwcDisplay::GetDozeSupport, int32_t *>); |
| case HWC2::FunctionDescriptor::GetHdrCapabilities: |
| return ToHook<HWC2_PFN_GET_HDR_CAPABILITIES>( |
| DisplayHook<decltype(&HwcDisplay::GetHdrCapabilities), |
| &HwcDisplay::GetHdrCapabilities, uint32_t *, int32_t *, |
| float *, float *, float *>); |
| case HWC2::FunctionDescriptor::GetReleaseFences: |
| return ToHook<HWC2_PFN_GET_RELEASE_FENCES>( |
| DisplayHook<decltype(&HwcDisplay::GetReleaseFences), |
| &HwcDisplay::GetReleaseFences, uint32_t *, hwc2_layer_t *, |
| int32_t *>); |
| case HWC2::FunctionDescriptor::PresentDisplay: |
| return ToHook<HWC2_PFN_PRESENT_DISPLAY>( |
| DisplayHook<decltype(&HwcDisplay::PresentDisplay), |
| &HwcDisplay::PresentDisplay, int32_t *>); |
| case HWC2::FunctionDescriptor::SetActiveConfig: |
| return ToHook<HWC2_PFN_SET_ACTIVE_CONFIG>( |
| DisplayHook<decltype(&HwcDisplay::SetActiveConfig), |
| &HwcDisplay::SetActiveConfig, hwc2_config_t>); |
| case HWC2::FunctionDescriptor::SetClientTarget: |
| return ToHook<HWC2_PFN_SET_CLIENT_TARGET>( |
| DisplayHook<decltype(&HwcDisplay::SetClientTarget), |
| &HwcDisplay::SetClientTarget, buffer_handle_t, int32_t, |
| int32_t, hwc_region_t>); |
| case HWC2::FunctionDescriptor::SetColorMode: |
| return ToHook<HWC2_PFN_SET_COLOR_MODE>( |
| DisplayHook<decltype(&HwcDisplay::SetColorMode), |
| &HwcDisplay::SetColorMode, int32_t>); |
| case HWC2::FunctionDescriptor::SetColorTransform: |
| return ToHook<HWC2_PFN_SET_COLOR_TRANSFORM>( |
| DisplayHook<decltype(&HwcDisplay::SetColorTransform), |
| &HwcDisplay::SetColorTransform, const float *, int32_t>); |
| case HWC2::FunctionDescriptor::SetOutputBuffer: |
| return ToHook<HWC2_PFN_SET_OUTPUT_BUFFER>( |
| DisplayHook<decltype(&HwcDisplay::SetOutputBuffer), |
| &HwcDisplay::SetOutputBuffer, buffer_handle_t, int32_t>); |
| case HWC2::FunctionDescriptor::SetPowerMode: |
| return ToHook<HWC2_PFN_SET_POWER_MODE>( |
| DisplayHook<decltype(&HwcDisplay::SetPowerMode), |
| &HwcDisplay::SetPowerMode, int32_t>); |
| case HWC2::FunctionDescriptor::SetVsyncEnabled: |
| return ToHook<HWC2_PFN_SET_VSYNC_ENABLED>( |
| DisplayHook<decltype(&HwcDisplay::SetVsyncEnabled), |
| &HwcDisplay::SetVsyncEnabled, int32_t>); |
| case HWC2::FunctionDescriptor::ValidateDisplay: |
| return ToHook<HWC2_PFN_VALIDATE_DISPLAY>( |
| DisplayHook<decltype(&HwcDisplay::ValidateDisplay), |
| &HwcDisplay::ValidateDisplay, uint32_t *, uint32_t *>); |
| #if PLATFORM_SDK_VERSION > 27 |
| case HWC2::FunctionDescriptor::GetRenderIntents: |
| return ToHook<HWC2_PFN_GET_RENDER_INTENTS>( |
| DisplayHook<decltype(&HwcDisplay::GetRenderIntents), |
| &HwcDisplay::GetRenderIntents, int32_t, uint32_t *, |
| int32_t *>); |
| case HWC2::FunctionDescriptor::SetColorModeWithRenderIntent: |
| return ToHook<HWC2_PFN_SET_COLOR_MODE_WITH_RENDER_INTENT>( |
| DisplayHook<decltype(&HwcDisplay::SetColorModeWithIntent), |
| &HwcDisplay::SetColorModeWithIntent, int32_t, int32_t>); |
| #endif |
| #if PLATFORM_SDK_VERSION > 28 |
| case HWC2::FunctionDescriptor::GetDisplayIdentificationData: |
| return ToHook<HWC2_PFN_GET_DISPLAY_IDENTIFICATION_DATA>( |
| DisplayHook<decltype(&HwcDisplay::GetDisplayIdentificationData), |
| &HwcDisplay::GetDisplayIdentificationData, uint8_t *, |
| uint32_t *, uint8_t *>); |
| case HWC2::FunctionDescriptor::GetDisplayCapabilities: |
| return ToHook<HWC2_PFN_GET_DISPLAY_CAPABILITIES>( |
| DisplayHook<decltype(&HwcDisplay::GetDisplayCapabilities), |
| &HwcDisplay::GetDisplayCapabilities, uint32_t *, |
| uint32_t *>); |
| case HWC2::FunctionDescriptor::GetDisplayBrightnessSupport: |
| return ToHook<HWC2_PFN_GET_DISPLAY_BRIGHTNESS_SUPPORT>( |
| DisplayHook<decltype(&HwcDisplay::GetDisplayBrightnessSupport), |
| &HwcDisplay::GetDisplayBrightnessSupport, bool *>); |
| case HWC2::FunctionDescriptor::SetDisplayBrightness: |
| return ToHook<HWC2_PFN_SET_DISPLAY_BRIGHTNESS>( |
| DisplayHook<decltype(&HwcDisplay::SetDisplayBrightness), |
| &HwcDisplay::SetDisplayBrightness, float>); |
| #endif /* PLATFORM_SDK_VERSION > 28 */ |
| #if PLATFORM_SDK_VERSION > 29 |
| case HWC2::FunctionDescriptor::GetDisplayConnectionType: |
| return ToHook<HWC2_PFN_GET_DISPLAY_CONNECTION_TYPE>( |
| DisplayHook<decltype(&HwcDisplay::GetDisplayConnectionType), |
| &HwcDisplay::GetDisplayConnectionType, uint32_t *>); |
| case HWC2::FunctionDescriptor::GetDisplayVsyncPeriod: |
| return ToHook<HWC2_PFN_GET_DISPLAY_VSYNC_PERIOD>( |
| DisplayHook<decltype(&HwcDisplay::GetDisplayVsyncPeriod), |
| &HwcDisplay::GetDisplayVsyncPeriod, |
| hwc2_vsync_period_t *>); |
| case HWC2::FunctionDescriptor::SetActiveConfigWithConstraints: |
| return ToHook<HWC2_PFN_SET_ACTIVE_CONFIG_WITH_CONSTRAINTS>( |
| DisplayHook<decltype(&HwcDisplay::SetActiveConfigWithConstraints), |
| &HwcDisplay::SetActiveConfigWithConstraints, |
| hwc2_config_t, hwc_vsync_period_change_constraints_t *, |
| hwc_vsync_period_change_timeline_t *>); |
| case HWC2::FunctionDescriptor::SetAutoLowLatencyMode: |
| return ToHook<HWC2_PFN_SET_AUTO_LOW_LATENCY_MODE>( |
| DisplayHook<decltype(&HwcDisplay::SetAutoLowLatencyMode), |
| &HwcDisplay::SetAutoLowLatencyMode, bool>); |
| case HWC2::FunctionDescriptor::GetSupportedContentTypes: |
| return ToHook<HWC2_PFN_GET_SUPPORTED_CONTENT_TYPES>( |
| DisplayHook<decltype(&HwcDisplay::GetSupportedContentTypes), |
| &HwcDisplay::GetSupportedContentTypes, uint32_t *, |
| uint32_t *>); |
| case HWC2::FunctionDescriptor::SetContentType: |
| return ToHook<HWC2_PFN_SET_CONTENT_TYPE>( |
| DisplayHook<decltype(&HwcDisplay::SetContentType), |
| &HwcDisplay::SetContentType, int32_t>); |
| #endif |
| // Layer functions |
| case HWC2::FunctionDescriptor::SetCursorPosition: |
| return ToHook<HWC2_PFN_SET_CURSOR_POSITION>( |
| LayerHook<decltype(&HwcLayer::SetCursorPosition), |
| &HwcLayer::SetCursorPosition, int32_t, int32_t>); |
| case HWC2::FunctionDescriptor::SetLayerBlendMode: |
| return ToHook<HWC2_PFN_SET_LAYER_BLEND_MODE>( |
| LayerHook<decltype(&HwcLayer::SetLayerBlendMode), |
| &HwcLayer::SetLayerBlendMode, int32_t>); |
| case HWC2::FunctionDescriptor::SetLayerBuffer: |
| return ToHook<HWC2_PFN_SET_LAYER_BUFFER>( |
| LayerHook<decltype(&HwcLayer::SetLayerBuffer), |
| &HwcLayer::SetLayerBuffer, buffer_handle_t, int32_t>); |
| case HWC2::FunctionDescriptor::SetLayerColor: |
| return ToHook<HWC2_PFN_SET_LAYER_COLOR>( |
| LayerHook<decltype(&HwcLayer::SetLayerColor), |
| &HwcLayer::SetLayerColor, hwc_color_t>); |
| case HWC2::FunctionDescriptor::SetLayerCompositionType: |
| return ToHook<HWC2_PFN_SET_LAYER_COMPOSITION_TYPE>( |
| LayerHook<decltype(&HwcLayer::SetLayerCompositionType), |
| &HwcLayer::SetLayerCompositionType, int32_t>); |
| case HWC2::FunctionDescriptor::SetLayerDataspace: |
| return ToHook<HWC2_PFN_SET_LAYER_DATASPACE>( |
| LayerHook<decltype(&HwcLayer::SetLayerDataspace), |
| &HwcLayer::SetLayerDataspace, int32_t>); |
| case HWC2::FunctionDescriptor::SetLayerDisplayFrame: |
| return ToHook<HWC2_PFN_SET_LAYER_DISPLAY_FRAME>( |
| LayerHook<decltype(&HwcLayer::SetLayerDisplayFrame), |
| &HwcLayer::SetLayerDisplayFrame, hwc_rect_t>); |
| case HWC2::FunctionDescriptor::SetLayerPlaneAlpha: |
| return ToHook<HWC2_PFN_SET_LAYER_PLANE_ALPHA>( |
| LayerHook<decltype(&HwcLayer::SetLayerPlaneAlpha), |
| &HwcLayer::SetLayerPlaneAlpha, float>); |
| case HWC2::FunctionDescriptor::SetLayerSidebandStream: |
| return ToHook<HWC2_PFN_SET_LAYER_SIDEBAND_STREAM>( |
| LayerHook<decltype(&HwcLayer::SetLayerSidebandStream), |
| &HwcLayer::SetLayerSidebandStream, |
| const native_handle_t *>); |
| case HWC2::FunctionDescriptor::SetLayerSourceCrop: |
| return ToHook<HWC2_PFN_SET_LAYER_SOURCE_CROP>( |
| LayerHook<decltype(&HwcLayer::SetLayerSourceCrop), |
| &HwcLayer::SetLayerSourceCrop, hwc_frect_t>); |
| case HWC2::FunctionDescriptor::SetLayerSurfaceDamage: |
| return ToHook<HWC2_PFN_SET_LAYER_SURFACE_DAMAGE>( |
| LayerHook<decltype(&HwcLayer::SetLayerSurfaceDamage), |
| &HwcLayer::SetLayerSurfaceDamage, hwc_region_t>); |
| case HWC2::FunctionDescriptor::SetLayerTransform: |
| return ToHook<HWC2_PFN_SET_LAYER_TRANSFORM>( |
| LayerHook<decltype(&HwcLayer::SetLayerTransform), |
| &HwcLayer::SetLayerTransform, int32_t>); |
| case HWC2::FunctionDescriptor::SetLayerVisibleRegion: |
| return ToHook<HWC2_PFN_SET_LAYER_VISIBLE_REGION>( |
| LayerHook<decltype(&HwcLayer::SetLayerVisibleRegion), |
| &HwcLayer::SetLayerVisibleRegion, hwc_region_t>); |
| case HWC2::FunctionDescriptor::SetLayerZOrder: |
| return ToHook<HWC2_PFN_SET_LAYER_Z_ORDER>( |
| LayerHook<decltype(&HwcLayer::SetLayerZOrder), |
| &HwcLayer::SetLayerZOrder, uint32_t>); |
| case HWC2::FunctionDescriptor::Invalid: |
| default: |
| return nullptr; |
| } |
| } |
| |
| static int HookDevOpen(const struct hw_module_t *module, const char *name, |
| struct hw_device_t **dev) { |
| if (strcmp(name, HWC_HARDWARE_COMPOSER) != 0) { |
| ALOGE("Invalid module name- %s", name); |
| return -EINVAL; |
| } |
| |
| auto ctx = std::make_unique<Drmhwc2Device>(); |
| if (!ctx) { |
| ALOGE("Failed to allocate DrmHwcTwo"); |
| return -ENOMEM; |
| } |
| |
| ctx->common.tag = HARDWARE_DEVICE_TAG; |
| ctx->common.version = HWC_DEVICE_API_VERSION_2_0; |
| ctx->common.close = HookDevClose; |
| // NOLINTNEXTLINE(cppcoreguidelines-pro-type-cstyle-cast) |
| ctx->common.module = (hw_module_t *)module; |
| ctx->getCapabilities = HookDevGetCapabilities; |
| ctx->getFunction = HookDevGetFunction; |
| |
| *dev = &ctx.release()->common; |
| |
| return 0; |
| } |
| |
| } // namespace android |
| |
| // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables) |
| static struct hw_module_methods_t hwc2_module_methods = { |
| .open = android::HookDevOpen, |
| }; |
| |
| // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables) |
| hw_module_t HAL_MODULE_INFO_SYM = { |
| .tag = HARDWARE_MODULE_TAG, |
| .module_api_version = HARDWARE_MODULE_API_VERSION(2, 0), |
| .id = HWC_HARDWARE_MODULE_ID, |
| .name = "DrmHwcTwo module", |
| .author = "The Android Open Source Project", |
| .methods = &hwc2_module_methods, |
| .dso = nullptr, |
| .reserved = {0}, |
| }; |
