ui/ozone/platform/drm/gpu/hardware_display_plane_manager.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ui/ozone/platform/drm/gpu/hardware_display_plane_manager.h"
   6
   7 #include <drm.h>
   8 #include <xf86drm.h>
   9
  10 #include <set>
  11
  12 #include "base/logging.h"
  13 #include "ui/gfx/geometry/rect.h"
  14 #include "ui/ozone/platform/drm/gpu/crtc_controller.h"
  15 #include "ui/ozone/platform/drm/gpu/drm_device.h"
  16 #include "ui/ozone/platform/drm/gpu/hardware_display_controller.h"
  17 #include "ui/ozone/platform/drm/gpu/scanout_buffer.h"
  18 #include "ui/ozone/public/ozone_switches.h"
  19
  20 namespace ui {
  21 namespace {
  22
  23 const float kFixedPointScaleValue = 65536.0f;
  24
  25 }  // namespace
  26
  27 HardwareDisplayPlaneList::HardwareDisplayPlaneList() {
  28 #if defined(USE_DRM_ATOMIC)
  29   atomic_property_set.reset(drmModePropertySetAlloc());
  30 #endif  // defined(USE_DRM_ATOMIC)
  31 }
  32
  33 HardwareDisplayPlaneList::~HardwareDisplayPlaneList() {
  34   for (auto* plane : plane_list) {
  35     plane->set_in_use(false);
  36     plane->set_owning_crtc(0);
  37   }
  38   for (auto* plane : old_plane_list) {
  39     plane->set_in_use(false);
  40     plane->set_owning_crtc(0);
  41   }
  42 }
  43
  44 HardwareDisplayPlaneList::PageFlipInfo::PageFlipInfo(uint32_t crtc_id,
  45                                                      uint32_t framebuffer,
  46                                                      CrtcController* crtc)
  47     : crtc_id(crtc_id), framebuffer(framebuffer), crtc(crtc) {
  48 }
  49
  50 HardwareDisplayPlaneList::PageFlipInfo::~PageFlipInfo() {
  51 }
  52
  53 HardwareDisplayPlaneList::PageFlipInfo::Plane::Plane(int plane,
  54                                                      int framebuffer,
  55                                                      const gfx::Rect& bounds,
  56                                                      const gfx::Rect& src_rect)
  57     : plane(plane),
  58       framebuffer(framebuffer),
  59       bounds(bounds),
  60       src_rect(src_rect) {
  61 }
  62
  63 HardwareDisplayPlaneList::PageFlipInfo::Plane::~Plane() {
  64 }
  65
  66 HardwareDisplayPlaneManager::HardwareDisplayPlaneManager() : drm_(nullptr) {
  67 }
  68
  69 HardwareDisplayPlaneManager::~HardwareDisplayPlaneManager() {
  70 }
  71
  72 bool HardwareDisplayPlaneManager::Initialize(DrmDevice* drm) {
  73   drm_ = drm;
  74
  75   // Try to get all of the planes if possible, so we don't have to try to
  76   // discover hidden primary planes.
  77   bool has_universal_planes = false;
  78 #if defined(DRM_CLIENT_CAP_UNIVERSAL_PLANES)
  79   has_universal_planes = drm->SetCapability(DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1);
  80 #endif  // defined(DRM_CLIENT_CAP_UNIVERSAL_PLANES)
  81
  82   ScopedDrmResourcesPtr resources(drmModeGetResources(drm->get_fd()));
  83   if (!resources) {
  84     PLOG(ERROR) << "Failed to get resources";
  85     return false;
  86   }
  87
  88   ScopedDrmPlaneResPtr plane_resources(drmModeGetPlaneResources(drm->get_fd()));
  89   if (!plane_resources) {
  90     PLOG(ERROR) << "Failed to get plane resources";
  91     return false;
  92   }
  93
  94   crtcs_.clear();
  95   for (int i = 0; i < resources->count_crtcs; ++i) {
  96     crtcs_.push_back(resources->crtcs[i]);
  97   }
  98
  99   uint32_t num_planes = plane_resources->count_planes;
 100   std::set<uint32_t> plane_ids;
 101   for (uint32_t i = 0; i < num_planes; ++i) {
 102     ScopedDrmPlanePtr drm_plane(
 103         drmModeGetPlane(drm->get_fd(), plane_resources->planes[i]));
 104     if (!drm_plane) {
 105       PLOG(ERROR) << "Failed to get plane " << i;
 106       return false;
 107     }
 108     plane_ids.insert(drm_plane->plane_id);
 109     scoped_ptr<HardwareDisplayPlane> plane(
 110         CreatePlane(drm_plane->plane_id, drm_plane->possible_crtcs));
 111     if (plane->Initialize(drm))
 112       planes_.push_back(plane.Pass());
 113   }
 114
 115   // crbug.com/464085: if driver reports no primary planes for a crtc, create a
 116   // dummy plane for which we can assign exactly one overlay.
 117   // TODO(dnicoara): refactor this to simplify AssignOverlayPlanes and move
 118   // this workaround into HardwareDisplayPlaneLegacy.
 119   if (!has_universal_planes) {
 120     for (int i = 0; i < resources->count_crtcs; ++i) {
 121       if (plane_ids.find(resources->crtcs[i] - 1) == plane_ids.end()) {
 122         scoped_ptr<HardwareDisplayPlane> dummy_plane(
 123             CreatePlane(resources->crtcs[i] - 1, (1 << i)));
 124         dummy_plane->set_is_dummy(true);
 125         if (dummy_plane->Initialize(drm))
 126           planes_.push_back(dummy_plane.Pass());
 127       }
 128     }
 129   }
 130
 131   std::sort(planes_.begin(), planes_.end(),
 132             [](HardwareDisplayPlane* l, HardwareDisplayPlane* r) {
 133               return l->plane_id() < r->plane_id();
 134             });
 135   return true;
 136 }
 137
 138 scoped_ptr<HardwareDisplayPlane> HardwareDisplayPlaneManager::CreatePlane(
 139     uint32_t plane_id,
 140     uint32_t possible_crtcs) {
 141   return scoped_ptr<HardwareDisplayPlane>(
 142       new HardwareDisplayPlane(plane_id, possible_crtcs));
 143 }
 144
 145 HardwareDisplayPlane* HardwareDisplayPlaneManager::FindNextUnusedPlane(
 146     size_t* index,
 147     uint32_t crtc_index) {
 148   for (size_t i = *index; i < planes_.size(); ++i) {
 149     auto plane = planes_[i];
 150     if (!plane->in_use() && plane->CanUseForCrtc(crtc_index)) {
 151       *index = i + 1;
 152       return plane;
 153     }
 154   }
 155   return nullptr;
 156 }
 157
 158 int HardwareDisplayPlaneManager::LookupCrtcIndex(uint32_t crtc_id) {
 159   for (size_t i = 0; i < crtcs_.size(); ++i)
 160     if (crtcs_[i] == crtc_id)
 161       return i;
 162   return -1;
 163 }
 164
 165 void HardwareDisplayPlaneManager::BeginFrame(
 166     HardwareDisplayPlaneList* plane_list) {
 167   for (auto* plane : plane_list->old_plane_list) {
 168     plane->set_in_use(false);
 169   }
 170 }
 171
 172 bool HardwareDisplayPlaneManager::AssignOverlayPlanes(
 173     HardwareDisplayPlaneList* plane_list,
 174     const OverlayPlaneList& overlay_list,
 175     uint32_t crtc_id,
 176     CrtcController* crtc) {
 177   int crtc_index = LookupCrtcIndex(crtc_id);
 178   if (crtc_index < 0) {
 179     LOG(ERROR) << "Cannot find crtc " << crtc_id;
 180     return false;
 181   }
 182
 183   size_t plane_idx = 0;
 184   for (const auto& plane : overlay_list) {
 185     HardwareDisplayPlane* hw_plane =
 186         FindNextUnusedPlane(&plane_idx, crtc_index);
 187     if (!hw_plane) {
 188       LOG(ERROR) << "Failed to find a free plane for crtc " << crtc_id;
 189       return false;
 190     }
 191
 192     gfx::Rect fixed_point_rect;
 193     if (!hw_plane->is_dummy()) {
 194       const gfx::Size& size = plane.buffer->GetSize();
 195       gfx::RectF crop_rect = plane.crop_rect;
 196       crop_rect.Scale(size.width(), size.height());
 197
 198       // This returns a number in 16.16 fixed point, required by the DRM overlay
 199       // APIs.
 200       auto to_fixed_point =
 201           [](double v) -> uint32_t { return v * kFixedPointScaleValue; };
 202       fixed_point_rect = gfx::Rect(to_fixed_point(crop_rect.x()),
 203                                    to_fixed_point(crop_rect.y()),
 204                                    to_fixed_point(crop_rect.width()),
 205                                    to_fixed_point(crop_rect.height()));
 206     }
 207
 208     plane_list->plane_list.push_back(hw_plane);
 209     hw_plane->set_owning_crtc(crtc_id);
 210     if (SetPlaneData(plane_list, hw_plane, plane, crtc_id, fixed_point_rect,
 211                      crtc)) {
 212       hw_plane->set_in_use(true);
 213     } else {
 214       return false;
 215     }
 216   }
 217   return true;
 218 }
 219
 220 void HardwareDisplayPlaneManager::ResetPlanes(
 221     HardwareDisplayPlaneList* plane_list,
 222     uint32_t crtc_id) {
 223   std::vector<HardwareDisplayPlane*> planes;
 224   planes.swap(plane_list->old_plane_list);
 225   for (auto* plane : planes) {
 226     if (plane->owning_crtc() == crtc_id) {
 227       plane->set_owning_crtc(0);
 228       plane->set_in_use(false);
 229     } else {
 230       plane_list->old_plane_list.push_back(plane);
 231     }
 232   }
 233 }
 234
 235 }  // namespace ui