1 /*
2 * Copyright (C) 2008 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 #include <limits.h>
18 #include <unistd.h>
19 #include <fcntl.h>
20 #include <errno.h>
21 #include <pthread.h>
22 #include <stdlib.h>
23 #include <string.h>
24
25 #include <sys/mman.h>
26 #include <sys/stat.h>
27 #include <sys/types.h>
28 #include <sys/ioctl.h>
29
30 #include <ion/ion.h>
31 #include <linux/ion.h>
32 #include <cutils/log.h>
33 #include <cutils/atomic.h>
34
35 #include <hardware/hardware.h>
36 #include <hardware/gralloc.h>
37
38 #include "gralloc_priv.h"
39 #include "exynos_format.h"
40
41 #define ION_HEAP_EXYNOS_CONTIG_MASK (1 << 4)
42 #define ION_EXYNOS_FIMD_VIDEO_MASK (1 << 28)
43 #define ION_EXYNOS_MFC_OUTPUT_MASK (1 << 26)
44 #define ION_EXYNOS_MFC_INPUT_MASK (1 << 25)
45 #define ION_HEAP_SYSTEM_ID 0
46 #define ION_HEAP_EXYNOS_CONTIG_ID 4
47 #define ION_HEAP_CHUNK_ID 6
48 #define MB_1 (1024*1024)
49
50
51 /*****************************************************************************/
52
53 struct gralloc_context_t {
54 alloc_device_t device;
55 /* our private data here */
56 };
57
58 static int gralloc_alloc_buffer(alloc_device_t* dev,
59 size_t size, int usage, buffer_handle_t* pHandle);
60
61 /*****************************************************************************/
62
63 int fb_device_open(const hw_module_t* module, const char* name,
64 hw_device_t** device);
65
66 static int gralloc_device_open(const hw_module_t* module, const char* name,
67 hw_device_t** device);
68
69 extern int gralloc_lock(gralloc_module_t const* module,
70 buffer_handle_t handle, int usage,
71 int l, int t, int w, int h,
72 void** vaddr);
73
74 extern int gralloc_unlock(gralloc_module_t const* module,
75 buffer_handle_t handle);
76
77 extern int gralloc_register_buffer(gralloc_module_t const* module,
78 buffer_handle_t handle);
79
80 extern int gralloc_unregister_buffer(gralloc_module_t const* module,
81 buffer_handle_t handle);
82
83 /*****************************************************************************/
84
85 static struct hw_module_methods_t gralloc_module_methods = {
86 open: gralloc_device_open
87 };
88
89 struct private_module_t HAL_MODULE_INFO_SYM = {
90 base: {
91 common: {
92 tag: HARDWARE_MODULE_TAG,
93 version_major: 1,
94 version_minor: 0,
95 id: GRALLOC_HARDWARE_MODULE_ID,
96 name: "Graphics Memory Allocator Module",
97 author: "The Android Open Source Project",
98 methods: &gralloc_module_methods
99 },
100 registerBuffer: gralloc_register_buffer,
101 unregisterBuffer: gralloc_unregister_buffer,
102 lock: gralloc_lock,
103 unlock: gralloc_unlock,
104 },
105 framebuffer: 0,
106 flags: 0,
107 numBuffers: 0,
108 bufferMask: 0,
109 lock: PTHREAD_MUTEX_INITIALIZER,
110 refcount: 0,
111 currentBuffer: 0,
112 ionfd: -1,
113 };
114
115 /*****************************************************************************/
116
_select_heap(int usage)117 static unsigned int _select_heap(int usage)
118 {
119 unsigned int heap_mask;
120
121 if (usage & GRALLOC_USAGE_PROTECTED)
122 heap_mask = (1 << ION_HEAP_EXYNOS_CONTIG_ID);
123 else
124 heap_mask = (1 << ION_HEAP_SYSTEM_ID) | (1 << ION_HEAP_CHUNK_ID);
125
126 return heap_mask;
127 }
128
gralloc_alloc_rgb(int ionfd,int w,int h,int format,int usage,unsigned int ion_flags,private_handle_t ** hnd,int * stride)129 static int gralloc_alloc_rgb(int ionfd, int w, int h, int format, int usage,
130 unsigned int ion_flags, private_handle_t **hnd, int *stride)
131 {
132 size_t size, bpr, alignment = 0;
133 int bpp = 0, vstride, fd, err;
134 unsigned int heap_mask = _select_heap(usage);
135
136 if (format == HAL_PIXEL_FORMAT_RGBA_8888) {
137 bool sw_usage = !!(usage & (GRALLOC_USAGE_SW_READ_MASK |
138 GRALLOC_USAGE_SW_WRITE_MASK));
139
140 if (usage & GRALLOC_USAGE_HW_FB) {
141 ALOGW_IF(sw_usage,
142 "framebuffer target should not have SW usage bits; ignoring");
143 format = HAL_PIXEL_FORMAT_BGRA_8888;
144 } else if (usage & GRALLOC_USAGE_HW_VIDEO_ENCODER) {
145 if (sw_usage)
146 return -EINVAL;
147 format = HAL_PIXEL_FORMAT_BGRA_8888;
148 }
149 }
150
151 switch (format) {
152 case HAL_PIXEL_FORMAT_RGBA_8888:
153 case HAL_PIXEL_FORMAT_RGBX_8888:
154 case HAL_PIXEL_FORMAT_BGRA_8888:
155 case HAL_PIXEL_FORMAT_sRGB_A_8888:
156 case HAL_PIXEL_FORMAT_sRGB_X_8888:
157 bpp = 4;
158 break;
159 case HAL_PIXEL_FORMAT_RGB_888:
160 bpp = 3;
161 break;
162 case HAL_PIXEL_FORMAT_RGB_565:
163 case HAL_PIXEL_FORMAT_RAW_SENSOR:
164 bpp = 2;
165 break;
166 case HAL_PIXEL_FORMAT_BLOB:
167 *stride = w;
168 vstride = h;
169 size = w * h;
170 break;
171 default:
172 return -EINVAL;
173 }
174
175 if (format != HAL_PIXEL_FORMAT_BLOB) {
176 bpr = ALIGN(w*bpp, 64);
177 vstride = ALIGN(h, 16);
178 if (vstride < h + 2)
179 size = bpr * (h + 2);
180 else
181 size = bpr * vstride;
182 *stride = bpr / bpp;
183 size = ALIGN(size, PAGE_SIZE);
184 }
185
186 if (usage & GRALLOC_USAGE_PROTECTED) {
187 alignment = MB_1;
188 ion_flags |= ION_EXYNOS_FIMD_VIDEO_MASK;
189 }
190
191 err = ion_alloc_fd(ionfd, size, alignment, heap_mask, ion_flags,
192 &fd);
193 *hnd = new private_handle_t(fd, size, usage, w, h, format, *stride,
194 vstride);
195
196 return err;
197 }
198
gralloc_alloc_framework_yuv(int ionfd,int w,int h,int format,int usage,unsigned int ion_flags,private_handle_t ** hnd,int * stride)199 static int gralloc_alloc_framework_yuv(int ionfd, int w, int h, int format,
200 int usage, unsigned int ion_flags,
201 private_handle_t **hnd, int *stride)
202 {
203 size_t size;
204 int err, fd;
205 unsigned int heap_mask = _select_heap(usage);
206
207 switch (format) {
208 case HAL_PIXEL_FORMAT_YV12:
209 *stride = ALIGN(w, 16);
210 size = (*stride * h) + (ALIGN(*stride / 2, 16) * h);
211 break;
212 case HAL_PIXEL_FORMAT_YCrCb_420_SP:
213 *stride = w;
214 size = *stride * h * 3 / 2;
215 break;
216 default:
217 ALOGE("invalid yuv format %d\n", format);
218 return -EINVAL;
219 }
220
221 err = ion_alloc_fd(ionfd, size, 0, heap_mask, ion_flags, &fd);
222 if (err)
223 return err;
224
225 *hnd = new private_handle_t(fd, size, usage, w, h, format, *stride, h);
226 return err;
227 }
228
gralloc_alloc_yuv(int ionfd,int w,int h,int format,int usage,unsigned int ion_flags,private_handle_t ** hnd,int * stride)229 static int gralloc_alloc_yuv(int ionfd, int w, int h, int format,
230 int usage, unsigned int ion_flags,
231 private_handle_t **hnd, int *stride)
232 {
233 size_t luma_size, chroma_size;
234 int err, planes, fd, fd1, fd2 = 0;
235 size_t luma_vstride;
236 unsigned int heap_mask = _select_heap(usage);
237
238 *stride = ALIGN(w, 16);
239
240 if (format == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED) {
241 ALOGV("HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED : usage(%x), flags(%x)\n", usage, ion_flags);
242 if ((usage & GRALLOC_USAGE_HW_CAMERA_ZSL) == GRALLOC_USAGE_HW_CAMERA_ZSL) {
243 format = HAL_PIXEL_FORMAT_YCbCr_422_I; // YUYV
244 } else if (usage & GRALLOC_USAGE_HW_TEXTURE) {
245 format = HAL_PIXEL_FORMAT_EXYNOS_YV12;
246 } else if (usage & GRALLOC_USAGE_HW_VIDEO_ENCODER) {
247 format = HAL_PIXEL_FORMAT_YCbCr_420_SP; // NV12M
248 }
249 }
250 switch (format) {
251 case HAL_PIXEL_FORMAT_EXYNOS_YV12:
252 {
253 *stride = ALIGN(w, 32);
254 luma_vstride = ALIGN(h, 16);
255 luma_size = luma_vstride * *stride;
256 chroma_size = (luma_vstride / 2) * ALIGN(*stride / 2, 16);
257 planes = 3;
258 break;
259 }
260 case HAL_PIXEL_FORMAT_EXYNOS_YCrCb_420_SP:
261 case HAL_PIXEL_FORMAT_YCbCr_420_SP:
262 case HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED:
263 {
264 size_t chroma_vstride = ALIGN(h / 2, 32);
265 luma_vstride = ALIGN(h, 32);
266 luma_size = luma_vstride * *stride;
267 chroma_size = chroma_vstride * *stride;
268 planes = 2;
269 break;
270 }
271 case HAL_PIXEL_FORMAT_YV12:
272 case HAL_PIXEL_FORMAT_YCrCb_420_SP:
273 return gralloc_alloc_framework_yuv(ionfd, w, h, format, usage,
274 ion_flags, hnd, stride);
275 case HAL_PIXEL_FORMAT_YCbCr_422_I:
276 {
277 luma_vstride = h;
278 luma_size = luma_vstride * *stride * 2;
279 chroma_size = 0;
280 planes = 1;
281 break;
282 }
283 default:
284 ALOGE("invalid yuv format %d\n", format);
285 return -EINVAL;
286 }
287
288 if (usage & GRALLOC_USAGE_PROTECTED)
289 ion_flags |= ION_EXYNOS_MFC_OUTPUT_MASK;
290
291 err = ion_alloc_fd(ionfd, luma_size, 0, heap_mask, ion_flags, &fd);
292 if (err)
293 return err;
294 if (planes == 1) {
295 *hnd = new private_handle_t(fd, luma_size, usage, w, h,
296 format, *stride, luma_vstride);
297 } else {
298 err = ion_alloc_fd(ionfd, chroma_size, 0, heap_mask, ion_flags, &fd1);
299 if (err)
300 goto err1;
301 if (planes == 3) {
302 err = ion_alloc_fd(ionfd, chroma_size, 0, heap_mask, ion_flags, &fd2);
303 if (err)
304 goto err2;
305
306 *hnd = new private_handle_t(fd, fd1, fd2, luma_size, usage, w, h,
307 format, *stride, luma_vstride);
308 } else {
309 *hnd = new private_handle_t(fd, fd1, luma_size, usage, w, h, format,
310 *stride, luma_vstride);
311 }
312 }
313 // Set chroma & gamut fields
314 if (!err && *hnd) {
315 if (usage & GRALLOC_USAGE_PRIVATE_CHROMA) {
316 (*hnd)->chroma = HAL_PIXEL_CHROMA_BT601_8;
317 (*hnd)->gamut = HAL_PIXEL_GAMUT_NARROW_8;
318 } else {
319 (*hnd)->chroma = HAL_PIXEL_CHROMA_BT709_8;
320 (*hnd)->gamut = HAL_PIXEL_GAMUT_WIDE_8;
321 }
322 }
323 return err;
324
325 err2:
326 close(fd1);
327 err1:
328 close(fd);
329 return err;
330 }
331
gralloc_alloc(alloc_device_t * dev,int w,int h,int format,int usage,buffer_handle_t * pHandle,int * pStride)332 static int gralloc_alloc(alloc_device_t* dev,
333 int w, int h, int format, int usage,
334 buffer_handle_t* pHandle, int* pStride)
335 {
336 int stride;
337 int err;
338 unsigned int ion_flags = 0;
339 private_handle_t *hnd = NULL;
340
341 if (!pHandle || !pStride)
342 return -EINVAL;
343
344 if( (usage & GRALLOC_USAGE_SW_READ_MASK) == GRALLOC_USAGE_SW_READ_OFTEN )
345 ion_flags = ION_FLAG_CACHED | ION_FLAG_CACHED_NEEDS_SYNC;
346
347 private_module_t* m = reinterpret_cast<private_module_t*>
348 (dev->common.module);
349 gralloc_module_t* module = reinterpret_cast<gralloc_module_t*>
350 (dev->common.module);
351
352 err = gralloc_alloc_rgb(m->ionfd, w, h, format, usage, ion_flags, &hnd,
353 &stride);
354 if (err)
355 err = gralloc_alloc_yuv(m->ionfd, w, h, format, usage, ion_flags,
356 &hnd, &stride);
357 if (err)
358 goto err;
359
360 err = gralloc_register_buffer(module, hnd);
361 if (err)
362 goto err;
363
364 *pHandle = hnd;
365 *pStride = stride;
366 return 0;
367 err:
368 if (!hnd)
369 return err;
370 close(hnd->fd);
371 if (hnd->fd1 >= 0)
372 close(hnd->fd1);
373 if (hnd->fd2 >= 0)
374 close(hnd->fd2);
375 return err;
376 }
377
gralloc_free(alloc_device_t * dev,buffer_handle_t handle)378 static int gralloc_free(alloc_device_t* dev,
379 buffer_handle_t handle)
380 {
381 if (private_handle_t::validate(handle) < 0)
382 return -EINVAL;
383
384 private_handle_t const* hnd = reinterpret_cast<private_handle_t const*>(handle);
385 gralloc_module_t* module = reinterpret_cast<gralloc_module_t*>(
386 dev->common.module);
387
388 gralloc_unregister_buffer(module, hnd);
389
390 close(hnd->fd);
391 if (hnd->fd1 >= 0)
392 close(hnd->fd1);
393 if (hnd->fd2 >= 0)
394 close(hnd->fd2);
395
396 delete hnd;
397 return 0;
398 }
399
400 /*****************************************************************************/
401
gralloc_close(struct hw_device_t * dev)402 static int gralloc_close(struct hw_device_t *dev)
403 {
404 gralloc_context_t* ctx = reinterpret_cast<gralloc_context_t*>(dev);
405 if (ctx) {
406 private_module_t *p = reinterpret_cast<private_module_t*>(ctx->device.common.module);
407 pthread_mutex_lock(&p->lock);
408 LOG_ALWAYS_FATAL_IF(!p->refcount);
409 p->refcount--;
410 if (!p->refcount)
411 close(p->ionfd);
412 pthread_mutex_unlock(&p->lock);
413
414 /* TODO: keep a list of all buffer_handle_t created, and free them
415 * all here.
416 */
417 free(ctx);
418 }
419 return 0;
420 }
421
gralloc_device_open(const hw_module_t * module,const char * name,hw_device_t ** device)422 int gralloc_device_open(const hw_module_t* module, const char* name,
423 hw_device_t** device)
424 {
425 int status = -EINVAL;
426 if (!strcmp(name, GRALLOC_HARDWARE_GPU0)) {
427 gralloc_context_t *dev;
428 dev = (gralloc_context_t*)malloc(sizeof(*dev));
429
430 /* initialize our state here */
431 memset(dev, 0, sizeof(*dev));
432
433 /* initialize the procs */
434 dev->device.common.tag = HARDWARE_DEVICE_TAG;
435 dev->device.common.version = 0;
436 dev->device.common.module = const_cast<hw_module_t*>(module);
437 dev->device.common.close = gralloc_close;
438
439 dev->device.alloc = gralloc_alloc;
440 dev->device.free = gralloc_free;
441
442 private_module_t *p = reinterpret_cast<private_module_t*>(dev->device.common.module);
443 pthread_mutex_lock(&p->lock);
444 if (!p->refcount)
445 p->ionfd = ion_open();
446 p->refcount++;
447 pthread_mutex_unlock(&p->lock);
448
449 *device = &dev->device.common;
450 status = 0;
451 } else {
452 status = fb_device_open(module, name, device);
453 }
454 return status;
455 }
456