1 /*
2 * Copyright (c) 2012-2017, The Linux Foundation. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are
6 * met:
7 * * Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * * Redistributions in binary form must reproduce the above
10 * copyright notice, this list of conditions and the following
11 * disclaimer in the documentation and/or other materials provided
12 * with the distribution.
13 * * Neither the name of The Linux Foundation nor the names of its
14 * contributors may be used to endorse or promote products derived
15 * from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
18 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
19 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
21 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
22 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
23 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
24 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
25 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
26 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
27 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30 #include <errno.h>
31 #include <string.h>
32 #include <sys/mman.h>
33 #include <cutils/log.h>
34 #include <cinttypes>
35 #include <gralloc_priv.h>
36 #include "qdMetaData.h"
37
getMetaDataSize()38 unsigned long getMetaDataSize() {
39 return static_cast<unsigned long>(ROUND_UP_PAGESIZE(sizeof(MetaData_t)));
40 }
41
validateAndMap(private_handle_t * handle)42 static int validateAndMap(private_handle_t* handle) {
43 if (private_handle_t::validate(handle)) {
44 ALOGE("%s: Private handle is invalid - handle:%p", __func__, handle);
45 return -1;
46 }
47 if (handle->fd_metadata == -1) {
48 ALOGE("%s: Invalid metadata fd - handle:%p fd: %d",
49 __func__, handle, handle->fd_metadata);
50 return -1;
51 }
52
53 if (!handle->base_metadata) {
54 auto size = getMetaDataSize();
55 void *base = mmap(NULL, size, PROT_READ|PROT_WRITE, MAP_SHARED,
56 handle->fd_metadata, 0);
57 if (base == reinterpret_cast<void*>(MAP_FAILED)) {
58 ALOGE("%s: metadata mmap failed - handle:%p fd: %d err: %s",
59 __func__, handle, handle->fd_metadata, strerror(errno));
60
61 return -1;
62 }
63 handle->base_metadata = (uintptr_t) base;
64 }
65 return 0;
66 }
67
setMetaData(private_handle_t * handle,DispParamType paramType,void * param)68 int setMetaData(private_handle_t *handle, DispParamType paramType,
69 void *param) {
70 auto err = validateAndMap(handle);
71 if (err != 0)
72 return err;
73 return setMetaDataVa(reinterpret_cast<MetaData_t*>(handle->base_metadata),
74 paramType, param);
75 }
76
setMetaDataVa(MetaData_t * data,DispParamType paramType,void * param)77 int setMetaDataVa(MetaData_t *data, DispParamType paramType,
78 void *param) {
79 if (data == nullptr)
80 return -EINVAL;
81 // If parameter is NULL reset the specific MetaData Key
82 if (!param) {
83 data->operation &= ~paramType;
84 // param unset
85 return 0;
86 }
87
88 data->operation |= paramType;
89 switch (paramType) {
90 case PP_PARAM_INTERLACED:
91 data->interlaced = *((int32_t *)param);
92 break;
93 case UPDATE_BUFFER_GEOMETRY:
94 data->bufferDim = *((BufferDim_t *)param);
95 break;
96 case UPDATE_REFRESH_RATE:
97 data->refreshrate = *((float *)param);
98 break;
99 case UPDATE_COLOR_SPACE:
100 data->colorSpace = *((ColorSpace_t *)param);
101 break;
102 case MAP_SECURE_BUFFER:
103 data->mapSecureBuffer = *((int32_t *)param);
104 break;
105 case S3D_FORMAT:
106 data->s3dFormat = *((uint32_t *)param);
107 break;
108 case LINEAR_FORMAT:
109 data->linearFormat = *((uint32_t *)param);
110 break;
111 case SET_IGC:
112 data->igc = *((IGC_t *)param);
113 break;
114 case SET_SINGLE_BUFFER_MODE:
115 data->isSingleBufferMode = *((uint32_t *)param);
116 break;
117 case SET_S3D_COMP:
118 data->s3dComp = *((S3DGpuComp_t *)param);
119 break;
120 case SET_VT_TIMESTAMP:
121 data->vtTimeStamp = *((uint64_t *)param);
122 break;
123 case COLOR_METADATA:
124 #ifdef USE_COLOR_METADATA
125 data->color = *((ColorMetaData *)param);
126 #endif
127 break;
128 default:
129 ALOGE("Unknown paramType %d", paramType);
130 break;
131 }
132 return 0;
133 }
134
clearMetaData(private_handle_t * handle,DispParamType paramType)135 int clearMetaData(private_handle_t *handle, DispParamType paramType) {
136 auto err = validateAndMap(handle);
137 if (err != 0)
138 return err;
139 return clearMetaDataVa(reinterpret_cast<MetaData_t *>(handle->base_metadata),
140 paramType);
141 }
142
clearMetaDataVa(MetaData_t * data,DispParamType paramType)143 int clearMetaDataVa(MetaData_t *data, DispParamType paramType) {
144 if (data == nullptr)
145 return -EINVAL;
146 data->operation &= ~paramType;
147 switch (paramType) {
148 case SET_S3D_COMP:
149 data->s3dComp.displayId = -1;
150 data->s3dComp.s3dMode = 0;
151 break;
152 default:
153 ALOGE("Unknown paramType %d", paramType);
154 break;
155 }
156 return 0;
157 }
158
getMetaData(private_handle_t * handle,DispFetchParamType paramType,void * param)159 int getMetaData(private_handle_t *handle, DispFetchParamType paramType,
160 void *param) {
161 int ret = validateAndMap(handle);
162 if (ret != 0)
163 return ret;
164 return getMetaDataVa(reinterpret_cast<MetaData_t *>(handle->base_metadata),
165 paramType, param);
166 }
167
getMetaDataVa(MetaData_t * data,DispFetchParamType paramType,void * param)168 int getMetaDataVa(MetaData_t *data, DispFetchParamType paramType,
169 void *param) {
170 // Make sure we send 0 only if the operation queried is present
171 int ret = -EINVAL;
172 if (data == nullptr)
173 return ret;
174
175 switch (paramType) {
176 case GET_PP_PARAM_INTERLACED:
177 if (data->operation & PP_PARAM_INTERLACED) {
178 *((int32_t *)param) = data->interlaced;
179 ret = 0;
180 }
181 break;
182 case GET_BUFFER_GEOMETRY:
183 if (data->operation & UPDATE_BUFFER_GEOMETRY) {
184 *((BufferDim_t *)param) = data->bufferDim;
185 ret = 0;
186 }
187 break;
188 case GET_REFRESH_RATE:
189 if (data->operation & UPDATE_REFRESH_RATE) {
190 *((float *)param) = data->refreshrate;
191 ret = 0;
192 }
193 break;
194 case GET_COLOR_SPACE:
195 if (data->operation & UPDATE_COLOR_SPACE) {
196 *((ColorSpace_t *)param) = data->colorSpace;
197 ret = 0;
198 }
199 break;
200 case GET_MAP_SECURE_BUFFER:
201 if (data->operation & MAP_SECURE_BUFFER) {
202 *((int32_t *)param) = data->mapSecureBuffer;
203 ret = 0;
204 }
205 break;
206 case GET_S3D_FORMAT:
207 if (data->operation & S3D_FORMAT) {
208 *((uint32_t *)param) = data->s3dFormat;
209 ret = 0;
210 }
211 break;
212 case GET_LINEAR_FORMAT:
213 if (data->operation & LINEAR_FORMAT) {
214 *((uint32_t *)param) = data->linearFormat;
215 ret = 0;
216 }
217 break;
218 case GET_IGC:
219 if (data->operation & SET_IGC) {
220 *((IGC_t *)param) = data->igc;
221 ret = 0;
222 }
223 break;
224 case GET_SINGLE_BUFFER_MODE:
225 if (data->operation & SET_SINGLE_BUFFER_MODE) {
226 *((uint32_t *)param) = data->isSingleBufferMode;
227 ret = 0;
228 }
229 break;
230 case GET_S3D_COMP:
231 if (data->operation & SET_S3D_COMP) {
232 *((S3DGpuComp_t *)param) = data->s3dComp;
233 ret = 0;
234 }
235 break;
236 case GET_VT_TIMESTAMP:
237 if (data->operation & SET_VT_TIMESTAMP) {
238 *((uint64_t *)param) = data->vtTimeStamp;
239 ret = 0;
240 }
241 break;
242 case GET_COLOR_METADATA:
243 #ifdef USE_COLOR_METADATA
244 if (data->operation & COLOR_METADATA) {
245 *((ColorMetaData *)param) = data->color;
246 ret = 0;
247 }
248 #endif
249 break;
250 default:
251 ALOGE("Unknown paramType %d", paramType);
252 break;
253 }
254 return ret;
255 }
256
copyMetaData(struct private_handle_t * src,struct private_handle_t * dst)257 int copyMetaData(struct private_handle_t *src, struct private_handle_t *dst) {
258 auto err = validateAndMap(src);
259 if (err != 0)
260 return err;
261
262 err = validateAndMap(dst);
263 if (err != 0)
264 return err;
265
266 MetaData_t *src_data = reinterpret_cast <MetaData_t *>(src->base_metadata);
267 MetaData_t *dst_data = reinterpret_cast <MetaData_t *>(dst->base_metadata);
268 *dst_data = *src_data;
269 return 0;
270 }
271
copyMetaDataVaToHandle(MetaData_t * src_data,struct private_handle_t * dst)272 int copyMetaDataVaToHandle(MetaData_t *src_data, struct private_handle_t *dst) {
273 int err = -EINVAL;
274 if (src_data == nullptr)
275 return err;
276
277 err = validateAndMap(dst);
278 if (err != 0)
279 return err;
280
281 MetaData_t *dst_data = reinterpret_cast <MetaData_t *>(dst->base_metadata);
282 *dst_data = *src_data;
283 return 0;
284 }
285
copyMetaDataHandleToVa(struct private_handle_t * src,MetaData_t * dst_data)286 int copyMetaDataHandleToVa(struct private_handle_t *src, MetaData_t *dst_data) {
287 int err = -EINVAL;
288 if (dst_data == nullptr)
289 return err;
290
291 err = validateAndMap(src);
292 if (err != 0)
293 return err;
294
295 MetaData_t *src_data = reinterpret_cast <MetaData_t *>(src->base_metadata);
296 *dst_data = *src_data;
297 return 0;
298 }
299
copyMetaDataVaToVa(MetaData_t * src_data,MetaData_t * dst_data)300 int copyMetaDataVaToVa(MetaData_t *src_data, MetaData_t *dst_data) {
301 int err = -EINVAL;
302 if (src_data == nullptr)
303 return err;
304
305 if (dst_data == nullptr)
306 return err;
307
308 *dst_data = *src_data;
309 return 0;
310 }
311
312