Home | History | Annotate | Download | only in drm_hwcomposer 
      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:
     38   DrmVsyncCallback(hwc2_callback_data_t data, hwc2_function_pointer_t hook)
     39       : data_(data), hook_(hook) {
     40   }
     41 
     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 
     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 
     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>
    103 static inline HWC2::Error unsupported(char const *func, Args... /*args*/) {
    104   ALOGV("Unsupported function: %s", func);
    105   return HWC2::Error::Unsupported;
    106 }
    107 
    108 static inline void supported(char const *func) {
    109   ALOGV("Supported function: %s", func);
    110 }
    111 
    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 
    119 HWC2::Error DrmHwcTwo::DestroyVirtualDisplay(hwc2_display_t display) {
    120   // TODO: Implement virtual display
    121   return unsupported(__func__, display);
    122 }
    123 
    124 void DrmHwcTwo::Dump(uint32_t *size, char *buffer) {
    125   // TODO: Implement dump
    126   unsupported(__func__, size, buffer);
    127 }
    128 
    129 uint32_t DrmHwcTwo::GetMaxVirtualDisplayCount() {
    130   // TODO: Implement virtual display
    131   unsupported(__func__);
    132   return 0;
    133 }
    134 
    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 
    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 
    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 
    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 
    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 
    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 
    259 HWC2::Error DrmHwcTwo::HwcDisplay::DestroyLayer(hwc2_layer_t layer) {
    260   supported(__func__);
    261   layers_.erase(layer);
    262   return HWC2::Error::None;
    263 }
    264 
    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 
    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 
    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 
    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 
    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 
    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 
    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 
    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 
    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 
    435 HWC2::Error DrmHwcTwo::HwcDisplay::GetDozeSupport(int32_t *support) {
    436   supported(__func__);
    437   *support = 0;
    438   return HWC2::Error::None;
    439 }
    440 
    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 
    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 
    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 
    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 
    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 
    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 
    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 
    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 
    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 
    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 
    684 HWC2::Error DrmHwcTwo::HwcDisplay::SetVsyncEnabled(int32_t enabled) {
    685   supported(__func__);
    686   vsync_worker_.VSyncControl(enabled);
    687   return HWC2::Error::None;
    688 }
    689 
    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 
    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 
    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 
    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 
    741 HWC2::Error DrmHwcTwo::HwcLayer::SetLayerColor(hwc_color_t color) {
    742   // TODO: Punt to client composition here?
    743   return unsupported(__func__, color);
    744 }
    745 
    746 HWC2::Error DrmHwcTwo::HwcLayer::SetLayerCompositionType(int32_t type) {
    747   sf_type_ = static_cast<HWC2::Composition>(type);
    748   return HWC2::Error::None;
    749 }
    750 
    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 
    757 HWC2::Error DrmHwcTwo::HwcLayer::SetLayerDisplayFrame(hwc_rect_t frame) {
    758   supported(__func__);
    759   display_frame_ = frame;
    760   return HWC2::Error::None;
    761 }
    762 
    763 HWC2::Error DrmHwcTwo::HwcLayer::SetLayerPlaneAlpha(float alpha) {
    764   supported(__func__);
    765   alpha_ = alpha;
    766   return HWC2::Error::None;
    767 }
    768 
    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 
    776 HWC2::Error DrmHwcTwo::HwcLayer::SetLayerSourceCrop(hwc_frect_t crop) {
    777   supported(__func__);
    778   source_crop_ = crop;
    779   return HWC2::Error::None;
    780 }
    781 
    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 
    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 
    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 
    802 HWC2::Error DrmHwcTwo::HwcLayer::SetLayerZOrder(uint32_t order) {
    803   supported(__func__);
    804   z_order_ = order;
    805   return HWC2::Error::None;
    806 }
    807 
    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
    838 int DrmHwcTwo::HookDevClose(hw_device_t * /*dev*/) {
    839   unsupported(__func__);
    840   return 0;
    841 }
    842 
    843 // static
    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
    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
   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