Merge remote-tracking branch 'aosp/upstream-master' into HEAD am: 68b94c0fae am: 344722436b

am: 7a477bc410

Change-Id: I3201b4edf82aefeffd8d88554f202e897265ae05

15 files changed, 295 insertions, 82 deletions

diff --git a/Android.bp b/Android.bp
index 5681cb7..85be0b5 100644
--- a/Android.bp
+++ b/Android.bp
@@ -110,6 +110,15 @@ cc_library_shared {
     include_dirs: ["external/minigbm/cros_gralloc"],
 }
 
+// Used by hwcomposer.drm_imagination
+filegroup {
+    name: "drm_hwcomposer_platformimagination",
+    srcs: [
+        "platform/platformdrmgeneric.cpp",
+        "platform/platformimagination.cpp",
+    ],
+}
+
 // Used by hwcomposer.drm_hikey and hwcomposer.drm_hikey960
 filegroup {
     name: "drm_hwcomposer_platformhisi",
diff --git a/drm/drmconnector.cpp b/drm/drmconnector.cpp
index 543827d..7cde7cd 100644
--- a/drm/drmconnector.cpp
+++ b/drm/drmconnector.cpp
@@ -22,11 +22,16 @@
 #include <errno.h>
 #include <stdint.h>
 
+#include <array>
+#include <sstream>
+
 #include <log/log.h>
 #include <xf86drmMode.h>
 
 namespace android {
 
+constexpr size_t TYPES_COUNT = 17;
+
 DrmConnector::DrmConnector(DrmDevice *drm, drmModeConnectorPtr c,
                            DrmEncoder *current_encoder,
                            std::vector<DrmEncoder *> &possible_encoders)
@@ -35,6 +40,7 @@ DrmConnector::DrmConnector(DrmDevice *drm, drmModeConnectorPtr c,
       encoder_(current_encoder),
       display_(-1),
       type_(c->connector_type),
+      type_id_(c->connector_type_id),
       state_(c->connection),
       mm_width_(c->mmWidth),
       mm_height_(c->mmHeight),
@@ -112,6 +118,22 @@ bool DrmConnector::valid_type() const {
   return internal() || external() || writeback();
 }
 
+std::string DrmConnector::name() const {
+  constexpr std::array<const char *, TYPES_COUNT> names =
+      {"None",   "VGA",  "DVI-I",     "DVI-D",   "DVI-A", "Composite",
+       "SVIDEO", "LVDS", "Component", "DIN",     "DP",    "HDMI-A",
+       "HDMI-B", "TV",   "eDP",       "Virtual", "DSI"};
+
+  if (type_ < TYPES_COUNT) {
+    std::ostringstream name_buf;
+    name_buf << names[type_] << "-" << type_id_;
+    return name_buf.str();
+  } else {
+    ALOGE("Unknown type in connector %d, could not make his name", id_);
+    return "None";
+  }
+}
+
 int DrmConnector::UpdateModes() {
   int fd = drm_->fd();
 
diff --git a/drm/drmdevice.cpp b/drm/drmdevice.cpp
index 2007fdd..bcb9ddd 100644
--- a/drm/drmdevice.cpp
+++ b/drm/drmdevice.cpp
@@ -30,11 +30,91 @@
 #include <xf86drmMode.h>
 #include <cinttypes>
 
+#include <algorithm>
+#include <array>
+#include <string>
+
 #include <cutils/properties.h>
 #include <log/log.h>
 
+static void trim_left(std::string &str) {
+  str.erase(std::begin(str),
+            std::find_if(std::begin(str), std::end(str),
+                         [](int ch) { return !std::isspace(ch); }));
+}
+
+static void trim_right(std::string &str) {
+  str.erase(std::find_if(std::rbegin(str), std::rend(str),
+                         [](int ch) { return !std::isspace(ch); })
+                .base(),
+            std::end(str));
+}
+
+static void trim(std::string &str) {
+  trim_left(str);
+  trim_right(str);
+}
+
 namespace android {
 
+static std::vector<std::string> read_primary_display_order_prop() {
+  std::array<char, PROPERTY_VALUE_MAX> display_order_buf;
+  property_get("hwc.drm.primary_display_order", display_order_buf.data(),
+               "...");
+
+  std::vector<std::string> display_order;
+  std::istringstream str(display_order_buf.data());
+  for (std::string conn_name = ""; std::getline(str, conn_name, ',');) {
+    trim(conn_name);
+    display_order.push_back(std::move(conn_name));
+  }
+  return display_order;
+}
+
+static std::vector<DrmConnector *> make_primary_display_candidates(
+    std::vector<std::unique_ptr<DrmConnector>> &connectors) {
+  std::vector<DrmConnector *> primary_candidates;
+  std::transform(std::begin(connectors), std::end(connectors),
+                 std::back_inserter(primary_candidates),
+                 [](std::unique_ptr<DrmConnector> &conn) {
+                   return conn.get();
+                 });
+  primary_candidates.erase(std::remove_if(std::begin(primary_candidates),
+                                          std::end(primary_candidates),
+                                          [](const DrmConnector *conn) {
+                                            return conn->state() !=
+                                                   DRM_MODE_CONNECTED;
+                                          }),
+                           std::end(primary_candidates));
+
+  std::vector<std::string> display_order = read_primary_display_order_prop();
+  bool use_other = display_order.back() == "...";
+
+  // putting connectors from primary_display_order first
+  auto curr_connector = std::begin(primary_candidates);
+  for (const std::string &display_name : display_order) {
+    auto it = std::find_if(std::begin(primary_candidates),
+                           std::end(primary_candidates),
+                           [&display_name](const DrmConnector *conn) {
+                             return conn->name() == display_name;
+                           });
+    if (it != std::end(primary_candidates)) {
+      std::iter_swap(it, curr_connector);
+      ++curr_connector;
+    }
+  }
+
+  if (use_other) {
+    // then putting internal connectors second, everything else afterwards
+    std::partition(curr_connector, std::end(primary_candidates),
+                   [](const DrmConnector *conn) { return conn->internal(); });
+  } else {
+    primary_candidates.erase(curr_connector, std::end(primary_candidates));
+  }
+
+  return primary_candidates;
+}
+
 DrmDevice::DrmDevice() : event_listener_(this) {
 }
 
@@ -173,19 +253,26 @@ std::tuple<int, int> DrmDevice::Init(const char *path, int num_displays) {
       connectors_.emplace_back(std::move(conn));
   }
 
-  // First look for primary amongst internal connectors
-  for (auto &conn : connectors_) {
-    if (conn->internal() && !found_primary) {
-      conn->set_display(num_displays);
-      displays_[num_displays] = num_displays;
-      ++num_displays;
-      found_primary = true;
-      break;
-    }
+  // Primary display priority:
+  // 1) hwc.drm.primary_display_order property
+  // 2) internal connectors
+  // 3) anything else
+  std::vector<DrmConnector *>
+      primary_candidates = make_primary_display_candidates(connectors_);
+  if (!primary_candidates.empty() && !found_primary) {
+    DrmConnector &conn = **std::begin(primary_candidates);
+    conn.set_display(num_displays);
+    displays_[num_displays] = num_displays;
+    ++num_displays;
+    found_primary = true;
+  } else {
+    ALOGE(
+        "Failed to find primary display from \"hwc.drm.primary_display_order\" "
+        "property");
   }
 
-  // Then pick first available as primary and for the others assign
-  // consecutive display_numbers.
+  // If no priority display were found then pick first available as primary and
+  // for the others assign consecutive display_numbers.
   for (auto &conn : connectors_) {
     if (conn->external() || conn->internal()) {
       if (!found_primary) {
diff --git a/drmhwctwo.cpp b/drmhwctwo.cpp
index 814d8f7..ffc5fcd 100644
--- a/drmhwctwo.cpp
+++ b/drmhwctwo.cpp
@@ -547,19 +547,25 @@ HWC2::Error DrmHwcTwo::HwcDisplay::GetReleaseFences(uint32_t *num_elements,
   return HWC2::Error::None;
 }
 
-void DrmHwcTwo::HwcDisplay::AddFenceToRetireFence(int fd) {
-  supported(__func__);
+void DrmHwcTwo::HwcDisplay::AddFenceToPresentFence(int fd) {
   if (fd < 0)
     return;
 
-  if (next_retire_fence_.get() >= 0) {
-    int old_fence = next_retire_fence_.get();
-    next_retire_fence_.Set(sync_merge("dc_retire", old_fence, fd));
+  if (present_fence_.get() >= 0) {
+    int old_fence = present_fence_.get();
+    present_fence_.Set(sync_merge("dc_present", old_fence, fd));
+    close(fd);
   } else {
-    next_retire_fence_.Set(dup(fd));
+    present_fence_.Set(fd);
   }
 }
 
+bool DrmHwcTwo::HwcDisplay::HardwareSupportsLayerType(
+    HWC2::Composition comp_type) {
+  return comp_type == HWC2::Composition::Device ||
+         comp_type == HWC2::Composition::Cursor;
+}
+
 HWC2::Error DrmHwcTwo::HwcDisplay::CreateComposition(bool test) {
   std::vector<DrmCompositionDisplayLayersMap> layers_map;
   layers_map.emplace_back();
@@ -573,17 +579,7 @@ HWC2::Error DrmHwcTwo::HwcDisplay::CreateComposition(bool test) {
   uint32_t client_z_order = UINT32_MAX;
   std::map<uint32_t, DrmHwcTwo::HwcLayer *> z_map;
   for (std::pair<const hwc2_layer_t, DrmHwcTwo::HwcLayer> &l : layers_) {
-    HWC2::Composition comp_type;
-    if (test) {
-      comp_type = l.second.sf_type();
-      if (comp_type == HWC2::Composition::Device) {
-        if (!importer_->CanImportBuffer(l.second.buffer()))
-          comp_type = HWC2::Composition::Client;
-      }
-    } else
-      comp_type = l.second.validated_type();
-
-    switch (comp_type) {
+    switch (l.second.validated_type()) {
       case HWC2::Composition::Device:
         z_map.emplace(std::make_pair(l.second.z_order(), &l.second));
         break;
@@ -646,8 +642,8 @@ HWC2::Error DrmHwcTwo::HwcDisplay::CreateComposition(bool test) {
   if (test) {
     ret = compositor_.TestComposition(composition.get());
   } else {
-    AddFenceToRetireFence(composition->take_out_fence());
     ret = compositor_.ApplyComposition(std::move(composition));
+    AddFenceToPresentFence(compositor_.TakeOutFence());
   }
   if (ret) {
     if (!test)
@@ -657,23 +653,20 @@ HWC2::Error DrmHwcTwo::HwcDisplay::CreateComposition(bool test) {
   return HWC2::Error::None;
 }
 
-HWC2::Error DrmHwcTwo::HwcDisplay::PresentDisplay(int32_t *retire_fence) {
+HWC2::Error DrmHwcTwo::HwcDisplay::PresentDisplay(int32_t *present_fence) {
   supported(__func__);
   HWC2::Error ret;
 
   ret = CreateComposition(false);
   if (ret == HWC2::Error::BadLayer) {
     // Can we really have no client or device layers?
-    *retire_fence = -1;
+    *present_fence = -1;
     return HWC2::Error::None;
   }
   if (ret != HWC2::Error::None)
     return ret;
 
-  // The retire fence returned here is for the last frame, so return it and
-  // promote the next retire fence
-  *retire_fence = retire_fence_.Release();
-  retire_fence_ = std::move(next_retire_fence_);
+  *present_fence = present_fence_.Release();
 
   ++frame_no_;
   return HWC2::Error::None;
@@ -798,22 +791,6 @@ HWC2::Error DrmHwcTwo::HwcDisplay::ValidateDisplay(uint32_t *num_types,
   *num_types = 0;
   *num_requests = 0;
   size_t avail_planes = primary_planes_.size() + overlay_planes_.size();
-  bool comp_failed = false;
-
-  HWC2::Error ret;
-
-  for (std::pair<const hwc2_layer_t, DrmHwcTwo::HwcLayer> &l : layers_)
-    l.second.set_validated_type(HWC2::Composition::Invalid);
-
-  ret = CreateComposition(true);
-  if (ret != HWC2::Error::None)
-    comp_failed = true;
-
-  std::map<uint32_t, DrmHwcTwo::HwcLayer *, std::greater<int>> z_map;
-  for (std::pair<const hwc2_layer_t, DrmHwcTwo::HwcLayer> &l : layers_) {
-    if (l.second.sf_type() == HWC2::Composition::Device)
-      z_map.emplace(std::make_pair(l.second.z_order(), &l.second));
-  }
 
   /*
    * If more layers then planes, save one plane
@@ -822,22 +799,29 @@ HWC2::Error DrmHwcTwo::HwcDisplay::ValidateDisplay(uint32_t *num_types,
   if (avail_planes < layers_.size())
     avail_planes--;
 
-  for (std::pair<const uint32_t, DrmHwcTwo::HwcLayer *> &l : z_map) {
-    if (comp_failed || !avail_planes--)
-      break;
-    if (importer_->CanImportBuffer(l.second->buffer()))
-      l.second->set_validated_type(HWC2::Composition::Device);
-  }
+  std::map<uint32_t, DrmHwcTwo::HwcLayer *, std::greater<int>> z_map;
+  for (std::pair<const hwc2_layer_t, DrmHwcTwo::HwcLayer> &l : layers_)
+    z_map.emplace(std::make_pair(l.second.z_order(), &l.second));
 
-  for (std::pair<const hwc2_layer_t, DrmHwcTwo::HwcLayer> &l : layers_) {
-    DrmHwcTwo::HwcLayer &layer = l.second;
-    // We can only handle layers of Device type, send everything else to SF
-    if (layer.sf_type() != HWC2::Composition::Device ||
-        layer.validated_type() != HWC2::Composition::Device) {
-      layer.set_validated_type(HWC2::Composition::Client);
+  bool gpu_block = false;
+  for (std::pair<const uint32_t, DrmHwcTwo::HwcLayer *> &l : z_map) {
+    if (gpu_block || avail_planes == 0 ||
+        !HardwareSupportsLayerType(l.second->sf_type()) ||
+        !importer_->CanImportBuffer(l.second->buffer())) {
+      gpu_block = true;
       ++*num_types;
+    } else {
+      avail_planes--;
     }
+
+    l.second->set_validated_type(gpu_block ? HWC2::Composition::Client
+                                           : HWC2::Composition::Device);
   }
+
+  if (CreateComposition(true) != HWC2::Error::None)
+    for (std::pair<const hwc2_layer_t, DrmHwcTwo::HwcLayer> &l : layers_)
+      l.second.set_validated_type(HWC2::Composition::Client);
+
   return *num_types ? HWC2::Error::HasChanges : HWC2::Error::None;
 }
 
diff --git a/include/drmconnector.h b/include/drmconnector.h
index 9c526c8..c9fd7ab 100644
--- a/include/drmconnector.h
+++ b/include/drmconnector.h
@@ -23,6 +23,7 @@
 
 #include <stdint.h>
 #include <xf86drmMode.h>
+#include <string>
 #include <vector>
 
 namespace android {
@@ -49,6 +50,8 @@ class DrmConnector {
   bool writeback() const;
   bool valid_type() const;
 
+  std::string name() const;
+
   int UpdateModes();
 
   const std::vector<DrmMode> &modes() const {
@@ -86,6 +89,7 @@ class DrmConnector {
   int display_;
 
   uint32_t type_;
+  uint32_t type_id_;
   drmModeConnection state_;
 
   uint32_t mm_width_;
diff --git a/include/drmdisplaycompositor.h b/include/drmdisplaycompositor.h
index 1005598..477f226 100644
--- a/include/drmdisplaycompositor.h
+++ b/include/drmdisplaycompositor.h
@@ -56,6 +56,11 @@ class DrmDisplayCompositor {
   void Dump(std::ostringstream *out) const;
   void Vsync(int display, int64_t timestamp);
   void ClearDisplay();
+  int TakeOutFence() {
+    if (!active_composition_)
+      return -1;
+    return active_composition_->take_out_fence();
+  }
 
   std::tuple<uint32_t, uint32_t, int> GetActiveModeResolution();
 
diff --git a/include/drmhwcomposer.h b/include/drmhwcomposer.h
index 2af7e6e..69313d9 100644
--- a/include/drmhwcomposer.h
+++ b/include/drmhwcomposer.h
@@ -158,10 +158,6 @@ struct DrmHwcLayer {
   }
 };
 
-struct DrmHwcDisplayContents {
-  OutputFd retire_fence;
-  std::vector<DrmHwcLayer> layers;
-};
 }  // namespace android
 
 #endif
diff --git a/include/drmhwctwo.h b/include/drmhwctwo.h
index 8c75fc0..c6ce640 100644
--- a/include/drmhwctwo.h
+++ b/include/drmhwctwo.h
@@ -172,7 +172,7 @@ class DrmHwcTwo : public hwc2_device_t {
                                    float *min_luminance);
     HWC2::Error GetReleaseFences(uint32_t *num_elements, hwc2_layer_t *layers,
                                  int32_t *fences);
-    HWC2::Error PresentDisplay(int32_t *retire_fence);
+    HWC2::Error PresentDisplay(int32_t *present_fence);
     HWC2::Error SetActiveConfig(hwc2_config_t config);
     HWC2::Error ChosePreferredConfig();
     HWC2::Error SetClientTarget(buffer_handle_t target, int32_t acquire_fence,
@@ -192,7 +192,8 @@ class DrmHwcTwo : public hwc2_device_t {
 
    private:
     HWC2::Error CreateComposition(bool test);
-    void AddFenceToRetireFence(int fd);
+    void AddFenceToPresentFence(int fd);
+    bool HardwareSupportsLayerType(HWC2::Composition comp_type);
 
     ResourceManager *resource_manager_;
     DrmDevice *drm_;
@@ -211,8 +212,7 @@ class DrmHwcTwo : public hwc2_device_t {
     uint32_t layer_idx_ = 0;
     std::map<hwc2_layer_t, HwcLayer> layers_;
     HwcLayer client_layer_;
-    UniqueFd retire_fence_;
-    UniqueFd next_retire_fence_;
+    UniqueFd present_fence_;
     int32_t color_mode_;
 
     uint32_t frame_no_ = 0;
diff --git a/platform/platformdrmgeneric.cpp b/platform/platformdrmgeneric.cpp
index 9ac601f..0883b90 100644
--- a/platform/platformdrmgeneric.cpp
+++ b/platform/platformdrmgeneric.cpp
@@ -20,7 +20,6 @@
 #include "drmdevice.h"
 #include "platform.h"
 
-#include <drm/drm_fourcc.h>
 #include <xf86drm.h>
 #include <xf86drmMode.h>
 
@@ -89,7 +88,7 @@ uint32_t DrmGenericImporter::ConvertHalFormatToDrm(uint32_t hal_format) {
       return DRM_FORMAT_YVU420;
     default:
       ALOGE("Cannot convert hal format to drm format %u", hal_format);
-      return -EINVAL;
+      return DRM_FORMAT_INVALID;
   }
 }
 
@@ -128,6 +127,8 @@ int DrmGenericImporter::ImportBuffer(buffer_handle_t handle, hwc_drm_bo_t *bo) {
   bo->height = gr_handle->height;
   bo->hal_format = gr_handle->format;
   bo->format = ConvertHalFormatToDrm(gr_handle->format);
+  if (bo->format == DRM_FORMAT_INVALID)
+    return -EINVAL;
   bo->usage = gr_handle->usage;
   bo->pixel_stride = (gr_handle->stride * 8) /
                      DrmFormatToBitsPerPixel(bo->format);
diff --git a/platform/platformdrmgeneric.h b/platform/platformdrmgeneric.h
index 88bff5f..7bb2ea2 100644
--- a/platform/platformdrmgeneric.h
+++ b/platform/platformdrmgeneric.h
@@ -22,6 +22,12 @@
 
 #include <hardware/gralloc.h>
 
+#include <drm/drm_fourcc.h>
+
+#ifndef DRM_FORMAT_INVALID
+#define DRM_FORMAT_INVALID 0
+#endif
+
 namespace android {
 
 class DrmGenericImporter : public Importer {
diff --git a/platform/platformhisi.cpp b/platform/platformhisi.cpp
index 64b410b..2e6ac43 100644
--- a/platform/platformhisi.cpp
+++ b/platform/platformhisi.cpp
@@ -20,7 +20,6 @@
 #include "drmdevice.h"
 #include "platform.h"
 
-#include <drm/drm_fourcc.h>
 #include <stdatomic.h>
 #include <xf86drm.h>
 #include <xf86drmMode.h>
@@ -121,9 +120,9 @@ int HisiImporter::ImportBuffer(buffer_handle_t handle, hwc_drm_bo_t *bo) {
     return ret;
   }
 
-  int32_t fmt = ConvertHalFormatToDrm(hnd->req_format);
-  if (fmt < 0)
-    return fmt;
+  uint32_t fmt = ConvertHalFormatToDrm(hnd->req_format);
+  if (fmt == DRM_FORMAT_INVALID)
+    return -EINVAL;
 
   is_rgb = IsDrmFormatRgb(fmt);
   modifiers[0] = ConvertGrallocFormatToDrmModifiers(hnd->internal_format,
diff --git a/platform/platformimagination.cpp b/platform/platformimagination.cpp
new file mode 100644
index 0000000..565e6ee
--- /dev/null
+++ b/platform/platformimagination.cpp
@@ -0,0 +1,80 @@
+#define LOG_TAG "hwc-platform-imagination"
+
+#include "platformimagination.h"
+#include <log/log.h>
+#include <xf86drm.h>
+
+#include "img_gralloc1_public.h"
+
+namespace android {
+
+Importer *Importer::CreateInstance(DrmDevice *drm) {
+  ImaginationImporter *importer = new ImaginationImporter(drm);
+  if (!importer)
+    return NULL;
+
+  int ret = importer->Init();
+  if (ret) {
+    ALOGE("Failed to initialize the Imagination importer %d", ret);
+    delete importer;
+    return NULL;
+  }
+  return importer;
+}
+
+int ImaginationImporter::ImportBuffer(buffer_handle_t handle,
+                                      hwc_drm_bo_t *bo) {
+  IMG_native_handle_t *hnd = (IMG_native_handle_t *)handle;
+  if (!hnd)
+    return -EINVAL;
+
+  uint32_t gem_handle;
+  int ret = drmPrimeFDToHandle(drm_->fd(), hnd->fd[0], &gem_handle);
+  if (ret) {
+    ALOGE("failed to import prime fd %d ret=%d", hnd->fd[0], ret);
+    return ret;
+  }
+
+  /* Extra bits are responsible for buffer compression and memory layout */
+  if (hnd->iFormat & ~0x10f) {
+    ALOGE("Special buffer formats are not supported");
+    return -EINVAL;
+  }
+
+  memset(bo, 0, sizeof(hwc_drm_bo_t));
+  bo->width = hnd->iWidth;
+  bo->height = hnd->iHeight;
+  bo->usage = hnd->usage;
+  bo->gem_handles[0] = gem_handle;
+  bo->pitches[0] = ALIGN(hnd->iWidth, HW_ALIGN) * hnd->uiBpp >> 3;
+
+  switch (hnd->iFormat) {
+#ifdef HAL_PIXEL_FORMAT_BGRX_8888
+    case HAL_PIXEL_FORMAT_BGRX_8888:
+      bo->format = DRM_FORMAT_XRGB8888;
+      break;
+#endif
+    default:
+      bo->format = ConvertHalFormatToDrm(hnd->iFormat & 0xf);
+      if (bo->format == DRM_FORMAT_INVALID) {
+        ALOGE("Cannot convert hal format to drm format %u", hnd->iFormat);
+        return -EINVAL;
+      }
+  }
+
+  ret = drmModeAddFB2(drm_->fd(), bo->width, bo->height, bo->format,
+                      bo->gem_handles, bo->pitches, bo->offsets, &bo->fb_id, 0);
+  if (ret) {
+    ALOGE("could not create drm fb ret: %d", ret);
+    return ret;
+  }
+
+  return 0;
+}
+
+std::unique_ptr<Planner> Planner::CreateInstance(DrmDevice *) {
+  std::unique_ptr<Planner> planner(new Planner);
+  planner->AddStage<PlanStageGreedy>();
+  return planner;
+}
+}  // namespace android
diff --git a/platform/platformimagination.h b/platform/platformimagination.h
new file mode 100644
index 0000000..85dfc45
--- /dev/null
+++ b/platform/platformimagination.h
@@ -0,0 +1,22 @@
+#ifndef PLATFORMIMAGINATION_H
+#define PLATFORMIMAGINATION_H
+
+#include "drmdevice.h"
+#include "platform.h"
+#include "platformdrmgeneric.h"
+
+#include <stdatomic.h>
+
+#include <hardware/gralloc.h>
+
+namespace android {
+
+class ImaginationImporter : public DrmGenericImporter {
+ public:
+  using DrmGenericImporter::DrmGenericImporter;
+
+  int ImportBuffer(buffer_handle_t handle, hwc_drm_bo_t *bo) override;
+};
+}  // namespace android
+
+#endif  // PLATFORMIMAGINATION_H
diff --git a/platform/platformmeson.cpp b/platform/platformmeson.cpp
index 7bde5cd..5184972 100644
--- a/platform/platformmeson.cpp
+++ b/platform/platformmeson.cpp
@@ -20,7 +20,6 @@
 #include "drmdevice.h"
 #include "platform.h"
 
-#include <drm/drm_fourcc.h>
 #include <stdatomic.h>
 #include <xf86drm.h>
 #include <xf86drmMode.h>
@@ -98,9 +97,9 @@ int MesonImporter::ImportBuffer(buffer_handle_t handle, hwc_drm_bo_t *bo) {
     return ret;
   }
 
-  int32_t fmt = ConvertHalFormatToDrm(hnd->req_format);
-  if (fmt < 0)
-    return fmt;
+  uint32_t fmt = ConvertHalFormatToDrm(hnd->req_format);
+  if (fmt == DRM_FORMAT_INVALID)
+    return -EINVAL;
 
   modifiers[0] = ConvertGrallocFormatToDrmModifiers(hnd->internal_format);
 
diff --git a/platform/platformminigbm.cpp b/platform/platformminigbm.cpp
index ad0a373..a65e196 100644
--- a/platform/platformminigbm.cpp
+++ b/platform/platformminigbm.cpp
@@ -20,7 +20,6 @@
 #include "drmdevice.h"
 #include "platform.h"
 
-#include <drm/drm_fourcc.h>
 #include <xf86drm.h>
 #include <xf86drmMode.h>