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

   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 #ifndef UI_OZONE_PLATFORM_DRM_GPU_HARDWARE_DISPLAY_PLANE_MANAGER_H_
   6 #define UI_OZONE_PLATFORM_DRM_GPU_HARDWARE_DISPLAY_PLANE_MANAGER_H_
   7
   8 #include <stddef.h>
   9 #include <stdint.h>
  10 #include <xf86drmMode.h>
  11 #include <vector>
  12
  13 #include "base/basictypes.h"
  14 #include "base/memory/scoped_vector.h"
  15 #include "ui/ozone/ozone_export.h"
  16 #include "ui/ozone/platform/drm/gpu/hardware_display_plane.h"
  17 #include "ui/ozone/platform/drm/gpu/overlay_plane.h"
  18 #include "ui/ozone/platform/drm/gpu/scoped_drm_types.h"
  19
  20 namespace gfx {
  21 class Rect;
  22 }  // namespace gfx
  23
  24 namespace ui {
  25
  26 class CrtcController;
  27 class DrmDevice;
  28
  29 // This contains the list of planes controlled by one HDC on a given DRM fd.
  30 // It is owned by the HDC and filled by the CrtcController.
  31 struct OZONE_EXPORT HardwareDisplayPlaneList {
  32   HardwareDisplayPlaneList();
  33   ~HardwareDisplayPlaneList();
  34
  35   // This is the list of planes to be committed this time.
  36   std::vector<HardwareDisplayPlane*> plane_list;
  37   // This is the list of planes that was committed last time.
  38   std::vector<HardwareDisplayPlane*> old_plane_list;
  39
  40   struct PageFlipInfo {
  41     PageFlipInfo(uint32_t crtc_id, uint32_t framebuffer, CrtcController* crtc);
  42     ~PageFlipInfo();
  43
  44     uint32_t crtc_id;
  45     uint32_t framebuffer;
  46     CrtcController* crtc;
  47
  48     struct Plane {
  49       Plane(int plane,
  50             int framebuffer,
  51             const gfx::Rect& bounds,
  52             const gfx::Rect& src_rect);
  53       ~Plane();
  54       int plane;
  55       int framebuffer;
  56       gfx::Rect bounds;
  57       gfx::Rect src_rect;
  58     };
  59     std::vector<Plane> planes;
  60   };
  61   // In the case of non-atomic operation, this info will be used for
  62   // pageflipping.
  63   std::vector<PageFlipInfo> legacy_page_flips;
  64
  65 #if defined(USE_DRM_ATOMIC)
  66   ScopedDrmPropertySetPtr atomic_property_set;
  67 #endif  // defined(USE_DRM_ATOMIC)
  68
  69   // Set if the last operation on this list was a Commit().
  70   bool committed;
  71 };
  72
  73 class OZONE_EXPORT HardwareDisplayPlaneManager {
  74  public:
  75   HardwareDisplayPlaneManager();
  76   virtual ~HardwareDisplayPlaneManager();
  77
  78   // This parses information from the drm driver, adding any new planes
  79   // or crtcs found.
  80   bool Initialize(DrmDevice* drm);
  81
  82   // Assign hardware planes from the |planes_| list to |overlay_list| entries,
  83   // recording the plane IDs in the |plane_list|. Only planes compatible with
  84   // |crtc_id| will be used. |overlay_list| must be sorted bottom-to-top.
  85   virtual bool AssignOverlayPlanes(HardwareDisplayPlaneList* plane_list,
  86                                    const OverlayPlaneList& overlay_list,
  87                                    uint32_t crtc_id,
  88                                    CrtcController* crtc);
  89
  90   // Commit the plane states in |plane_list|.
  91   virtual bool Commit(HardwareDisplayPlaneList* plane_list, bool is_sync) = 0;
  92
  93   // Set all planes in |plane_list| owned by |crtc_id| to free.
  94   static void ResetPlanes(HardwareDisplayPlaneList* plane_list,
  95                           uint32_t crtc_id);
  96
  97   const ScopedVector<HardwareDisplayPlane>& planes() { return planes_; }
  98
  99  protected:
 100   virtual bool SetPlaneData(HardwareDisplayPlaneList* plane_list,
 101                             HardwareDisplayPlane* hw_plane,
 102                             const OverlayPlane& overlay,
 103                             uint32_t crtc_id,
 104                             const gfx::Rect& src_rect,
 105                             CrtcController* crtc) = 0;
 106
 107   virtual scoped_ptr<HardwareDisplayPlane> CreatePlane(uint32_t plane_id,
 108                                                        uint32_t possible_crtcs);
 109
 110   // Finds the plane located at or after |*index| that is not in use and can
 111   // be used with |crtc_index|.
 112   HardwareDisplayPlane* FindNextUnusedPlane(size_t* index, uint32_t crtc_index);
 113
 114   // Convert |crtc_id| into an index, returning -1 if the ID couldn't be found.
 115   int LookupCrtcIndex(uint32_t crtc_id);
 116
 117   // Object containing the connection to the graphics device and wraps the API
 118   // calls to control it. Not owned.
 119   DrmDevice* drm_;
 120
 121   ScopedVector<HardwareDisplayPlane> planes_;
 122   std::vector<uint32_t> crtcs_;
 123
 124   DISALLOW_COPY_AND_ASSIGN(HardwareDisplayPlaneManager);
 125 };
 126
 127 }  // namespace ui
 128
 129 #endif  // UI_OZONE_PLATFORM_DRM_GPU_HARDWARE_DISPLAY_PLANE_MANAGER_H_