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-platform-hisi"
18
19 #include "platformhisi.h"
20 #include "drmdevice.h"
21 #include "platform.h"
22
23 #include <stdatomic.h>
24 #include <xf86drm.h>
25 #include <xf86drmMode.h>
26 #include <cinttypes>
27
28 #include <hardware/gralloc.h>
29 #include <log/log.h>
30 #include "gralloc_priv.h"
31
32 #define MALI_ALIGN(value, base) (((value) + ((base)-1)) & ~((base)-1))
33
34 namespace android {
35
CreateInstance(DrmDevice * drm)36 Importer *Importer::CreateInstance(DrmDevice *drm) {
37 HisiImporter *importer = new HisiImporter(drm);
38 if (!importer)
39 return NULL;
40
41 int ret = importer->Init();
42 if (ret) {
43 ALOGE("Failed to initialize the hisi importer %d", ret);
44 delete importer;
45 return NULL;
46 }
47 return importer;
48 }
49
50 #if defined(MALI_GRALLOC_INTFMT_AFBC_BASIC) && \
51 defined(AFBC_FORMAT_MOD_BLOCK_SIZE_16x16)
ConvertGrallocFormatToDrmModifiers(uint64_t flags,bool is_rgb)52 uint64_t HisiImporter::ConvertGrallocFormatToDrmModifiers(uint64_t flags,
53 bool is_rgb) {
54 uint64_t features = 0UL;
55
56 if (flags & MALI_GRALLOC_INTFMT_AFBC_BASIC)
57 features |= AFBC_FORMAT_MOD_BLOCK_SIZE_16x16;
58
59 if (flags & MALI_GRALLOC_INTFMT_AFBC_SPLITBLK)
60 features |= (AFBC_FORMAT_MOD_SPLIT | AFBC_FORMAT_MOD_SPARSE);
61
62 if (flags & MALI_GRALLOC_INTFMT_AFBC_WIDEBLK)
63 features |= AFBC_FORMAT_MOD_BLOCK_SIZE_32x8;
64
65 if (flags & MALI_GRALLOC_INTFMT_AFBC_TILED_HEADERS)
66 features |= AFBC_FORMAT_MOD_TILED;
67
68 if (features) {
69 if (is_rgb)
70 features |= AFBC_FORMAT_MOD_YTR;
71
72 return DRM_FORMAT_MOD_ARM_AFBC(features);
73 }
74
75 return 0;
76 }
77 #else
ConvertGrallocFormatToDrmModifiers(uint64_t,bool)78 uint64_t HisiImporter::ConvertGrallocFormatToDrmModifiers(uint64_t /* flags */,
79 bool /* is_rgb */) {
80 return 0;
81 }
82 #endif
83
IsDrmFormatRgb(uint32_t drm_format)84 bool HisiImporter::IsDrmFormatRgb(uint32_t drm_format) {
85 switch (drm_format) {
86 case DRM_FORMAT_ARGB8888:
87 case DRM_FORMAT_XBGR8888:
88 case DRM_FORMAT_ABGR8888:
89 case DRM_FORMAT_BGR888:
90 case DRM_FORMAT_BGR565:
91 return true;
92 case DRM_FORMAT_YVU420:
93 return false;
94 default:
95 ALOGV("Unsupported format %u assuming rgb?", drm_format);
96 return true;
97 }
98 }
99
ConvertBoInfo(buffer_handle_t handle,hwc_drm_bo_t * bo)100 int HisiImporter::ConvertBoInfo(buffer_handle_t handle, hwc_drm_bo_t *bo) {
101 bool is_rgb;
102
103 private_handle_t const *hnd = reinterpret_cast<private_handle_t const *>(
104 handle);
105 if (!hnd)
106 return -EINVAL;
107
108 if (!(hnd->usage & GRALLOC_USAGE_HW_FB))
109 return -EINVAL;
110
111 uint32_t fmt = ConvertHalFormatToDrm(hnd->req_format);
112 if (fmt == DRM_FORMAT_INVALID)
113 return -EINVAL;
114
115 is_rgb = HisiImporter::IsDrmFormatRgb(fmt);
116 bo->modifiers[0] = HisiImporter::
117 ConvertGrallocFormatToDrmModifiers(hnd->internal_format, is_rgb);
118
119 bo->width = hnd->width;
120 bo->height = hnd->height;
121 bo->hal_format = hnd->req_format;
122 bo->format = fmt;
123 bo->usage = hnd->usage;
124 bo->pixel_stride = hnd->stride;
125 bo->pitches[0] = hnd->byte_stride;
126 bo->prime_fds[0] = hnd->share_fd;
127 bo->offsets[0] = 0;
128
129 switch (fmt) {
130 case DRM_FORMAT_YVU420: {
131 int align = 128;
132 if (hnd->usage &
133 (GRALLOC_USAGE_SW_READ_MASK | GRALLOC_USAGE_SW_WRITE_MASK))
134 align = 16;
135 int adjusted_height = MALI_ALIGN(hnd->height, 2);
136 int y_size = adjusted_height * hnd->byte_stride;
137 int vu_stride = MALI_ALIGN(hnd->byte_stride / 2, align);
138 int v_size = vu_stride * (adjusted_height / 2);
139
140 /* V plane*/
141 bo->prime_fds[1] = hnd->share_fd;
142 bo->pitches[1] = vu_stride;
143 bo->offsets[1] = y_size;
144 /* U plane */
145 bo->prime_fds[2] = hnd->share_fd;
146 bo->pitches[2] = vu_stride;
147 bo->offsets[2] = y_size + v_size;
148 break;
149 }
150 default:
151 break;
152 }
153
154 bo->with_modifiers = true;
155
156 return 0;
157 }
158
159 class PlanStageHiSi : public Planner::PlanStage {
160 public:
ProvisionPlanes(std::vector<DrmCompositionPlane> * composition,std::map<size_t,DrmHwcLayer * > & layers,DrmCrtc * crtc,std::vector<DrmPlane * > * planes)161 int ProvisionPlanes(std::vector<DrmCompositionPlane> *composition,
162 std::map<size_t, DrmHwcLayer *> &layers, DrmCrtc *crtc,
163 std::vector<DrmPlane *> *planes) {
164 int layers_added = 0;
165 // Fill up as many DRM planes as we can with buffers that have HW_FB usage.
166 // Buffers without HW_FB should have been filtered out with
167 // CanImportBuffer(), if we meet one here, just skip it.
168 for (auto i = layers.begin(); i != layers.end(); i = layers.erase(i)) {
169 if (!(i->second->gralloc_buffer_usage & GRALLOC_USAGE_HW_FB))
170 continue;
171
172 int ret = Emplace(composition, planes, DrmCompositionPlane::Type::kLayer,
173 crtc, std::make_pair(i->first, i->second));
174 layers_added++;
175 // We don't have any planes left
176 if (ret == -ENOENT)
177 break;
178 else if (ret) {
179 ALOGE("Failed to emplace layer %zu, dropping it", i->first);
180 return ret;
181 }
182 }
183 // If we didn't emplace anything, return an error to ensure we force client
184 // compositing.
185 if (!layers_added)
186 return -EINVAL;
187
188 return 0;
189 }
190 };
191
CreateInstance(DrmDevice *)192 std::unique_ptr<Planner> Planner::CreateInstance(DrmDevice *) {
193 std::unique_ptr<Planner> planner(new Planner);
194 planner->AddStage<PlanStageHiSi>();
195 return planner;
196 }
197 } // namespace android
198