• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 #include "platform.h"
24 
25 #include <stdlib.h>
26 
27 #include <cutils/log.h>
28 #include <cutils/properties.h>
29 #include <sw_sync.h>
30 #include <sync/sync.h>
31 
32 namespace android {
33 
DrmComposition(DrmResources * drm,Importer * importer,Planner * planner)34 DrmComposition::DrmComposition(DrmResources *drm, Importer *importer,
35                                Planner *planner)
36     : drm_(drm), importer_(importer), planner_(planner) {
37   char use_overlay_planes_prop[PROPERTY_VALUE_MAX];
38   property_get("hwc.drm.use_overlay_planes", use_overlay_planes_prop, "1");
39   bool use_overlay_planes = atoi(use_overlay_planes_prop);
40 
41   for (auto &plane : drm->planes()) {
42     if (plane->type() == DRM_PLANE_TYPE_PRIMARY)
43       primary_planes_.push_back(plane.get());
44     else if (use_overlay_planes && plane->type() == DRM_PLANE_TYPE_OVERLAY)
45       overlay_planes_.push_back(plane.get());
46   }
47 }
48 
Init(uint64_t frame_no)49 int DrmComposition::Init(uint64_t frame_no) {
50   for (auto &conn : drm_->connectors()) {
51     int display = conn->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_, planner_,
62                                               frame_no);
63     if (ret) {
64       ALOGE("Failed to init display composition for %d", display);
65       return ret;
66     }
67   }
68   return 0;
69 }
70 
SetLayers(size_t num_displays,DrmCompositionDisplayLayersMap * maps)71 int DrmComposition::SetLayers(size_t num_displays,
72                               DrmCompositionDisplayLayersMap *maps) {
73   int ret = 0;
74   for (size_t display_index = 0; display_index < num_displays;
75        display_index++) {
76     DrmCompositionDisplayLayersMap &map = maps[display_index];
77     int display = map.display;
78 
79     if (!drm_->GetConnectorForDisplay(display)) {
80       ALOGE("Invalid display given to SetLayers %d", display);
81       continue;
82     }
83 
84     ret = composition_map_[display]->SetLayers(
85         map.layers.data(), map.layers.size(), map.geometry_changed);
86     if (ret)
87       return ret;
88   }
89 
90   return 0;
91 }
92 
SetDpmsMode(int display,uint32_t dpms_mode)93 int DrmComposition::SetDpmsMode(int display, uint32_t dpms_mode) {
94   return composition_map_[display]->SetDpmsMode(dpms_mode);
95 }
96 
SetDisplayMode(int display,const DrmMode & display_mode)97 int DrmComposition::SetDisplayMode(int display, const DrmMode &display_mode) {
98   return composition_map_[display]->SetDisplayMode(display_mode);
99 }
100 
TakeDisplayComposition(int display)101 std::unique_ptr<DrmDisplayComposition> DrmComposition::TakeDisplayComposition(
102     int display) {
103   return std::move(composition_map_[display]);
104 }
105 
Plan(std::map<int,DrmDisplayCompositor> & compositor_map)106 int DrmComposition::Plan(std::map<int, DrmDisplayCompositor> &compositor_map) {
107   int ret = 0;
108   for (auto &conn : drm_->connectors()) {
109     int display = conn->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 
DisableUnusedPlanes()122 int DrmComposition::DisableUnusedPlanes() {
123   for (auto &conn : drm_->connectors()) {
124     int display = conn->display();
125     DrmDisplayComposition *comp = GetDisplayComposition(display);
126 
127     /*
128      * Leave empty compositions alone
129      * TODO: re-visit this and potentially disable leftover planes after the
130      *       active compositions have gobbled up all they can
131      */
132     if (comp->type() == DRM_COMPOSITION_TYPE_EMPTY ||
133         comp->type() == DRM_COMPOSITION_TYPE_MODESET)
134       continue;
135 
136     DrmCrtc *crtc = drm_->GetCrtcForDisplay(display);
137     if (!crtc) {
138       ALOGE("Failed to find crtc for display %d", display);
139       continue;
140     }
141 
142     for (std::vector<DrmPlane *>::iterator iter = primary_planes_.begin();
143          iter != primary_planes_.end(); ++iter) {
144       if ((*iter)->GetCrtcSupported(*crtc)) {
145         comp->AddPlaneDisable(*iter);
146         primary_planes_.erase(iter);
147         break;
148       }
149     }
150     for (std::vector<DrmPlane *>::iterator iter = overlay_planes_.begin();
151          iter != overlay_planes_.end();) {
152       if ((*iter)->GetCrtcSupported(*crtc)) {
153         comp->AddPlaneDisable(*iter);
154         iter = overlay_planes_.erase(iter);
155       } else {
156         iter++;
157       }
158     }
159   }
160   return 0;
161 }
162 
GetDisplayComposition(int display)163 DrmDisplayComposition *DrmComposition::GetDisplayComposition(int display) {
164   return composition_map_[display].get();
165 }
166 }
167