DrmHwcTwo.h

   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 #ifndef ANDROID_DRM_HWC_TWO_H_
  18 #define ANDROID_DRM_HWC_TWO_H_
  19
  20 #include <hardware/hwcomposer2.h>
  21 #include <math.h>
  22
  23 #include <array>
  24 #include <map>
  25
  26 #include "compositor/DrmDisplayCompositor.h"
  27 #include "compositor/Planner.h"
  28 #include "drm/DrmGenericImporter.h"
  29 #include "drm/ResourceManager.h"
  30 #include "drm/VSyncWorker.h"
  31 #include "drmhwcomposer.h"
  32
  33 namespace android {
  34
  35 class Backend;
  36
  37 class DrmHwcTwo : public hwc2_device_t {
  38  public:
  39   static int HookDevOpen(const struct hw_module_t *module, const char *name,
  40                          struct hw_device_t **dev);
  41
  42   DrmHwcTwo();
  43
  44   HWC2::Error Init();
  45
  46   hwc2_callback_data_t hotplug_callback_data_ = NULL;
  47   HWC2_PFN_HOTPLUG hotplug_callback_hook_ = NULL;
  48   std::mutex hotplug_callback_lock;
  49
  50   void SetHotplugCallback(hwc2_callback_data_t data,
  51                           hwc2_function_pointer_t hook) {
  52     const std::lock_guard<std::mutex> lock(hotplug_callback_lock);
  53     hotplug_callback_data_ = data;
  54     hotplug_callback_hook_ = reinterpret_cast<HWC2_PFN_HOTPLUG>(hook);
  55   }
  56
  57   class HwcLayer {
  58    public:
  59     HWC2::Composition sf_type() const {
  60       return sf_type_;
  61     }
  62     HWC2::Composition validated_type() const {
  63       return validated_type_;
  64     }
  65     void accept_type_change() {
  66       sf_type_ = validated_type_;
  67     }
  68     void set_validated_type(HWC2::Composition type) {
  69       validated_type_ = type;
  70     }
  71     bool type_changed() const {
  72       return sf_type_ != validated_type_;
  73     }
  74
  75     uint32_t z_order() const {
  76       return z_order_;
  77     }
  78
  79     buffer_handle_t buffer() {
  80       return buffer_;
  81     }
  82     void set_buffer(buffer_handle_t buffer) {
  83       buffer_ = buffer;
  84     }
  85
  86     int take_acquire_fence() {
  87       return acquire_fence_.Release();
  88     }
  89     void set_acquire_fence(int acquire_fence) {
  90       acquire_fence_.Set(dup(acquire_fence));
  91     }
  92
  93     int release_fence() {
  94       return release_fence_.get();
  95     }
  96     int take_release_fence() {
  97       return release_fence_.Release();
  98     }
  99     void manage_release_fence() {
 100       release_fence_.Set(release_fence_raw_);
 101       release_fence_raw_ = -1;
 102     }
 103     OutputFd release_fence_output() {
 104       return OutputFd(&release_fence_raw_);
 105     }
 106
 107     hwc_rect_t display_frame() {
 108       return display_frame_;
 109     }
 110
 111     void PopulateDrmLayer(DrmHwcLayer *layer);
 112
 113     bool RequireScalingOrPhasing() {
 114       float src_width = source_crop_.right - source_crop_.left;
 115       float src_height = source_crop_.bottom - source_crop_.top;
 116
 117       float dest_width = display_frame_.right - display_frame_.left;
 118       float dest_height = display_frame_.bottom - display_frame_.top;
 119
 120       bool scaling = src_width != dest_width || src_height != dest_height;
 121       bool phasing = (source_crop_.left - floor(source_crop_.left) != 0) ||
 122                      (source_crop_.top - floor(source_crop_.top) != 0);
 123       return scaling || phasing;
 124     }
 125
 126     // Layer hooks
 127     HWC2::Error SetCursorPosition(int32_t x, int32_t y);
 128     HWC2::Error SetLayerBlendMode(int32_t mode);
 129     HWC2::Error SetLayerBuffer(buffer_handle_t buffer, int32_t acquire_fence);
 130     HWC2::Error SetLayerColor(hwc_color_t color);
 131     HWC2::Error SetLayerCompositionType(int32_t type);
 132     HWC2::Error SetLayerDataspace(int32_t dataspace);
 133     HWC2::Error SetLayerDisplayFrame(hwc_rect_t frame);
 134     HWC2::Error SetLayerPlaneAlpha(float alpha);
 135     HWC2::Error SetLayerSidebandStream(const native_handle_t *stream);
 136     HWC2::Error SetLayerSourceCrop(hwc_frect_t crop);
 137     HWC2::Error SetLayerSurfaceDamage(hwc_region_t damage);
 138     HWC2::Error SetLayerTransform(int32_t transform);
 139     HWC2::Error SetLayerVisibleRegion(hwc_region_t visible);
 140     HWC2::Error SetLayerZOrder(uint32_t z);
 141
 142    private:
 143     // sf_type_ stores the initial type given to us by surfaceflinger,
 144     // validated_type_ stores the type after running ValidateDisplay
 145     HWC2::Composition sf_type_ = HWC2::Composition::Invalid;
 146     HWC2::Composition validated_type_ = HWC2::Composition::Invalid;
 147
 148     HWC2::BlendMode blending_ = HWC2::BlendMode::None;
 149     buffer_handle_t buffer_ = NULL;
 150     UniqueFd acquire_fence_;
 151     int release_fence_raw_ = -1;
 152     UniqueFd release_fence_;
 153     hwc_rect_t display_frame_;
 154     float alpha_ = 1.0f;
 155     hwc_frect_t source_crop_;
 156     int32_t cursor_x_;
 157     int32_t cursor_y_;
 158     hwc_color_t layer_color_;
 159     HWC2::Transform transform_ = HWC2::Transform::None;
 160     uint32_t z_order_ = 0;
 161     android_dataspace_t dataspace_ = HAL_DATASPACE_UNKNOWN;
 162   };
 163
 164   class HwcDisplay {
 165    public:
 166     HwcDisplay(ResourceManager *resource_manager, DrmDevice *drm,
 167                std::shared_ptr<Importer> importer, hwc2_display_t handle,
 168                HWC2::DisplayType type);
 169     HwcDisplay(const HwcDisplay &) = delete;
 170     HWC2::Error Init(std::vector<DrmPlane *> *planes);
 171
 172     void RegisterVsyncCallback(hwc2_callback_data_t data,
 173                                hwc2_function_pointer_t func);
 174     void RegisterRefreshCallback(hwc2_callback_data_t data,
 175                                  hwc2_function_pointer_t func);
 176     HWC2::Error CreateComposition(bool test);
 177     bool HardwareSupportsLayerType(HWC2::Composition comp_type);
 178     uint32_t CalcPixOps(std::map<uint32_t, DrmHwcTwo::HwcLayer *> &z_map,
 179                         size_t first_z, size_t size);
 180     void MarkValidated(std::map<uint32_t, DrmHwcTwo::HwcLayer *> &z_map,
 181                        size_t client_first_z, size_t client_size);
 182
 183     void ClearDisplay();
 184
 185     std::string Dump();
 186
 187     // HWC Hooks
 188     HWC2::Error AcceptDisplayChanges();
 189     HWC2::Error CreateLayer(hwc2_layer_t *layer);
 190     HWC2::Error DestroyLayer(hwc2_layer_t layer);
 191     HWC2::Error GetActiveConfig(hwc2_config_t *config);
 192     HWC2::Error GetChangedCompositionTypes(uint32_t *num_elements,
 193                                            hwc2_layer_t *layers,
 194                                            int32_t *types);
 195     HWC2::Error GetClientTargetSupport(uint32_t width, uint32_t height,
 196                                        int32_t format, int32_t dataspace);
 197     HWC2::Error GetColorModes(uint32_t *num_modes, int32_t *modes);
 198     HWC2::Error GetDisplayAttribute(hwc2_config_t config, int32_t attribute,
 199                                     int32_t *value);
 200     HWC2::Error GetDisplayConfigs(uint32_t *num_configs,
 201                                   hwc2_config_t *configs);
 202     HWC2::Error GetDisplayName(uint32_t *size, char *name);
 203     HWC2::Error GetDisplayRequests(int32_t *display_requests,
 204                                    uint32_t *num_elements, hwc2_layer_t *layers,
 205                                    int32_t *layer_requests);
 206     HWC2::Error GetDisplayType(int32_t *type);
 207 #if PLATFORM_SDK_VERSION > 27
 208     HWC2::Error GetRenderIntents(int32_t mode, uint32_t *outNumIntents,
 209                                  int32_t *outIntents);
 210     HWC2::Error SetColorModeWithIntent(int32_t mode, int32_t intent);
 211 #endif
 212 #if PLATFORM_SDK_VERSION > 28
 213     HWC2::Error GetDisplayIdentificationData(uint8_t *outPort,
 214                                              uint32_t *outDataSize,
 215                                              uint8_t *outData);
 216     HWC2::Error GetDisplayCapabilities(uint32_t *outNumCapabilities,
 217                                        uint32_t *outCapabilities);
 218     HWC2::Error GetDisplayBrightnessSupport(bool *supported);
 219     HWC2::Error SetDisplayBrightness(float);
 220 #endif
 221     HWC2::Error GetDozeSupport(int32_t *support);
 222     HWC2::Error GetHdrCapabilities(uint32_t *num_types, int32_t *types,
 223                                    float *max_luminance,
 224                                    float *max_average_luminance,
 225                                    float *min_luminance);
 226     HWC2::Error GetReleaseFences(uint32_t *num_elements, hwc2_layer_t *layers,
 227                                  int32_t *fences);
 228     HWC2::Error PresentDisplay(int32_t *present_fence);
 229     HWC2::Error SetActiveConfig(hwc2_config_t config);
 230     HWC2::Error ChosePreferredConfig();
 231     HWC2::Error SetClientTarget(buffer_handle_t target, int32_t acquire_fence,
 232                                 int32_t dataspace, hwc_region_t damage);
 233     HWC2::Error SetColorMode(int32_t mode);
 234     HWC2::Error SetColorTransform(const float *matrix, int32_t hint);
 235     HWC2::Error SetOutputBuffer(buffer_handle_t buffer, int32_t release_fence);
 236     HWC2::Error SetPowerMode(int32_t mode);
 237     HWC2::Error SetVsyncEnabled(int32_t enabled);
 238     HWC2::Error ValidateDisplay(uint32_t *num_types, uint32_t *num_requests);
 239     HwcLayer *get_layer(hwc2_layer_t layer) {
 240       auto it = layers_.find(layer);
 241       if (it == layers_.end())
 242         return nullptr;
 243       return &it->second;
 244     }
 245
 246     /* Statistics */
 247     struct Stats {
 248       Stats minus(Stats b) {
 249         return {total_frames_ - b.total_frames_,
 250                 total_pixops_ - b.total_pixops_,
 251                 gpu_pixops_ - b.gpu_pixops_,
 252                 failed_kms_validate_ - b.failed_kms_validate_,
 253                 failed_kms_present_ - b.failed_kms_present_,
 254                 frames_flattened_ - b.frames_flattened_};
 255       }
 256
 257       uint32_t total_frames_ = 0;
 258       uint64_t total_pixops_ = 0;
 259       uint64_t gpu_pixops_ = 0;
 260       uint32_t failed_kms_validate_ = 0;
 261       uint32_t failed_kms_present_ = 0;
 262       uint32_t frames_flattened_ = 0;
 263     };
 264
 265     const Backend *backend() const {
 266       return backend_.get();
 267     }
 268     void set_backend(std::unique_ptr<Backend> backend) {
 269       backend_ = std::move(backend);
 270     }
 271
 272     const std::vector<DrmPlane *> &primary_planes() const {
 273       return primary_planes_;
 274     }
 275
 276     const std::vector<DrmPlane *> &overlay_planes() const {
 277       return overlay_planes_;
 278     }
 279
 280     std::map<hwc2_layer_t, HwcLayer> &layers() {
 281       return layers_;
 282     }
 283
 284     const DrmDisplayCompositor &compositor() const {
 285       return compositor_;
 286     }
 287
 288     const DrmDevice *drm() const {
 289       return drm_;
 290     }
 291
 292     const DrmConnector *connector() const {
 293       return connector_;
 294     }
 295
 296     const std::shared_ptr<Importer> &importer() const {
 297       return importer_;
 298     }
 299
 300     ResourceManager *resource_manager() const {
 301       return resource_manager_;
 302     }
 303
 304     android_color_transform_t &color_transform_hint() {
 305       return color_transform_hint_;
 306     }
 307
 308     Stats &total_stats() {
 309       return total_stats_;
 310     }
 311
 312    private:
 313     void AddFenceToPresentFence(int fd);
 314
 315     constexpr static size_t MATRIX_SIZE = 16;
 316
 317     ResourceManager *resource_manager_;
 318     DrmDevice *drm_;
 319     DrmDisplayCompositor compositor_;
 320     std::shared_ptr<Importer> importer_;
 321     std::unique_ptr<Planner> planner_;
 322
 323     std::vector<DrmPlane *> primary_planes_;
 324     std::vector<DrmPlane *> overlay_planes_;
 325
 326     std::unique_ptr<Backend> backend_;
 327
 328     VSyncWorker vsync_worker_;
 329     DrmConnector *connector_ = NULL;
 330     DrmCrtc *crtc_ = NULL;
 331     hwc2_display_t handle_;
 332     HWC2::DisplayType type_;
 333     uint32_t layer_idx_ = 0;
 334     std::map<hwc2_layer_t, HwcLayer> layers_;
 335     HwcLayer client_layer_;
 336     UniqueFd present_fence_;
 337     int32_t color_mode_;
 338     std::array<float, MATRIX_SIZE> color_transform_matrix_;
 339     android_color_transform_t color_transform_hint_;
 340
 341     uint32_t frame_no_ = 0;
 342     Stats total_stats_;
 343     Stats prev_stats_;
 344     std::string DumpDelta(DrmHwcTwo::HwcDisplay::Stats delta);
 345   };
 346
 347   class DrmHotplugHandler : public DrmEventHandler {
 348    public:
 349     DrmHotplugHandler(DrmHwcTwo *hwc2, DrmDevice *drm)
 350         : hwc2_(hwc2), drm_(drm) {
 351     }
 352     void HandleEvent(uint64_t timestamp_us);
 353
 354    private:
 355     DrmHwcTwo *hwc2_;
 356     DrmDevice *drm_;
 357   };
 358
 359  private:
 360   static DrmHwcTwo *toDrmHwcTwo(hwc2_device_t *dev) {
 361     return static_cast<DrmHwcTwo *>(dev);
 362   }
 363
 364   template <typename PFN, typename T>
 365   static hwc2_function_pointer_t ToHook(T function) {
 366     static_assert(std::is_same<PFN, T>::value, "Incompatible fn pointer");
 367     return reinterpret_cast<hwc2_function_pointer_t>(function);
 368   }
 369
 370   template <typename T, typename HookType, HookType func, typename... Args>
 371   static T DeviceHook(hwc2_device_t *dev, Args... args) {
 372     DrmHwcTwo *hwc = toDrmHwcTwo(dev);
 373     return static_cast<T>(((*hwc).*func)(std::forward<Args>(args)...));
 374   }
 375
 376   static HwcDisplay *GetDisplay(DrmHwcTwo *hwc, hwc2_display_t display_handle) {
 377     auto it = hwc->displays_.find(display_handle);
 378     if (it == hwc->displays_.end())
 379       return nullptr;
 380
 381     return &it->second;
 382   }
 383
 384   template <typename HookType, HookType func, typename... Args>
 385   static int32_t DisplayHook(hwc2_device_t *dev, hwc2_display_t display_handle,
 386                              Args... args) {
 387     HwcDisplay *display = GetDisplay(toDrmHwcTwo(dev), display_handle);
 388     if (!display)
 389       return static_cast<int32_t>(HWC2::Error::BadDisplay);
 390
 391     return static_cast<int32_t>((display->*func)(std::forward<Args>(args)...));
 392   }
 393
 394   template <typename HookType, HookType func, typename... Args>
 395   static int32_t LayerHook(hwc2_device_t *dev, hwc2_display_t display_handle,
 396                            hwc2_layer_t layer_handle, Args... args) {
 397     HwcDisplay *display = GetDisplay(toDrmHwcTwo(dev), display_handle);
 398     if (!display)
 399       return static_cast<int32_t>(HWC2::Error::BadDisplay);
 400
 401     HwcLayer *layer = display->get_layer(layer_handle);
 402     if (!layer)
 403       return static_cast<int32_t>(HWC2::Error::BadLayer);
 404
 405     return static_cast<int32_t>((layer->*func)(std::forward<Args>(args)...));
 406   }
 407
 408   // hwc2_device_t hooks
 409   static int HookDevClose(hw_device_t *dev);
 410   static void HookDevGetCapabilities(hwc2_device_t *dev, uint32_t *out_count,
 411                                      int32_t *out_capabilities);
 412   static hwc2_function_pointer_t HookDevGetFunction(struct hwc2_device *device,
 413                                                     int32_t descriptor);
 414
 415   // Device functions
 416   HWC2::Error CreateVirtualDisplay(uint32_t width, uint32_t height,
 417                                    int32_t *format, hwc2_display_t *display);
 418   HWC2::Error DestroyVirtualDisplay(hwc2_display_t display);
 419   void Dump(uint32_t *outSize, char *outBuffer);
 420   uint32_t GetMaxVirtualDisplayCount();
 421   HWC2::Error RegisterCallback(int32_t descriptor, hwc2_callback_data_t data,
 422                                hwc2_function_pointer_t function);
 423   HWC2::Error CreateDisplay(hwc2_display_t displ, HWC2::DisplayType type);
 424   void HandleDisplayHotplug(hwc2_display_t displayid, int state);
 425   void HandleInitialHotplugState(DrmDevice *drmDevice);
 426
 427   ResourceManager resource_manager_;
 428   std::map<hwc2_display_t, HwcDisplay> displays_;
 429
 430   std::string mDumpString;
 431 };
 432 }  // namespace android
 433
 434 #endif