drmhwctwo.cpp

   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   // TODO: android_color_mode_t isn't defined yet!
 319   return unsupported(__func__, num_modes, modes);
 320 }
 321
 322 HWC2::Error DrmHwcTwo::HwcDisplay::GetDisplayAttribute(hwc2_config_t config,
 323                                                        int32_t attribute_in,
 324                                                        int32_t *value) {
 325   supported(__func__);
 326   auto mode =
 327       std::find_if(connector_->modes().begin(), connector_->modes().end(),
 328                    [config](DrmMode const &m) { return m.id() == config; });
 329   if (mode == connector_->modes().end()) {
 330     ALOGE("Could not find active mode for %d", config);
 331     return HWC2::Error::BadConfig;
 332   }
 333
 334   static const int32_t kUmPerInch = 25400;
 335   uint32_t mm_width = connector_->mm_width();
 336   uint32_t mm_height = connector_->mm_height();
 337   auto attribute = static_cast<HWC2::Attribute>(attribute_in);
 338   switch (attribute) {
 339     case HWC2::Attribute::Width:
 340       *value = mode->h_display();
 341       break;
 342     case HWC2::Attribute::Height:
 343       *value = mode->v_display();
 344       break;
 345     case HWC2::Attribute::VsyncPeriod:
 346       // in nanoseconds
 347       *value = 1000 * 1000 * 1000 / mode->v_refresh();
 348       break;
 349     case HWC2::Attribute::DpiX:
 350       // Dots per 1000 inches
 351       *value = mm_width ? (mode->h_display() * kUmPerInch) / mm_width : -1;
 352       break;
 353     case HWC2::Attribute::DpiY:
 354       // Dots per 1000 inches
 355       *value = mm_height ? (mode->v_display() * kUmPerInch) / mm_height : -1;
 356       break;
 357     default:
 358       *value = -1;
 359       return HWC2::Error::BadConfig;
 360   }
 361   return HWC2::Error::None;
 362 }
 363
 364 HWC2::Error DrmHwcTwo::HwcDisplay::GetDisplayConfigs(uint32_t *num_configs,
 365                                                      hwc2_config_t *configs) {
 366   supported(__func__);
 367   // Since this callback is normally invoked twice (once to get the count, and
 368   // once to populate configs), we don't really want to read the edid
 369   // redundantly. Instead, only update the modes on the first invocation. While
 370   // it's possible this will result in stale modes, it'll all come out in the
 371   // wash when we try to set the active config later.
 372   if (!configs) {
 373     int ret = connector_->UpdateModes();
 374     if (ret) {
 375       ALOGE("Failed to update display modes %d", ret);
 376       return HWC2::Error::BadDisplay;
 377     }
 378   }
 379
 380   auto num_modes = static_cast<uint32_t>(connector_->modes().size());
 381   if (!configs) {
 382     *num_configs = num_modes;
 383     return HWC2::Error::None;
 384   }
 385
 386   uint32_t idx = 0;
 387   for (const DrmMode &mode : connector_->modes()) {
 388     if (idx >= *num_configs)
 389       break;
 390     configs[idx++] = mode.id();
 391   }
 392   *num_configs = idx;
 393   return HWC2::Error::None;
 394 }
 395
 396 HWC2::Error DrmHwcTwo::HwcDisplay::GetDisplayName(uint32_t *size, char *name) {
 397   supported(__func__);
 398   std::ostringstream stream;
 399   stream << "display-" << connector_->id();
 400   std::string string = stream.str();
 401   size_t length = string.length();
 402   if (!name) {
 403     *size = length;
 404     return HWC2::Error::None;
 405   }
 406
 407   *size = std::min<uint32_t>(static_cast<uint32_t>(length - 1), *size);
 408   strncpy(name, string.c_str(), *size);
 409   return HWC2::Error::None;
 410 }
 411
 412 HWC2::Error DrmHwcTwo::HwcDisplay::GetDisplayRequests(int32_t *display_requests,
 413                                                       uint32_t *num_elements,
 414                                                       hwc2_layer_t *layers,
 415                                                       int32_t *layer_requests) {
 416   supported(__func__);
 417   // TODO: I think virtual display should request
 418   //      HWC2_DISPLAY_REQUEST_WRITE_CLIENT_TARGET_TO_OUTPUT here
 419   unsupported(__func__, display_requests, num_elements, layers, layer_requests);
 420   *num_elements = 0;
 421   return HWC2::Error::None;
 422 }
 423
 424 HWC2::Error DrmHwcTwo::HwcDisplay::GetDisplayType(int32_t *type) {
 425   supported(__func__);
 426   *type = static_cast<int32_t>(type_);
 427   return HWC2::Error::None;
 428 }
 429
 430 HWC2::Error DrmHwcTwo::HwcDisplay::GetDozeSupport(int32_t *support) {
 431   supported(__func__);
 432   *support = 0;
 433   return HWC2::Error::None;
 434 }
 435
 436 HWC2::Error DrmHwcTwo::HwcDisplay::GetHdrCapabilities(
 437     uint32_t *num_types, int32_t */*types*/, float */*max_luminance*/,
 438     float */*max_average_luminance*/, float */*min_luminance*/) {
 439   supported(__func__);
 440   *num_types = 0;
 441   return HWC2::Error::None;
 442 }
 443
 444 HWC2::Error DrmHwcTwo::HwcDisplay::GetReleaseFences(uint32_t *num_elements,
 445                                                     hwc2_layer_t *layers,
 446                                                     int32_t *fences) {
 447   supported(__func__);
 448   uint32_t num_layers = 0;
 449
 450   for (std::pair<const hwc2_layer_t, DrmHwcTwo::HwcLayer> &l : layers_) {
 451     ++num_layers;
 452     if (layers == NULL || fences == NULL) {
 453       continue;
 454     } else if (num_layers > *num_elements) {
 455       ALOGW("Overflow num_elements %d/%d", num_layers, *num_elements);
 456       return HWC2::Error::None;
 457     }
 458
 459     layers[num_layers - 1] = l.first;
 460     fences[num_layers - 1] = l.second.take_release_fence();
 461   }
 462   *num_elements = num_layers;
 463   return HWC2::Error::None;
 464 }
 465
 466 void DrmHwcTwo::HwcDisplay::AddFenceToRetireFence(int fd) {
 467   supported(__func__);
 468   if (fd < 0)
 469     return;
 470
 471   if (next_retire_fence_.get() >= 0) {
 472     int old_fence = next_retire_fence_.get();
 473     next_retire_fence_.Set(sync_merge("dc_retire", old_fence, fd));
 474   } else {
 475     next_retire_fence_.Set(dup(fd));
 476   }
 477 }
 478
 479 HWC2::Error DrmHwcTwo::HwcDisplay::PresentDisplay(int32_t *retire_fence) {
 480   supported(__func__);
 481   std::vector<DrmCompositionDisplayLayersMap> layers_map;
 482   layers_map.emplace_back();
 483   DrmCompositionDisplayLayersMap &map = layers_map.back();
 484
 485   map.display = static_cast<int>(handle_);
 486   map.geometry_changed = true;  // TODO: Fix this
 487
 488   // order the layers by z-order
 489   bool use_client_layer = false;
 490   uint32_t client_z_order = 0;
 491   std::map<uint32_t, DrmHwcTwo::HwcLayer *> z_map;
 492   for (std::pair<const hwc2_layer_t, DrmHwcTwo::HwcLayer> &l : layers_) {
 493     switch (l.second.validated_type()) {
 494       case HWC2::Composition::Device:
 495         z_map.emplace(std::make_pair(l.second.z_order(), &l.second));
 496         break;
 497       case HWC2::Composition::Client:
 498         // Place it at the z_order of the highest client layer
 499         use_client_layer = true;
 500         client_z_order = std::max(client_z_order, l.second.z_order());
 501         break;
 502       default:
 503         continue;
 504     }
 505   }
 506   if (use_client_layer)
 507     z_map.emplace(std::make_pair(client_z_order, &client_layer_));
 508
 509   // now that they're ordered by z, add them to the composition
 510   for (std::pair<const uint32_t, DrmHwcTwo::HwcLayer *> &l : z_map) {
 511     DrmHwcLayer layer;
 512     l.second->PopulateDrmLayer(&layer);
 513     int ret = layer.ImportBuffer(importer_.get(), gralloc_);
 514     if (ret) {
 515       ALOGE("Failed to import layer, ret=%d", ret);
 516       return HWC2::Error::NoResources;
 517     }
 518     map.layers.emplace_back(std::move(layer));
 519   }
 520   if (map.layers.empty()) {
 521     *retire_fence = -1;
 522     return HWC2::Error::None;
 523   }
 524
 525   std::unique_ptr<DrmDisplayComposition> composition =
 526       compositor_.CreateComposition();
 527   composition->Init(drm_, crtc_, importer_.get(), planner_.get(), frame_no_);
 528
 529   // TODO: Don't always assume geometry changed
 530   int ret = composition->SetLayers(map.layers.data(), map.layers.size(), true);
 531   if (ret) {
 532     ALOGE("Failed to set layers in the composition ret=%d", ret);
 533     return HWC2::Error::BadLayer;
 534   }
 535
 536   std::vector<DrmPlane *> primary_planes(primary_planes_);
 537   std::vector<DrmPlane *> overlay_planes(overlay_planes_);
 538   ret = composition->Plan(compositor_.squash_state(), &primary_planes,
 539                          &overlay_planes);
 540   if (ret) {
 541     ALOGE("Failed to plan the composition ret=%d", ret);
 542     return HWC2::Error::BadConfig;
 543   }
 544
 545   // Disable the planes we're not using
 546   for (auto i = primary_planes.begin(); i != primary_planes.end();) {
 547     composition->AddPlaneDisable(*i);
 548     i = primary_planes.erase(i);
 549   }
 550   for (auto i = overlay_planes.begin(); i != overlay_planes.end();) {
 551     composition->AddPlaneDisable(*i);
 552     i = overlay_planes.erase(i);
 553   }
 554
 555   ret = compositor_.QueueComposition(std::move(composition));
 556   if (ret) {
 557     ALOGE("Failed to apply the frame composition ret=%d", ret);
 558     return HWC2::Error::BadParameter;
 559   }
 560
 561   // Now that the release fences have been generated by the compositor, make
 562   // sure they're managed properly
 563   for (std::pair<const uint32_t, DrmHwcTwo::HwcLayer *> &l : z_map) {
 564     l.second->manage_release_fence();
 565     AddFenceToRetireFence(l.second->release_fence());
 566   }
 567
 568   // The retire fence returned here is for the last frame, so return it and
 569   // promote the next retire fence
 570   *retire_fence = retire_fence_.Release();
 571   retire_fence_ = std::move(next_retire_fence_);
 572
 573   ++frame_no_;
 574   return HWC2::Error::None;
 575 }
 576
 577 HWC2::Error DrmHwcTwo::HwcDisplay::SetActiveConfig(hwc2_config_t config) {
 578   supported(__func__);
 579   auto mode =
 580       std::find_if(connector_->modes().begin(), connector_->modes().end(),
 581                    [config](DrmMode const &m) { return m.id() == config; });
 582   if (mode == connector_->modes().end()) {
 583     ALOGE("Could not find active mode for %d", config);
 584     return HWC2::Error::BadConfig;
 585   }
 586
 587   std::unique_ptr<DrmDisplayComposition> composition =
 588       compositor_.CreateComposition();
 589   composition->Init(drm_, crtc_, importer_.get(), planner_.get(), frame_no_);
 590   int ret = composition->SetDisplayMode(*mode);
 591   ret = compositor_.QueueComposition(std::move(composition));
 592   if (ret) {
 593     ALOGE("Failed to queue dpms composition on %d", ret);
 594     return HWC2::Error::BadConfig;
 595   }
 596   if (connector_->active_mode().id() == 0)
 597     connector_->set_active_mode(*mode);
 598
 599   // Setup the client layer's dimensions
 600   hwc_rect_t display_frame = {.left = 0,
 601                               .top = 0,
 602                               .right = static_cast<int>(mode->h_display()),
 603                               .bottom = static_cast<int>(mode->v_display())};
 604   client_layer_.SetLayerDisplayFrame(display_frame);
 605   hwc_frect_t source_crop = {.left = 0.0f,
 606                              .top = 0.0f,
 607                              .right = mode->h_display() + 0.0f,
 608                              .bottom = mode->v_display() + 0.0f};
 609   client_layer_.SetLayerSourceCrop(source_crop);
 610
 611   return HWC2::Error::None;
 612 }
 613
 614 HWC2::Error DrmHwcTwo::HwcDisplay::SetClientTarget(buffer_handle_t target,
 615                                                    int32_t acquire_fence,
 616                                                    int32_t dataspace,
 617                                                    hwc_region_t damage) {
 618   supported(__func__);
 619   UniqueFd uf(acquire_fence);
 620
 621   client_layer_.set_buffer(target);
 622   client_layer_.set_acquire_fence(uf.get());
 623   client_layer_.SetLayerDataspace(dataspace);
 624   return HWC2::Error::None;
 625 }
 626
 627 HWC2::Error DrmHwcTwo::HwcDisplay::SetColorMode(int32_t mode) {
 628   supported(__func__);
 629   // TODO: android_color_mode_t isn't defined yet!
 630   return unsupported(__func__, mode);
 631 }
 632
 633 HWC2::Error DrmHwcTwo::HwcDisplay::SetColorTransform(const float *matrix,
 634                                                      int32_t hint) {
 635   supported(__func__);
 636   // TODO: Force client composition if we get this
 637   return unsupported(__func__, matrix, hint);
 638 }
 639
 640 HWC2::Error DrmHwcTwo::HwcDisplay::SetOutputBuffer(buffer_handle_t buffer,
 641                                                    int32_t release_fence) {
 642   supported(__func__);
 643   // TODO: Need virtual display support
 644   return unsupported(__func__, buffer, release_fence);
 645 }
 646
 647 HWC2::Error DrmHwcTwo::HwcDisplay::SetPowerMode(int32_t mode_in) {
 648   supported(__func__);
 649   uint64_t dpms_value = 0;
 650   auto mode = static_cast<HWC2::PowerMode>(mode_in);
 651   switch (mode) {
 652     case HWC2::PowerMode::Off:
 653       dpms_value = DRM_MODE_DPMS_OFF;
 654       break;
 655     case HWC2::PowerMode::On:
 656       dpms_value = DRM_MODE_DPMS_ON;
 657       break;
 658     default:
 659       ALOGI("Power mode %d is unsupported\n", mode);
 660       return HWC2::Error::Unsupported;
 661   };
 662
 663   std::unique_ptr<DrmDisplayComposition> composition =
 664       compositor_.CreateComposition();
 665   composition->Init(drm_, crtc_, importer_.get(), planner_.get(), frame_no_);
 666   composition->SetDpmsMode(dpms_value);
 667   int ret = compositor_.QueueComposition(std::move(composition));
 668   if (ret) {
 669     ALOGE("Failed to apply the dpms composition ret=%d", ret);
 670     return HWC2::Error::BadParameter;
 671   }
 672   return HWC2::Error::None;
 673 }
 674
 675 HWC2::Error DrmHwcTwo::HwcDisplay::SetVsyncEnabled(int32_t enabled) {
 676   supported(__func__);
 677   vsync_worker_.VSyncControl(enabled);
 678   return HWC2::Error::None;
 679 }
 680
 681 HWC2::Error DrmHwcTwo::HwcDisplay::ValidateDisplay(uint32_t *num_types,
 682                                                    uint32_t *num_requests) {
 683   supported(__func__);
 684   *num_types = 0;
 685   *num_requests = 0;
 686   for (std::pair<const hwc2_layer_t, DrmHwcTwo::HwcLayer> &l : layers_) {
 687     DrmHwcTwo::HwcLayer &layer = l.second;
 688     switch (layer.sf_type()) {
 689       case HWC2::Composition::SolidColor:
 690       case HWC2::Composition::Cursor:
 691       case HWC2::Composition::Sideband:
 692         layer.set_validated_type(HWC2::Composition::Client);
 693         ++*num_types;
 694         break;
 695       default:
 696         layer.set_validated_type(layer.sf_type());
 697         break;
 698     }
 699   }
 700   return HWC2::Error::None;
 701 }
 702
 703 HWC2::Error DrmHwcTwo::HwcLayer::SetCursorPosition(int32_t x, int32_t y) {
 704   supported(__func__);
 705   // TODO: Implement proper cursor support
 706   return unsupported(__func__, x, y);
 707 }
 708
 709 HWC2::Error DrmHwcTwo::HwcLayer::SetLayerBlendMode(int32_t mode) {
 710   supported(__func__);
 711   blending_ = static_cast<HWC2::BlendMode>(mode);
 712   return HWC2::Error::None;
 713 }
 714
 715 HWC2::Error DrmHwcTwo::HwcLayer::SetLayerBuffer(buffer_handle_t buffer,
 716                                                 int32_t acquire_fence) {
 717   supported(__func__);
 718   UniqueFd uf(acquire_fence);
 719
 720   // The buffer and acquire_fence are handled elsewhere
 721   if (sf_type_ == HWC2::Composition::Client ||
 722       sf_type_ == HWC2::Composition::Sideband ||
 723       sf_type_ == HWC2::Composition::SolidColor)
 724     return HWC2::Error::None;
 725
 726   set_buffer(buffer);
 727   set_acquire_fence(uf.get());
 728   return HWC2::Error::None;
 729 }
 730
 731 HWC2::Error DrmHwcTwo::HwcLayer::SetLayerColor(hwc_color_t color) {
 732   // TODO: Punt to client composition here?
 733   return unsupported(__func__, color);
 734 }
 735
 736 HWC2::Error DrmHwcTwo::HwcLayer::SetLayerCompositionType(int32_t type) {
 737   sf_type_ = static_cast<HWC2::Composition>(type);
 738   return HWC2::Error::None;
 739 }
 740
 741 HWC2::Error DrmHwcTwo::HwcLayer::SetLayerDataspace(int32_t dataspace) {
 742   supported(__func__);
 743   dataspace_ = static_cast<android_dataspace_t>(dataspace);
 744   return HWC2::Error::None;
 745 }
 746
 747 HWC2::Error DrmHwcTwo::HwcLayer::SetLayerDisplayFrame(hwc_rect_t frame) {
 748   supported(__func__);
 749   display_frame_ = frame;
 750   return HWC2::Error::None;
 751 }
 752
 753 HWC2::Error DrmHwcTwo::HwcLayer::SetLayerPlaneAlpha(float alpha) {
 754   supported(__func__);
 755   alpha_ = alpha;
 756   return HWC2::Error::None;
 757 }
 758
 759 HWC2::Error DrmHwcTwo::HwcLayer::SetLayerSidebandStream(
 760     const native_handle_t *stream) {
 761   supported(__func__);
 762   // TODO: We don't support sideband
 763   return unsupported(__func__, stream);
 764 }
 765
 766 HWC2::Error DrmHwcTwo::HwcLayer::SetLayerSourceCrop(hwc_frect_t crop) {
 767   supported(__func__);
 768   source_crop_ = crop;
 769   return HWC2::Error::None;
 770 }
 771
 772 HWC2::Error DrmHwcTwo::HwcLayer::SetLayerSurfaceDamage(hwc_region_t damage) {
 773   supported(__func__);
 774   // TODO: We don't use surface damage, marking as unsupported
 775   unsupported(__func__, damage);
 776   return HWC2::Error::None;
 777 }
 778
 779 HWC2::Error DrmHwcTwo::HwcLayer::SetLayerTransform(int32_t transform) {
 780   supported(__func__);
 781   transform_ = static_cast<HWC2::Transform>(transform);
 782   return HWC2::Error::None;
 783 }
 784
 785 HWC2::Error DrmHwcTwo::HwcLayer::SetLayerVisibleRegion(hwc_region_t visible) {
 786   supported(__func__);
 787   // TODO: We don't use this information, marking as unsupported
 788   unsupported(__func__, visible);
 789   return HWC2::Error::None;
 790 }
 791
 792 HWC2::Error DrmHwcTwo::HwcLayer::SetLayerZOrder(uint32_t order) {
 793   supported(__func__);
 794   z_order_ = order;
 795   return HWC2::Error::None;
 796 }
 797
 798 void DrmHwcTwo::HwcLayer::PopulateDrmLayer(DrmHwcLayer *layer) {
 799   supported(__func__);
 800   switch (blending_) {
 801     case HWC2::BlendMode::None:
 802       layer->blending = DrmHwcBlending::kNone;
 803       break;
 804     case HWC2::BlendMode::Premultiplied:
 805       layer->blending = DrmHwcBlending::kPreMult;
 806       break;
 807     case HWC2::BlendMode::Coverage:
 808       layer->blending = DrmHwcBlending::kCoverage;
 809       break;
 810     default:
 811       ALOGE("Unknown blending mode b=%d", blending_);
 812       layer->blending = DrmHwcBlending::kNone;
 813       break;
 814   }
 815
 816   OutputFd release_fence = release_fence_output();
 817
 818   layer->sf_handle = buffer_;
 819   layer->acquire_fence = acquire_fence_.Release();
 820   layer->release_fence = std::move(release_fence);
 821   layer->SetDisplayFrame(display_frame_);
 822   layer->alpha = static_cast<uint8_t>(255.0f * alpha_ + 0.5f);
 823   layer->SetSourceCrop(source_crop_);
 824   layer->SetTransform(static_cast<int32_t>(transform_));
 825 }
 826
 827 // static
 828 int DrmHwcTwo::HookDevClose(hw_device_t * /*dev*/) {
 829   unsupported(__func__);
 830   return 0;
 831 }
 832
 833 // static
 834 void DrmHwcTwo::HookDevGetCapabilities(hwc2_device_t * /*dev*/,
 835                                        uint32_t *out_count,
 836                                        int32_t * /*out_capabilities*/) {
 837   supported(__func__);
 838   *out_count = 0;
 839 }
 840
 841 // static
 842 hwc2_function_pointer_t DrmHwcTwo::HookDevGetFunction(
 843     struct hwc2_device * /*dev*/, int32_t descriptor) {
 844   supported(__func__);
 845   auto func = static_cast<HWC2::FunctionDescriptor>(descriptor);
 846   switch (func) {
 847     // Device functions
 848     case HWC2::FunctionDescriptor::CreateVirtualDisplay:
 849       return ToHook<HWC2_PFN_CREATE_VIRTUAL_DISPLAY>(
 850           DeviceHook<int32_t, decltype(&DrmHwcTwo::CreateVirtualDisplay),
 851                      &DrmHwcTwo::CreateVirtualDisplay, uint32_t, uint32_t,
 852                      int32_t*, hwc2_display_t *>);
 853     case HWC2::FunctionDescriptor::DestroyVirtualDisplay:
 854       return ToHook<HWC2_PFN_DESTROY_VIRTUAL_DISPLAY>(
 855           DeviceHook<int32_t, decltype(&DrmHwcTwo::DestroyVirtualDisplay),
 856                      &DrmHwcTwo::DestroyVirtualDisplay, hwc2_display_t>);
 857     case HWC2::FunctionDescriptor::Dump:
 858       return ToHook<HWC2_PFN_DUMP>(
 859           DeviceHook<void, decltype(&DrmHwcTwo::Dump), &DrmHwcTwo::Dump,
 860                      uint32_t *, char *>);
 861     case HWC2::FunctionDescriptor::GetMaxVirtualDisplayCount:
 862       return ToHook<HWC2_PFN_GET_MAX_VIRTUAL_DISPLAY_COUNT>(
 863           DeviceHook<uint32_t, decltype(&DrmHwcTwo::GetMaxVirtualDisplayCount),
 864                      &DrmHwcTwo::GetMaxVirtualDisplayCount>);
 865     case HWC2::FunctionDescriptor::RegisterCallback:
 866       return ToHook<HWC2_PFN_REGISTER_CALLBACK>(
 867           DeviceHook<int32_t, decltype(&DrmHwcTwo::RegisterCallback),
 868                      &DrmHwcTwo::RegisterCallback, int32_t,
 869                      hwc2_callback_data_t, hwc2_function_pointer_t>);
 870
 871     // Display functions
 872     case HWC2::FunctionDescriptor::AcceptDisplayChanges:
 873       return ToHook<HWC2_PFN_ACCEPT_DISPLAY_CHANGES>(
 874           DisplayHook<decltype(&HwcDisplay::AcceptDisplayChanges),
 875                       &HwcDisplay::AcceptDisplayChanges>);
 876     case HWC2::FunctionDescriptor::CreateLayer:
 877       return ToHook<HWC2_PFN_CREATE_LAYER>(
 878           DisplayHook<decltype(&HwcDisplay::CreateLayer),
 879                       &HwcDisplay::CreateLayer, hwc2_layer_t *>);
 880     case HWC2::FunctionDescriptor::DestroyLayer:
 881       return ToHook<HWC2_PFN_DESTROY_LAYER>(
 882           DisplayHook<decltype(&HwcDisplay::DestroyLayer),
 883                       &HwcDisplay::DestroyLayer, hwc2_layer_t>);
 884     case HWC2::FunctionDescriptor::GetActiveConfig:
 885       return ToHook<HWC2_PFN_GET_ACTIVE_CONFIG>(
 886           DisplayHook<decltype(&HwcDisplay::GetActiveConfig),
 887                       &HwcDisplay::GetActiveConfig, hwc2_config_t *>);
 888     case HWC2::FunctionDescriptor::GetChangedCompositionTypes:
 889       return ToHook<HWC2_PFN_GET_CHANGED_COMPOSITION_TYPES>(
 890           DisplayHook<decltype(&HwcDisplay::GetChangedCompositionTypes),
 891                       &HwcDisplay::GetChangedCompositionTypes, uint32_t *,
 892                       hwc2_layer_t *, int32_t *>);
 893     case HWC2::FunctionDescriptor::GetClientTargetSupport:
 894       return ToHook<HWC2_PFN_GET_CLIENT_TARGET_SUPPORT>(
 895           DisplayHook<decltype(&HwcDisplay::GetClientTargetSupport),
 896                       &HwcDisplay::GetClientTargetSupport, uint32_t, uint32_t,
 897                       int32_t, int32_t>);
 898     case HWC2::FunctionDescriptor::GetColorModes:
 899       return ToHook<HWC2_PFN_GET_COLOR_MODES>(
 900           DisplayHook<decltype(&HwcDisplay::GetColorModes),
 901                       &HwcDisplay::GetColorModes, uint32_t *, int32_t *>);
 902     case HWC2::FunctionDescriptor::GetDisplayAttribute:
 903       return ToHook<HWC2_PFN_GET_DISPLAY_ATTRIBUTE>(DisplayHook<
 904           decltype(&HwcDisplay::GetDisplayAttribute),
 905           &HwcDisplay::GetDisplayAttribute, hwc2_config_t, int32_t, int32_t *>);
 906     case HWC2::FunctionDescriptor::GetDisplayConfigs:
 907       return ToHook<HWC2_PFN_GET_DISPLAY_CONFIGS>(DisplayHook<
 908           decltype(&HwcDisplay::GetDisplayConfigs),
 909           &HwcDisplay::GetDisplayConfigs, uint32_t *, hwc2_config_t *>);
 910     case HWC2::FunctionDescriptor::GetDisplayName:
 911       return ToHook<HWC2_PFN_GET_DISPLAY_NAME>(
 912           DisplayHook<decltype(&HwcDisplay::GetDisplayName),
 913                       &HwcDisplay::GetDisplayName, uint32_t *, char *>);
 914     case HWC2::FunctionDescriptor::GetDisplayRequests:
 915       return ToHook<HWC2_PFN_GET_DISPLAY_REQUESTS>(
 916           DisplayHook<decltype(&HwcDisplay::GetDisplayRequests),
 917                       &HwcDisplay::GetDisplayRequests, int32_t *, uint32_t *,
 918                       hwc2_layer_t *, int32_t *>);
 919     case HWC2::FunctionDescriptor::GetDisplayType:
 920       return ToHook<HWC2_PFN_GET_DISPLAY_TYPE>(
 921           DisplayHook<decltype(&HwcDisplay::GetDisplayType),
 922                       &HwcDisplay::GetDisplayType, int32_t *>);
 923     case HWC2::FunctionDescriptor::GetDozeSupport:
 924       return ToHook<HWC2_PFN_GET_DOZE_SUPPORT>(
 925           DisplayHook<decltype(&HwcDisplay::GetDozeSupport),
 926                       &HwcDisplay::GetDozeSupport, int32_t *>);
 927     case HWC2::FunctionDescriptor::GetHdrCapabilities:
 928       return ToHook<HWC2_PFN_GET_HDR_CAPABILITIES>(
 929           DisplayHook<decltype(&HwcDisplay::GetHdrCapabilities),
 930                       &HwcDisplay::GetHdrCapabilities, uint32_t *, int32_t *,
 931                       float *, float *, float *>);
 932     case HWC2::FunctionDescriptor::GetReleaseFences:
 933       return ToHook<HWC2_PFN_GET_RELEASE_FENCES>(
 934           DisplayHook<decltype(&HwcDisplay::GetReleaseFences),
 935                       &HwcDisplay::GetReleaseFences, uint32_t *, hwc2_layer_t *,
 936                       int32_t *>);
 937     case HWC2::FunctionDescriptor::PresentDisplay:
 938       return ToHook<HWC2_PFN_PRESENT_DISPLAY>(
 939           DisplayHook<decltype(&HwcDisplay::PresentDisplay),
 940                       &HwcDisplay::PresentDisplay, int32_t *>);
 941     case HWC2::FunctionDescriptor::SetActiveConfig:
 942       return ToHook<HWC2_PFN_SET_ACTIVE_CONFIG>(
 943           DisplayHook<decltype(&HwcDisplay::SetActiveConfig),
 944                       &HwcDisplay::SetActiveConfig, hwc2_config_t>);
 945     case HWC2::FunctionDescriptor::SetClientTarget:
 946       return ToHook<HWC2_PFN_SET_CLIENT_TARGET>(DisplayHook<
 947           decltype(&HwcDisplay::SetClientTarget), &HwcDisplay::SetClientTarget,
 948           buffer_handle_t, int32_t, int32_t, hwc_region_t>);
 949     case HWC2::FunctionDescriptor::SetColorMode:
 950       return ToHook<HWC2_PFN_SET_COLOR_MODE>(
 951           DisplayHook<decltype(&HwcDisplay::SetColorMode),
 952                       &HwcDisplay::SetColorMode, int32_t>);
 953     case HWC2::FunctionDescriptor::SetColorTransform:
 954       return ToHook<HWC2_PFN_SET_COLOR_TRANSFORM>(
 955           DisplayHook<decltype(&HwcDisplay::SetColorTransform),
 956                       &HwcDisplay::SetColorTransform, const float *, int32_t>);
 957     case HWC2::FunctionDescriptor::SetOutputBuffer:
 958       return ToHook<HWC2_PFN_SET_OUTPUT_BUFFER>(
 959           DisplayHook<decltype(&HwcDisplay::SetOutputBuffer),
 960                       &HwcDisplay::SetOutputBuffer, buffer_handle_t, int32_t>);
 961     case HWC2::FunctionDescriptor::SetPowerMode:
 962       return ToHook<HWC2_PFN_SET_POWER_MODE>(
 963           DisplayHook<decltype(&HwcDisplay::SetPowerMode),
 964                       &HwcDisplay::SetPowerMode, int32_t>);
 965     case HWC2::FunctionDescriptor::SetVsyncEnabled:
 966       return ToHook<HWC2_PFN_SET_VSYNC_ENABLED>(
 967           DisplayHook<decltype(&HwcDisplay::SetVsyncEnabled),
 968                       &HwcDisplay::SetVsyncEnabled, int32_t>);
 969     case HWC2::FunctionDescriptor::ValidateDisplay:
 970       return ToHook<HWC2_PFN_VALIDATE_DISPLAY>(
 971           DisplayHook<decltype(&HwcDisplay::ValidateDisplay),
 972                       &HwcDisplay::ValidateDisplay, uint32_t *, uint32_t *>);
 973
 974     // Layer functions
 975     case HWC2::FunctionDescriptor::SetCursorPosition:
 976       return ToHook<HWC2_PFN_SET_CURSOR_POSITION>(
 977           LayerHook<decltype(&HwcLayer::SetCursorPosition),
 978                     &HwcLayer::SetCursorPosition, int32_t, int32_t>);
 979     case HWC2::FunctionDescriptor::SetLayerBlendMode:
 980       return ToHook<HWC2_PFN_SET_LAYER_BLEND_MODE>(
 981           LayerHook<decltype(&HwcLayer::SetLayerBlendMode),
 982                     &HwcLayer::SetLayerBlendMode, int32_t>);
 983     case HWC2::FunctionDescriptor::SetLayerBuffer:
 984       return ToHook<HWC2_PFN_SET_LAYER_BUFFER>(
 985           LayerHook<decltype(&HwcLayer::SetLayerBuffer),
 986                     &HwcLayer::SetLayerBuffer, buffer_handle_t, int32_t>);
 987     case HWC2::FunctionDescriptor::SetLayerColor:
 988       return ToHook<HWC2_PFN_SET_LAYER_COLOR>(
 989           LayerHook<decltype(&HwcLayer::SetLayerColor),
 990                     &HwcLayer::SetLayerColor, hwc_color_t>);
 991     case HWC2::FunctionDescriptor::SetLayerCompositionType:
 992       return ToHook<HWC2_PFN_SET_LAYER_COMPOSITION_TYPE>(
 993           LayerHook<decltype(&HwcLayer::SetLayerCompositionType),
 994                     &HwcLayer::SetLayerCompositionType, int32_t>);
 995     case HWC2::FunctionDescriptor::SetLayerDataspace:
 996       return ToHook<HWC2_PFN_SET_LAYER_DATASPACE>(
 997           LayerHook<decltype(&HwcLayer::SetLayerDataspace),
 998                     &HwcLayer::SetLayerDataspace, int32_t>);
 999     case HWC2::FunctionDescriptor::SetLayerDisplayFrame:
1000       return ToHook<HWC2_PFN_SET_LAYER_DISPLAY_FRAME>(
1001           LayerHook<decltype(&HwcLayer::SetLayerDisplayFrame),
1002                     &HwcLayer::SetLayerDisplayFrame, hwc_rect_t>);
1003     case HWC2::FunctionDescriptor::SetLayerPlaneAlpha:
1004       return ToHook<HWC2_PFN_SET_LAYER_PLANE_ALPHA>(
1005           LayerHook<decltype(&HwcLayer::SetLayerPlaneAlpha),
1006                     &HwcLayer::SetLayerPlaneAlpha, float>);
1007     case HWC2::FunctionDescriptor::SetLayerSidebandStream:
1008       return ToHook<HWC2_PFN_SET_LAYER_SIDEBAND_STREAM>(LayerHook<
1009           decltype(&HwcLayer::SetLayerSidebandStream),
1010           &HwcLayer::SetLayerSidebandStream, const native_handle_t *>);
1011     case HWC2::FunctionDescriptor::SetLayerSourceCrop:
1012       return ToHook<HWC2_PFN_SET_LAYER_SOURCE_CROP>(
1013           LayerHook<decltype(&HwcLayer::SetLayerSourceCrop),
1014                     &HwcLayer::SetLayerSourceCrop, hwc_frect_t>);
1015     case HWC2::FunctionDescriptor::SetLayerSurfaceDamage:
1016       return ToHook<HWC2_PFN_SET_LAYER_SURFACE_DAMAGE>(
1017           LayerHook<decltype(&HwcLayer::SetLayerSurfaceDamage),
1018                     &HwcLayer::SetLayerSurfaceDamage, hwc_region_t>);
1019     case HWC2::FunctionDescriptor::SetLayerTransform:
1020       return ToHook<HWC2_PFN_SET_LAYER_TRANSFORM>(
1021           LayerHook<decltype(&HwcLayer::SetLayerTransform),
1022                     &HwcLayer::SetLayerTransform, int32_t>);
1023     case HWC2::FunctionDescriptor::SetLayerVisibleRegion:
1024       return ToHook<HWC2_PFN_SET_LAYER_VISIBLE_REGION>(
1025           LayerHook<decltype(&HwcLayer::SetLayerVisibleRegion),
1026                     &HwcLayer::SetLayerVisibleRegion, hwc_region_t>);
1027     case HWC2::FunctionDescriptor::SetLayerZOrder:
1028       return ToHook<HWC2_PFN_SET_LAYER_Z_ORDER>(
1029           LayerHook<decltype(&HwcLayer::SetLayerZOrder),
1030                     &HwcLayer::SetLayerZOrder, uint32_t>);
1031     case HWC2::FunctionDescriptor::Invalid:
1032     default:
1033       return NULL;
1034   }
1035 }
1036
1037 // static
1038 int DrmHwcTwo::HookDevOpen(const struct hw_module_t *module, const char *name,
1039                            struct hw_device_t **dev) {
1040   supported(__func__);
1041   if (strcmp(name, HWC_HARDWARE_COMPOSER)) {
1042     ALOGE("Invalid module name- %s", name);
1043     return -EINVAL;
1044   }
1045
1046   std::unique_ptr<DrmHwcTwo> ctx(new DrmHwcTwo());
1047   if (!ctx) {
1048     ALOGE("Failed to allocate DrmHwcTwo");
1049     return -ENOMEM;
1050   }
1051
1052   HWC2::Error err = ctx->Init();
1053   if (err != HWC2::Error::None) {
1054     ALOGE("Failed to initialize DrmHwcTwo err=%d\n", err);
1055     return -EINVAL;
1056   }
1057
1058   ctx->common.module = const_cast<hw_module_t *>(module);
1059   *dev = &ctx->common;
1060   ctx.release();
1061   return 0;
1062 }
1063 }
1064
1065 static struct hw_module_methods_t hwc2_module_methods = {
1066     .open = android::DrmHwcTwo::HookDevOpen,
1067 };
1068
1069 hw_module_t HAL_MODULE_INFO_SYM = {
1070     .tag = HARDWARE_MODULE_TAG,
1071     .module_api_version = HARDWARE_MODULE_API_VERSION(2, 0),
1072     .id = HWC_HARDWARE_MODULE_ID,
1073     .name = "DrmHwcTwo module",
1074     .author = "The Android Open Source Project",
1075     .methods = &hwc2_module_methods,
1076     .dso = NULL,
1077     .reserved = {0},
1078 };