drmdisplaycomposition.cpp

   1 /*
   2  * Copyright (C) 2015 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 LOG_TAG "hwc-drm-display-composition"
  18
  19 #include "drmdisplaycomposition.h"
  20 #include "drmcrtc.h"
  21 #include "drmplane.h"
  22 #include "drmresources.h"
  23
  24 #include <stdlib.h>
  25
  26 #include <cutils/log.h>
  27 #include <sw_sync.h>
  28 #include <sync/sync.h>
  29 #include <xf86drmMode.h>
  30
  31 namespace android {
  32
  33 DrmCompositionLayer::DrmCompositionLayer() : crtc(NULL), plane(NULL) {
  34   memset(&layer, 0, sizeof(layer));
  35   layer.acquireFenceFd = -1;
  36   memset(&bo, 0, sizeof(bo));
  37 }
  38
  39 DrmCompositionLayer::~DrmCompositionLayer() {
  40 }
  41
  42 DrmDisplayComposition::DrmDisplayComposition()
  43     : drm_(NULL),
  44       importer_(NULL),
  45       type_(DRM_COMPOSITION_TYPE_EMPTY),
  46       timeline_fd_(-1),
  47       timeline_(0),
  48       timeline_current_(0),
  49       dpms_mode_(DRM_MODE_DPMS_ON) {
  50 }
  51
  52 DrmDisplayComposition::~DrmDisplayComposition() {
  53   for (DrmCompositionLayerVector_t::iterator iter = layers_.begin();
  54        iter != layers_.end(); ++iter) {
  55     if (importer_ && iter->bo.fb_id)
  56       importer_->ReleaseBuffer(&iter->bo);
  57
  58     if (iter->layer.acquireFenceFd >= 0)
  59       close(iter->layer.acquireFenceFd);
  60   }
  61
  62   if (timeline_fd_ >= 0) {
  63     FinishComposition();
  64     close(timeline_fd_);
  65     timeline_fd_ = -1;
  66   }
  67 }
  68
  69 int DrmDisplayComposition::Init(DrmResources *drm, Importer *importer) {
  70   drm_ = drm;
  71   importer_ = importer;
  72
  73   int ret = sw_sync_timeline_create();
  74   if (ret < 0) {
  75     ALOGE("Failed to create sw sync timeline %d", ret);
  76     return ret;
  77   }
  78   timeline_fd_ = ret;
  79   return 0;
  80 }
  81
  82 DrmCompositionType DrmDisplayComposition::type() const {
  83   return type_;
  84 }
  85
  86 bool DrmDisplayComposition::validate_composition_type(DrmCompositionType des) {
  87   return type_ == DRM_COMPOSITION_TYPE_EMPTY || type_ == des;
  88 }
  89
  90 int DrmDisplayComposition::AddLayer(hwc_layer_1_t *layer, hwc_drm_bo_t *bo,
  91                                     DrmCrtc *crtc, DrmPlane *plane) {
  92   if (!validate_composition_type(DRM_COMPOSITION_TYPE_FRAME))
  93     return -EINVAL;
  94
  95   ++timeline_;
  96   layer->releaseFenceFd =
  97       sw_sync_fence_create(timeline_fd_, "drm_fence", timeline_);
  98   if (layer->releaseFenceFd < 0) {
  99     ALOGE("Could not create release fence %d", layer->releaseFenceFd);
 100     return layer->releaseFenceFd;
 101   }
 102
 103   DrmCompositionLayer_t c_layer;
 104   c_layer.layer = *layer;
 105   c_layer.bo = *bo;
 106   c_layer.crtc = crtc;
 107   c_layer.plane = plane;
 108
 109   layer->acquireFenceFd = -1;  // We own this now
 110   layers_.push_back(c_layer);
 111   type_ = DRM_COMPOSITION_TYPE_FRAME;
 112   return 0;
 113 }
 114
 115 int DrmDisplayComposition::AddLayer(hwc_layer_1_t *layer, DrmCrtc *crtc,
 116                                     DrmPlane *plane) {
 117   if (layer->transform != 0)
 118     return -EINVAL;
 119
 120   if (!validate_composition_type(DRM_COMPOSITION_TYPE_FRAME))
 121     return -EINVAL;
 122
 123   hwc_drm_bo_t bo;
 124   int ret = importer_->ImportBuffer(layer->handle, &bo);
 125   if (ret) {
 126     ALOGE("Failed to import handle of layer %d", ret);
 127     return ret;
 128   }
 129
 130   ret = AddLayer(layer, &bo, crtc, plane);
 131   if (ret)
 132     importer_->ReleaseBuffer(&bo);
 133
 134   return ret;
 135 }
 136
 137 int DrmDisplayComposition::AddDpmsMode(uint32_t dpms_mode) {
 138   if (!validate_composition_type(DRM_COMPOSITION_TYPE_DPMS))
 139     return -EINVAL;
 140   dpms_mode_ = dpms_mode;
 141   type_ = DRM_COMPOSITION_TYPE_DPMS;
 142   return 0;
 143 }
 144
 145 int DrmDisplayComposition::AddPlaneDisable(DrmPlane *plane) {
 146   DrmCompositionLayer_t c_layer;
 147   c_layer.crtc = NULL;
 148   c_layer.plane = plane;
 149   layers_.push_back(c_layer);
 150   return 0;
 151 }
 152
 153 int DrmDisplayComposition::FinishComposition() {
 154   int timeline_increase = timeline_ - timeline_current_;
 155   if (timeline_increase <= 0)
 156     return 0;
 157
 158   int ret = sw_sync_timeline_inc(timeline_fd_, timeline_increase);
 159   if (ret)
 160     ALOGE("Failed to increment sync timeline %d", ret);
 161   else
 162     timeline_current_ = timeline_;
 163
 164   return ret;
 165 }
 166
 167 DrmCompositionLayerVector_t *DrmDisplayComposition::GetCompositionLayers() {
 168   return &layers_;
 169 }
 170
 171 uint32_t DrmDisplayComposition::dpms_mode() const {
 172   return dpms_mode_;
 173 }
 174 }