drmcomposition.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-composition"
  18
  19 #include "drmcomposition.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 <cutils/properties.h>
  28 #include <sw_sync.h>
  29 #include <sync/sync.h>
  30
  31 namespace android {
  32
  33 DrmComposition::DrmComposition(DrmResources *drm, Importer *importer)
  34     : drm_(drm), importer_(importer) {
  35   char use_overlay_planes_prop[PROPERTY_VALUE_MAX];
  36   property_get("hwc.drm.use_overlay_planes", use_overlay_planes_prop, "1");
  37   bool use_overlay_planes = atoi(use_overlay_planes_prop);
  38
  39   for (DrmResources::PlaneIter iter = drm_->begin_planes();
  40        iter != drm_->end_planes(); ++iter) {
  41     if ((*iter)->type() == DRM_PLANE_TYPE_PRIMARY)
  42       primary_planes_.push_back(*iter);
  43     else if (use_overlay_planes && (*iter)->type() == DRM_PLANE_TYPE_OVERLAY)
  44       overlay_planes_.push_back(*iter);
  45   }
  46 }
  47
  48 int DrmComposition::Init(uint64_t frame_no) {
  49   for (DrmResources::ConnectorIter iter = drm_->begin_connectors();
  50        iter != drm_->end_connectors(); ++iter) {
  51     int display = (*iter)->display();
  52     composition_map_[display].reset(new DrmDisplayComposition());
  53     if (!composition_map_[display]) {
  54       ALOGE("Failed to allocate new display composition\n");
  55       return -ENOMEM;
  56     }
  57
  58     // If the display hasn't been modeset yet, this will be NULL
  59     DrmCrtc *crtc = drm_->GetCrtcForDisplay(display);
  60
  61     int ret = composition_map_[display]->Init(drm_, crtc, importer_, frame_no);
  62     if (ret) {
  63       ALOGE("Failed to init display composition for %d", display);
  64       return ret;
  65     }
  66   }
  67   return 0;
  68 }
  69
  70 int DrmComposition::SetLayers(size_t num_displays,
  71                               DrmCompositionDisplayLayersMap *maps) {
  72   int ret = 0;
  73   for (size_t display_index = 0; display_index < num_displays;
  74        display_index++) {
  75     DrmCompositionDisplayLayersMap &map = maps[display_index];
  76     int display = map.display;
  77
  78     if (!drm_->GetConnectorForDisplay(display)) {
  79       ALOGE("Invalid display given to SetLayers %d", display);
  80       continue;
  81     }
  82
  83     ret = composition_map_[display]->SetLayers(map.layers.data(),
  84                                                map.layers.size());
  85     if (ret)
  86       return ret;
  87   }
  88
  89   return 0;
  90 }
  91
  92 int DrmComposition::SetDpmsMode(int display, uint32_t dpms_mode) {
  93   return composition_map_[display]->SetDpmsMode(dpms_mode);
  94 }
  95
  96 int DrmComposition::SetDisplayMode(int display, const DrmMode &display_mode) {
  97   return composition_map_[display]->SetDisplayMode(display_mode);
  98 }
  99
 100 std::unique_ptr<DrmDisplayComposition> DrmComposition::TakeDisplayComposition(
 101     int display) {
 102   return std::move(composition_map_[display]);
 103 }
 104
 105 int DrmComposition::Plan(std::map<int, DrmDisplayCompositor> &compositor_map) {
 106   int ret = 0;
 107   for (DrmResources::ConnectorIter iter = drm_->begin_connectors();
 108        iter != drm_->end_connectors(); ++iter) {
 109     int display = (*iter)->display();
 110     DrmDisplayComposition *comp = GetDisplayComposition(display);
 111     ret = comp->Plan(compositor_map[display].squash_state(), &primary_planes_,
 112                      &overlay_planes_);
 113     if (ret) {
 114       ALOGE("Failed to plan composition for dislay %d", display);
 115       return ret;
 116     }
 117   }
 118
 119   return 0;
 120 }
 121
 122 int DrmComposition::DisableUnusedPlanes() {
 123   for (DrmResources::ConnectorIter iter = drm_->begin_connectors();
 124        iter != drm_->end_connectors(); ++iter) {
 125     int display = (*iter)->display();
 126     DrmDisplayComposition *comp = GetDisplayComposition(display);
 127
 128     /*
 129      * Leave empty compositions alone
 130      * TODO: re-visit this and potentially disable leftover planes after the
 131      *       active compositions have gobbled up all they can
 132      */
 133     if (comp->type() == DRM_COMPOSITION_TYPE_EMPTY ||
 134         comp->type() == DRM_COMPOSITION_TYPE_MODESET)
 135       continue;
 136
 137     DrmCrtc *crtc = drm_->GetCrtcForDisplay(display);
 138     if (!crtc) {
 139       ALOGE("Failed to find crtc for display %d", display);
 140       continue;
 141     }
 142
 143     for (std::vector<DrmPlane *>::iterator iter = primary_planes_.begin();
 144          iter != primary_planes_.end(); ++iter) {
 145       if ((*iter)->GetCrtcSupported(*crtc)) {
 146         comp->AddPlaneDisable(*iter);
 147         primary_planes_.erase(iter);
 148         break;
 149       }
 150     }
 151     for (std::vector<DrmPlane *>::iterator iter = overlay_planes_.begin();
 152          iter != overlay_planes_.end();) {
 153       if ((*iter)->GetCrtcSupported(*crtc)) {
 154         comp->AddPlaneDisable(*iter);
 155         iter = overlay_planes_.erase(iter);
 156       } else {
 157         iter++;
 158       }
 159     }
 160   }
 161   return 0;
 162 }
 163
 164 DrmDisplayComposition *DrmComposition::GetDisplayComposition(int display) {
 165   return composition_map_[display].get();
 166 }
 167 }