1 /*
2 * Copyright (C) 2010 ARM Limited. All rights reserved.
3 *
4 * Copyright (C) 2008 The Android Open Source Project
5 *
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 */
18
19 #include <string.h>
20 #include <errno.h>
21 #include <pthread.h>
22
23 #include <cutils/log.h>
24 #include <cutils/atomic.h>
25 #include <hardware/hardware.h>
26 #include <hardware/gralloc.h>
27
28 #include <sys/ioctl.h>
29
30 #include "alloc_device.h"
31 #include "gralloc_priv.h"
32 #include "gralloc_helper.h"
33 #include "framebuffer_device.h"
34
35 #if GRALLOC_ARM_UMP_MODULE
36 #include <ump/ump.h>
37 #include <ump/ump_ref_drv.h>
38 #endif
39
40 #if GRALLOC_ARM_DMA_BUF_MODULE
41 #include <linux/ion.h>
42 #include <ion/ion.h>
43 #endif
44
45 #define GRALLOC_ALIGN( value, base ) (((value) + ((base) - 1)) & ~((base) - 1))
46
47
48 #if GRALLOC_SIMULATE_FAILURES
49 #include <cutils/properties.h>
50
51 /* system property keys for controlling simulated UMP allocation failures */
52 #define PROP_MALI_TEST_GRALLOC_FAIL_FIRST "mali.test.gralloc.fail_first"
53 #define PROP_MALI_TEST_GRALLOC_FAIL_INTERVAL "mali.test.gralloc.fail_interval"
54
__ump_alloc_should_fail()55 static int __ump_alloc_should_fail()
56 {
57
58 static unsigned int call_count = 0;
59 unsigned int first_fail = 0;
60 int fail_period = 0;
61 int fail = 0;
62
63 ++call_count;
64
65 /* read the system properties that control failure simulation */
66 {
67 char prop_value[PROPERTY_VALUE_MAX];
68
69 if (property_get(PROP_MALI_TEST_GRALLOC_FAIL_FIRST, prop_value, "0") > 0)
70 {
71 sscanf(prop_value, "%11u", &first_fail);
72 }
73
74 if (property_get(PROP_MALI_TEST_GRALLOC_FAIL_INTERVAL, prop_value, "0") > 0)
75 {
76 sscanf(prop_value, "%11u", &fail_period);
77 }
78 }
79
80 /* failure simulation is enabled by setting the first_fail property to non-zero */
81 if (first_fail > 0)
82 {
83 LOGI("iteration %u (fail=%u, period=%u)\n", call_count, first_fail, fail_period);
84
85 fail = (call_count == first_fail) ||
86 (call_count > first_fail && fail_period > 0 && 0 == (call_count - first_fail) % fail_period);
87
88 if (fail)
89 {
90 AERR("failed ump_ref_drv_allocate on iteration #%d\n", call_count);
91 }
92 }
93
94 return fail;
95 }
96 #endif
97
98
gralloc_alloc_buffer(alloc_device_t * dev,size_t size,int usage,buffer_handle_t * pHandle)99 static int gralloc_alloc_buffer(alloc_device_t *dev, size_t size, int usage, buffer_handle_t *pHandle)
100 {
101 #if GRALLOC_ARM_DMA_BUF_MODULE
102 {
103 private_module_t *m = reinterpret_cast<private_module_t *>(dev->common.module);
104 ion_user_handle_t ion_hnd;
105 unsigned char *cpu_ptr;
106 int shared_fd;
107 int ret;
108
109 ret = ion_alloc(m->ion_client, size, 0, ION_HEAP_SYSTEM_MASK, 0, &(ion_hnd));
110
111 if (ret != 0)
112 {
113 AERR("Failed to ion_alloc from ion_client:%d", m->ion_client);
114 return -1;
115 }
116
117 ret = ion_share(m->ion_client, ion_hnd, &shared_fd);
118
119 if (ret != 0)
120 {
121 AERR("ion_share( %d ) failed", m->ion_client);
122
123 if (0 != ion_free(m->ion_client, ion_hnd))
124 {
125 AERR("ion_free( %d ) failed", m->ion_client);
126 }
127
128 return -1;
129 }
130
131 // we do not need ion_hnd once we have shared_fd
132 if (0 != ion_free(m->ion_client, ion_hnd))
133 {
134 AWAR("ion_free( %d ) failed", m->ion_client);
135 }
136 ion_hnd = ION_INVALID_HANDLE;
137
138 cpu_ptr = (unsigned char *)mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, shared_fd, 0);
139
140 if (MAP_FAILED == cpu_ptr)
141 {
142 AERR("ion_map( %d ) failed", m->ion_client);
143
144 close(shared_fd);
145 return -1;
146 }
147
148 private_handle_t *hnd = new private_handle_t(private_handle_t::PRIV_FLAGS_USES_ION, usage, size, cpu_ptr, private_handle_t::LOCK_STATE_MAPPED);
149
150 if (NULL != hnd)
151 {
152 hnd->share_fd = shared_fd;
153 *pHandle = hnd;
154 return 0;
155 }
156 else
157 {
158 AERR("Gralloc out of mem for ion_client:%d", m->ion_client);
159 }
160
161 close(shared_fd);
162 ret = munmap(cpu_ptr, size);
163
164 if (0 != ret)
165 {
166 AERR("munmap failed for base:%p size: %lu", cpu_ptr, (unsigned long)size);
167 }
168
169 return -1;
170 }
171 #endif
172
173 #if GRALLOC_ARM_UMP_MODULE
174 MALI_IGNORE(dev);
175 {
176 ump_handle ump_mem_handle;
177 void *cpu_ptr;
178 ump_secure_id ump_id;
179 ump_alloc_constraints constraints;
180
181 size = round_up_to_page_size(size);
182
183 if ((usage & GRALLOC_USAGE_SW_READ_MASK) == GRALLOC_USAGE_SW_READ_OFTEN)
184 {
185 constraints = UMP_REF_DRV_CONSTRAINT_USE_CACHE;
186 }
187 else
188 {
189 constraints = UMP_REF_DRV_CONSTRAINT_NONE;
190 }
191
192 #ifdef GRALLOC_SIMULATE_FAILURES
193
194 /* if the failure condition matches, fail this iteration */
195 if (__ump_alloc_should_fail())
196 {
197 ump_mem_handle = UMP_INVALID_MEMORY_HANDLE;
198 }
199 else
200 #endif
201 {
202 ump_mem_handle = ump_ref_drv_allocate(size, constraints);
203
204 if (UMP_INVALID_MEMORY_HANDLE != ump_mem_handle)
205 {
206 cpu_ptr = ump_mapped_pointer_get(ump_mem_handle);
207
208 if (NULL != cpu_ptr)
209 {
210 ump_id = ump_secure_id_get(ump_mem_handle);
211
212 if (UMP_INVALID_SECURE_ID != ump_id)
213 {
214 private_handle_t *hnd = new private_handle_t(private_handle_t::PRIV_FLAGS_USES_UMP, usage, size, cpu_ptr,
215 private_handle_t::LOCK_STATE_MAPPED, ump_id, ump_mem_handle);
216
217 if (NULL != hnd)
218 {
219 *pHandle = hnd;
220 return 0;
221 }
222 else
223 {
224 AERR("gralloc_alloc_buffer() failed to allocate handle. ump_handle = %p, ump_id = %d", ump_mem_handle, ump_id);
225 }
226 }
227 else
228 {
229 AERR("gralloc_alloc_buffer() failed to retrieve valid secure id. ump_handle = %p", ump_mem_handle);
230 }
231
232 ump_mapped_pointer_release(ump_mem_handle);
233 }
234 else
235 {
236 AERR("gralloc_alloc_buffer() failed to map UMP memory. ump_handle = %p", ump_mem_handle);
237 }
238
239 ump_reference_release(ump_mem_handle);
240 }
241 else
242 {
243 AERR("gralloc_alloc_buffer() failed to allocate UMP memory. size:%d constraints: %d", size, constraints);
244 }
245 }
246
247 return -1;
248 }
249 #endif
250
251 }
252
gralloc_alloc_framebuffer_locked(alloc_device_t * dev,size_t size,int usage,buffer_handle_t * pHandle)253 static int gralloc_alloc_framebuffer_locked(alloc_device_t *dev, size_t size, int usage, buffer_handle_t *pHandle)
254 {
255 private_module_t *m = reinterpret_cast<private_module_t *>(dev->common.module);
256
257 // allocate the framebuffer
258 if (m->framebuffer == NULL)
259 {
260 // initialize the framebuffer, the framebuffer is mapped once and forever.
261 int err = init_frame_buffer_locked(m);
262
263 if (err < 0)
264 {
265 return err;
266 }
267 }
268
269 const uint32_t bufferMask = m->bufferMask;
270 const uint32_t numBuffers = m->numBuffers;
271 const size_t bufferSize = m->finfo.line_length * m->info.yres;
272
273 if (numBuffers == 1)
274 {
275 // If we have only one buffer, we never use page-flipping. Instead,
276 // we return a regular buffer which will be memcpy'ed to the main
277 // screen when post is called.
278 int newUsage = (usage & ~GRALLOC_USAGE_HW_FB) | GRALLOC_USAGE_HW_2D;
279 AERR("fallback to single buffering. Virtual Y-res too small %d", m->info.yres);
280 return gralloc_alloc_buffer(dev, bufferSize, newUsage, pHandle);
281 }
282
283 if (bufferMask >= ((1LU << numBuffers) - 1))
284 {
285 // We ran out of buffers.
286 return -ENOMEM;
287 }
288
289 void *vaddr = m->framebuffer->base;
290
291 // find a free slot
292 for (uint32_t i = 0 ; i < numBuffers ; i++)
293 {
294 if ((bufferMask & (1LU << i)) == 0)
295 {
296 m->bufferMask |= (1LU << i);
297 break;
298 }
299
300 vaddr = (void *)((uintptr_t)vaddr + bufferSize);
301 }
302
303 int fbdev_fd = m->framebuffer->shallow_fbdev_fd;
304 // The entire framebuffer memory is already mapped, now create a buffer object for parts of this memory
305 private_handle_t *hnd = new private_handle_t(private_handle_t::PRIV_FLAGS_FRAMEBUFFER, usage, size, vaddr,
306 0, fbdev_fd, (uintptr_t)vaddr - (uintptr_t) m->framebuffer->base);
307 #if GRALLOC_ARM_UMP_MODULE
308 hnd->ump_id = m->framebuffer->ump_id;
309
310 /* create a backing ump memory handle if the framebuffer is exposed as a secure ID */
311 if ((int)UMP_INVALID_SECURE_ID != hnd->ump_id)
312 {
313 hnd->ump_mem_handle = (int)ump_handle_create_from_secure_id(hnd->ump_id);
314
315 if ((int)UMP_INVALID_MEMORY_HANDLE == hnd->ump_mem_handle)
316 {
317 AINF("warning: unable to create UMP handle from secure ID %i\n", hnd->ump_id);
318 }
319 }
320
321 #endif
322
323 #if GRALLOC_ARM_DMA_BUF_MODULE
324 {
325 #ifdef FBIOGET_DMABUF
326 struct fb_dmabuf_export fb_dma_buf;
327
328 if (ioctl(fbdev_fd, FBIOGET_DMABUF, &fb_dma_buf) == 0)
329 {
330 AINF("framebuffer accessed with dma buf (fd 0x%x)\n", (int)fb_dma_buf.fd);
331 hnd->share_fd = fb_dma_buf.fd;
332 }
333
334 #endif
335 }
336
337 // correct numFds/numInts when there is no dmabuf fd
338 if (hnd->share_fd < 0) {
339 hnd->numFds--;
340 hnd->numInts++;
341 }
342 #endif
343
344 *pHandle = hnd;
345
346 return 0;
347 }
348
gralloc_alloc_framebuffer(alloc_device_t * dev,size_t size,int usage,buffer_handle_t * pHandle)349 static int gralloc_alloc_framebuffer(alloc_device_t *dev, size_t size, int usage, buffer_handle_t *pHandle)
350 {
351 private_module_t *m = reinterpret_cast<private_module_t *>(dev->common.module);
352 pthread_mutex_lock(&m->lock);
353 int err = gralloc_alloc_framebuffer_locked(dev, size, usage, pHandle);
354 pthread_mutex_unlock(&m->lock);
355 return err;
356 }
357
alloc_device_alloc(alloc_device_t * dev,int w,int h,int format,int usage,buffer_handle_t * pHandle,int * pStride)358 static int alloc_device_alloc(alloc_device_t *dev, int w, int h, int format, int usage, buffer_handle_t *pHandle, int *pStride)
359 {
360 if (!pHandle || !pStride)
361 {
362 return -EINVAL;
363 }
364
365 size_t size;
366 size_t stride;
367
368 if (format == HAL_PIXEL_FORMAT_YCrCb_420_SP || format == HAL_PIXEL_FORMAT_YV12
369 /* HAL_PIXEL_FORMAT_YCbCr_420_SP, HAL_PIXEL_FORMAT_YCbCr_420_P, HAL_PIXEL_FORMAT_YCbCr_422_I are not defined in Android.
370 * To enable Mali DDK EGLImage support for those formats, firstly, you have to add them in Android system/core/include/system/graphics.h.
371 * Then, define SUPPORT_LEGACY_FORMAT in the same header file(Mali DDK will also check this definition).
372 */
373 #ifdef SUPPORT_LEGACY_FORMAT
374 || format == HAL_PIXEL_FORMAT_YCbCr_420_SP || format == HAL_PIXEL_FORMAT_YCbCr_420_P || format == HAL_PIXEL_FORMAT_YCbCr_422_I
375 #endif
376 )
377 {
378 switch (format)
379 {
380 case HAL_PIXEL_FORMAT_YCrCb_420_SP:
381 stride = GRALLOC_ALIGN(w, 16);
382 size = GRALLOC_ALIGN(h, 16) * (stride + GRALLOC_ALIGN(stride / 2, 16));
383 break;
384
385 case HAL_PIXEL_FORMAT_YV12:
386 #ifdef SUPPORT_LEGACY_FORMAT
387 case HAL_PIXEL_FORMAT_YCbCr_420_P:
388 #endif
389 stride = GRALLOC_ALIGN(w, 16);
390 size = GRALLOC_ALIGN(h, 2) * (stride + GRALLOC_ALIGN(stride / 2, 16));
391
392 break;
393 #ifdef SUPPORT_LEGACY_FORMAT
394
395 case HAL_PIXEL_FORMAT_YCbCr_420_SP:
396 stride = GRALLOC_ALIGN(w, 16);
397 size = GRALLOC_ALIGN(h, 16) * (stride + GRALLOC_ALIGN(stride / 2, 16));
398 break;
399
400 case HAL_PIXEL_FORMAT_YCbCr_422_I:
401 stride = GRALLOC_ALIGN(w, 16);
402 size = h * stride * 2;
403
404 break;
405 #endif
406
407 default:
408 return -EINVAL;
409 }
410 }
411 else
412 {
413 int bpp = 0;
414
415 switch (format)
416 {
417 case HAL_PIXEL_FORMAT_RGBA_8888:
418 case HAL_PIXEL_FORMAT_RGBX_8888:
419 case HAL_PIXEL_FORMAT_BGRA_8888:
420 bpp = 4;
421 break;
422
423 case HAL_PIXEL_FORMAT_RGB_888:
424 bpp = 3;
425 break;
426
427 case HAL_PIXEL_FORMAT_RGB_565:
428 #if PLATFORM_SDK_VERSION < 19
429 case HAL_PIXEL_FORMAT_RGBA_5551:
430 case HAL_PIXEL_FORMAT_RGBA_4444:
431 #endif
432 bpp = 2;
433 break;
434
435 default:
436 return -EINVAL;
437 }
438
439 size_t bpr = GRALLOC_ALIGN(w * bpp, 64);
440 size = bpr * h;
441 stride = bpr / bpp;
442 }
443
444 int err;
445
446 #ifndef MALI_600
447
448 if (usage & GRALLOC_USAGE_HW_FB)
449 {
450 err = gralloc_alloc_framebuffer(dev, size, usage, pHandle);
451 }
452 else
453 #endif
454
455 {
456 err = gralloc_alloc_buffer(dev, size, usage, pHandle);
457 }
458
459 if (err < 0)
460 {
461 return err;
462 }
463
464 /* match the framebuffer format */
465 if (usage & GRALLOC_USAGE_HW_FB)
466 {
467 #ifdef GRALLOC_16_BITS
468 format = HAL_PIXEL_FORMAT_RGB_565;
469 #else
470 format = HAL_PIXEL_FORMAT_BGRA_8888;
471 #endif
472 }
473
474 private_handle_t *hnd = (private_handle_t *)*pHandle;
475 int private_usage = usage & (GRALLOC_USAGE_PRIVATE_0 |
476 GRALLOC_USAGE_PRIVATE_1);
477
478 switch (private_usage)
479 {
480 case 0:
481 hnd->yuv_info = MALI_YUV_BT601_NARROW;
482 break;
483
484 case GRALLOC_USAGE_PRIVATE_1:
485 hnd->yuv_info = MALI_YUV_BT601_WIDE;
486 break;
487
488 case GRALLOC_USAGE_PRIVATE_0:
489 hnd->yuv_info = MALI_YUV_BT709_NARROW;
490 break;
491
492 case (GRALLOC_USAGE_PRIVATE_0 | GRALLOC_USAGE_PRIVATE_1):
493 hnd->yuv_info = MALI_YUV_BT709_WIDE;
494 break;
495 }
496
497 hnd->width = w;
498 hnd->height = h;
499 hnd->format = format;
500 hnd->stride = stride;
501
502 *pStride = stride;
503 return 0;
504 }
505
alloc_device_free(alloc_device_t * dev,buffer_handle_t handle)506 static int alloc_device_free(alloc_device_t *dev, buffer_handle_t handle)
507 {
508 if (private_handle_t::validate(handle) < 0)
509 {
510 return -EINVAL;
511 }
512
513 private_handle_t const *hnd = reinterpret_cast<private_handle_t const *>(handle);
514
515 if (hnd->flags & private_handle_t::PRIV_FLAGS_FRAMEBUFFER)
516 {
517 // free this buffer
518 private_module_t *m = reinterpret_cast<private_module_t *>(dev->common.module);
519 const size_t bufferSize = m->finfo.line_length * m->info.yres;
520 int index = ((uintptr_t)hnd->base - (uintptr_t)m->framebuffer->base) / bufferSize;
521 m->bufferMask &= ~(1 << index);
522
523 #if GRALLOC_ARM_UMP_MODULE
524
525 if ((int)UMP_INVALID_MEMORY_HANDLE != hnd->ump_mem_handle)
526 {
527 ump_reference_release((ump_handle)hnd->ump_mem_handle);
528 }
529
530 #endif
531 }
532 else if (hnd->flags & private_handle_t::PRIV_FLAGS_USES_UMP)
533 {
534 #if GRALLOC_ARM_UMP_MODULE
535
536 /* Buffer might be unregistered so we need to check for invalid ump handle*/
537 if ((int)UMP_INVALID_MEMORY_HANDLE != hnd->ump_mem_handle)
538 {
539 ump_mapped_pointer_release((ump_handle)hnd->ump_mem_handle);
540 ump_reference_release((ump_handle)hnd->ump_mem_handle);
541 }
542
543 #else
544 AERR("Can't free ump memory for handle:0x%p. Not supported.", hnd);
545 #endif
546 }
547 else if (hnd->flags & private_handle_t::PRIV_FLAGS_USES_ION)
548 {
549 #if GRALLOC_ARM_DMA_BUF_MODULE
550 private_module_t *m = reinterpret_cast<private_module_t *>(dev->common.module);
551
552 /* Buffer might be unregistered so we need to check for invalid ump handle*/
553 if (0 != hnd->base)
554 {
555 if (0 != munmap((void *)hnd->base, hnd->size))
556 {
557 AERR("Failed to munmap handle 0x%p", hnd);
558 }
559 }
560
561 close(hnd->share_fd);
562
563 memset((void *)hnd, 0, sizeof(*hnd));
564 #else
565 AERR("Can't free dma_buf memory for handle:0x%x. Not supported.", (unsigned int)hnd);
566 #endif
567
568 }
569
570 delete hnd;
571
572 return 0;
573 }
574
alloc_device_close(struct hw_device_t * device)575 static int alloc_device_close(struct hw_device_t *device)
576 {
577 alloc_device_t *dev = reinterpret_cast<alloc_device_t *>(device);
578
579 if (dev)
580 {
581 #if GRALLOC_ARM_DMA_BUF_MODULE
582 private_module_t *m = reinterpret_cast<private_module_t *>(device);
583
584 if (0 != ion_close(m->ion_client))
585 {
586 AERR("Failed to close ion_client: %d", m->ion_client);
587 }
588
589 close(m->ion_client);
590 #endif
591 delete dev;
592 #if GRALLOC_ARM_UMP_MODULE
593 ump_close(); // Our UMP memory refs will be released automatically here...
594 #endif
595 }
596
597 return 0;
598 }
599
alloc_device_open(hw_module_t const * module,const char * name,hw_device_t ** device)600 int alloc_device_open(hw_module_t const *module, const char *name, hw_device_t **device)
601 {
602 MALI_IGNORE(name);
603 alloc_device_t *dev;
604
605 dev = new alloc_device_t;
606
607 if (NULL == dev)
608 {
609 return -1;
610 }
611
612 #if GRALLOC_ARM_UMP_MODULE
613 ump_result ump_res = ump_open();
614
615 if (UMP_OK != ump_res)
616 {
617 AERR("UMP open failed with %d", ump_res);
618 delete dev;
619 return -1;
620 }
621
622 #endif
623
624 /* initialize our state here */
625 memset(dev, 0, sizeof(*dev));
626
627 /* initialize the procs */
628 dev->common.tag = HARDWARE_DEVICE_TAG;
629 dev->common.version = 0;
630 dev->common.module = const_cast<hw_module_t *>(module);
631 dev->common.close = alloc_device_close;
632 dev->alloc = alloc_device_alloc;
633 dev->free = alloc_device_free;
634
635 #if GRALLOC_ARM_DMA_BUF_MODULE
636 private_module_t *m = reinterpret_cast<private_module_t *>(dev->common.module);
637 m->ion_client = ion_open();
638
639 if (m->ion_client < 0)
640 {
641 AERR("ion_open failed with %s", strerror(errno));
642 delete dev;
643 return -1;
644 }
645
646 #endif
647
648 *device = &dev->common;
649
650 return 0;
651 }
652