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 cpu_ptr = (unsigned char *)mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, shared_fd, 0);
132
133 if (MAP_FAILED == cpu_ptr)
134 {
135 AERR("ion_map( %d ) failed", m->ion_client);
136
137 if (0 != ion_free(m->ion_client, ion_hnd))
138 {
139 AERR("ion_free( %d ) failed", m->ion_client);
140 }
141
142 close(shared_fd);
143 return -1;
144 }
145
146 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);
147
148 if (NULL != hnd)
149 {
150 hnd->share_fd = shared_fd;
151 hnd->ion_hnd = ion_hnd;
152 *pHandle = hnd;
153 return 0;
154 }
155 else
156 {
157 AERR("Gralloc out of mem for ion_client:%d", m->ion_client);
158 }
159
160 close(shared_fd);
161 ret = munmap(cpu_ptr, size);
162
163 if (0 != ret)
164 {
165 AERR("munmap failed for base:%p size: %lu", cpu_ptr, (unsigned long)size);
166 }
167
168 ret = ion_free(m->ion_client, ion_hnd);
169
170 if (0 != ret)
171 {
172 AERR("ion_free( %d ) failed", m->ion_client);
173 }
174
175 return -1;
176 }
177 #endif
178
179 #if GRALLOC_ARM_UMP_MODULE
180 MALI_IGNORE(dev);
181 {
182 ump_handle ump_mem_handle;
183 void *cpu_ptr;
184 ump_secure_id ump_id;
185 ump_alloc_constraints constraints;
186
187 size = round_up_to_page_size(size);
188
189 if ((usage & GRALLOC_USAGE_SW_READ_MASK) == GRALLOC_USAGE_SW_READ_OFTEN)
190 {
191 constraints = UMP_REF_DRV_CONSTRAINT_USE_CACHE;
192 }
193 else
194 {
195 constraints = UMP_REF_DRV_CONSTRAINT_NONE;
196 }
197
198 #ifdef GRALLOC_SIMULATE_FAILURES
199
200 /* if the failure condition matches, fail this iteration */
201 if (__ump_alloc_should_fail())
202 {
203 ump_mem_handle = UMP_INVALID_MEMORY_HANDLE;
204 }
205 else
206 #endif
207 {
208 ump_mem_handle = ump_ref_drv_allocate(size, constraints);
209
210 if (UMP_INVALID_MEMORY_HANDLE != ump_mem_handle)
211 {
212 cpu_ptr = ump_mapped_pointer_get(ump_mem_handle);
213
214 if (NULL != cpu_ptr)
215 {
216 ump_id = ump_secure_id_get(ump_mem_handle);
217
218 if (UMP_INVALID_SECURE_ID != ump_id)
219 {
220 private_handle_t *hnd = new private_handle_t(private_handle_t::PRIV_FLAGS_USES_UMP, usage, size, cpu_ptr,
221 private_handle_t::LOCK_STATE_MAPPED, ump_id, ump_mem_handle);
222
223 if (NULL != hnd)
224 {
225 *pHandle = hnd;
226 return 0;
227 }
228 else
229 {
230 AERR("gralloc_alloc_buffer() failed to allocate handle. ump_handle = %p, ump_id = %d", ump_mem_handle, ump_id);
231 }
232 }
233 else
234 {
235 AERR("gralloc_alloc_buffer() failed to retrieve valid secure id. ump_handle = %p", ump_mem_handle);
236 }
237
238 ump_mapped_pointer_release(ump_mem_handle);
239 }
240 else
241 {
242 AERR("gralloc_alloc_buffer() failed to map UMP memory. ump_handle = %p", ump_mem_handle);
243 }
244
245 ump_reference_release(ump_mem_handle);
246 }
247 else
248 {
249 AERR("gralloc_alloc_buffer() failed to allocate UMP memory. size:%d constraints: %d", size, constraints);
250 }
251 }
252
253 return -1;
254 }
255 #endif
256
257 }
258
gralloc_alloc_framebuffer_locked(alloc_device_t * dev,size_t size,int usage,buffer_handle_t * pHandle)259 static int gralloc_alloc_framebuffer_locked(alloc_device_t *dev, size_t size, int usage, buffer_handle_t *pHandle)
260 {
261 private_module_t *m = reinterpret_cast<private_module_t *>(dev->common.module);
262
263 // allocate the framebuffer
264 if (m->framebuffer == NULL)
265 {
266 // initialize the framebuffer, the framebuffer is mapped once and forever.
267 int err = init_frame_buffer_locked(m);
268
269 if (err < 0)
270 {
271 return err;
272 }
273 }
274
275 const uint32_t bufferMask = m->bufferMask;
276 const uint32_t numBuffers = m->numBuffers;
277 const size_t bufferSize = m->finfo.line_length * m->info.yres;
278
279 if (numBuffers == 1)
280 {
281 // If we have only one buffer, we never use page-flipping. Instead,
282 // we return a regular buffer which will be memcpy'ed to the main
283 // screen when post is called.
284 int newUsage = (usage & ~GRALLOC_USAGE_HW_FB) | GRALLOC_USAGE_HW_2D;
285 AERR("fallback to single buffering. Virtual Y-res too small %d", m->info.yres);
286 return gralloc_alloc_buffer(dev, bufferSize, newUsage, pHandle);
287 }
288
289 if (bufferMask >= ((1LU << numBuffers) - 1))
290 {
291 // We ran out of buffers.
292 return -ENOMEM;
293 }
294
295 void *vaddr = m->framebuffer->base;
296
297 // find a free slot
298 for (uint32_t i = 0 ; i < numBuffers ; i++)
299 {
300 if ((bufferMask & (1LU << i)) == 0)
301 {
302 m->bufferMask |= (1LU << i);
303 break;
304 }
305
306 vaddr = (void *)((uintptr_t)vaddr + bufferSize);
307 }
308
309 // The entire framebuffer memory is already mapped, now create a buffer object for parts of this memory
310 private_handle_t *hnd = new private_handle_t(private_handle_t::PRIV_FLAGS_FRAMEBUFFER, usage, size, vaddr,
311 0, dup(m->framebuffer->fd), (uintptr_t)vaddr - (uintptr_t) m->framebuffer->base);
312 #if GRALLOC_ARM_UMP_MODULE
313 hnd->ump_id = m->framebuffer->ump_id;
314
315 /* create a backing ump memory handle if the framebuffer is exposed as a secure ID */
316 if ((int)UMP_INVALID_SECURE_ID != hnd->ump_id)
317 {
318 hnd->ump_mem_handle = (int)ump_handle_create_from_secure_id(hnd->ump_id);
319
320 if ((int)UMP_INVALID_MEMORY_HANDLE == hnd->ump_mem_handle)
321 {
322 AINF("warning: unable to create UMP handle from secure ID %i\n", hnd->ump_id);
323 }
324 }
325
326 #endif
327
328 #if GRALLOC_ARM_DMA_BUF_MODULE
329 {
330 #ifdef FBIOGET_DMABUF
331 struct fb_dmabuf_export fb_dma_buf;
332
333 if (ioctl(m->framebuffer->fd, FBIOGET_DMABUF, &fb_dma_buf) == 0)
334 {
335 AINF("framebuffer accessed with dma buf (fd 0x%x)\n", (int)fb_dma_buf.fd);
336 hnd->share_fd = fb_dma_buf.fd;
337 }
338
339 #endif
340 }
341 #endif
342
343 *pHandle = hnd;
344
345 return 0;
346 }
347
gralloc_alloc_framebuffer(alloc_device_t * dev,size_t size,int usage,buffer_handle_t * pHandle)348 static int gralloc_alloc_framebuffer(alloc_device_t *dev, size_t size, int usage, buffer_handle_t *pHandle)
349 {
350 private_module_t *m = reinterpret_cast<private_module_t *>(dev->common.module);
351 pthread_mutex_lock(&m->lock);
352 int err = gralloc_alloc_framebuffer_locked(dev, size, usage, pHandle);
353 pthread_mutex_unlock(&m->lock);
354 return err;
355 }
356
alloc_device_alloc(alloc_device_t * dev,int w,int h,int format,int usage,buffer_handle_t * pHandle,int * pStride)357 static int alloc_device_alloc(alloc_device_t *dev, int w, int h, int format, int usage, buffer_handle_t *pHandle, int *pStride)
358 {
359 if (!pHandle || !pStride)
360 {
361 return -EINVAL;
362 }
363
364 size_t size;
365 size_t stride;
366
367 if (format == HAL_PIXEL_FORMAT_YCrCb_420_SP || format == HAL_PIXEL_FORMAT_YV12
368 /* HAL_PIXEL_FORMAT_YCbCr_420_SP, HAL_PIXEL_FORMAT_YCbCr_420_P, HAL_PIXEL_FORMAT_YCbCr_422_I are not defined in Android.
369 * To enable Mali DDK EGLImage support for those formats, firstly, you have to add them in Android system/core/include/system/graphics.h.
370 * Then, define SUPPORT_LEGACY_FORMAT in the same header file(Mali DDK will also check this definition).
371 */
372 #ifdef SUPPORT_LEGACY_FORMAT
373 || format == HAL_PIXEL_FORMAT_YCbCr_420_SP || format == HAL_PIXEL_FORMAT_YCbCr_420_P || format == HAL_PIXEL_FORMAT_YCbCr_422_I
374 #endif
375 )
376 {
377 switch (format)
378 {
379 case HAL_PIXEL_FORMAT_YCrCb_420_SP:
380 stride = GRALLOC_ALIGN(w, 16);
381 size = GRALLOC_ALIGN(h, 16) * (stride + GRALLOC_ALIGN(stride / 2, 16));
382 break;
383
384 case HAL_PIXEL_FORMAT_YV12:
385 #ifdef SUPPORT_LEGACY_FORMAT
386 case HAL_PIXEL_FORMAT_YCbCr_420_P:
387 #endif
388 stride = GRALLOC_ALIGN(w, 16);
389 size = GRALLOC_ALIGN(h, 2) * (stride + GRALLOC_ALIGN(stride / 2, 16));
390
391 break;
392 #ifdef SUPPORT_LEGACY_FORMAT
393
394 case HAL_PIXEL_FORMAT_YCbCr_420_SP:
395 stride = GRALLOC_ALIGN(w, 16);
396 size = GRALLOC_ALIGN(h, 16) * (stride + GRALLOC_ALIGN(stride / 2, 16));
397 break;
398
399 case HAL_PIXEL_FORMAT_YCbCr_422_I:
400 stride = GRALLOC_ALIGN(w, 16);
401 size = h * stride * 2;
402
403 break;
404 #endif
405
406 default:
407 return -EINVAL;
408 }
409 }
410 else
411 {
412 int bpp = 0;
413
414 switch (format)
415 {
416 case HAL_PIXEL_FORMAT_RGBA_8888:
417 case HAL_PIXEL_FORMAT_RGBX_8888:
418 case HAL_PIXEL_FORMAT_BGRA_8888:
419 bpp = 4;
420 break;
421
422 case HAL_PIXEL_FORMAT_RGB_888:
423 bpp = 3;
424 break;
425
426 case HAL_PIXEL_FORMAT_RGB_565:
427 #if PLATFORM_SDK_VERSION < 19
428 case HAL_PIXEL_FORMAT_RGBA_5551:
429 case HAL_PIXEL_FORMAT_RGBA_4444:
430 #endif
431 bpp = 2;
432 break;
433
434 default:
435 return -EINVAL;
436 }
437
438 size_t bpr = GRALLOC_ALIGN(w * bpp, 64);
439 size = bpr * h;
440 stride = bpr / bpp;
441 }
442
443 int err;
444
445 #ifndef MALI_600
446
447 if (usage & GRALLOC_USAGE_HW_FB)
448 {
449 err = gralloc_alloc_framebuffer(dev, size, usage, pHandle);
450 }
451 else
452 #endif
453
454 {
455 err = gralloc_alloc_buffer(dev, size, usage, pHandle);
456 }
457
458 if (err < 0)
459 {
460 return err;
461 }
462
463 /* match the framebuffer format */
464 if (usage & GRALLOC_USAGE_HW_FB)
465 {
466 #ifdef GRALLOC_16_BITS
467 format = HAL_PIXEL_FORMAT_RGB_565;
468 #else
469 format = HAL_PIXEL_FORMAT_BGRA_8888;
470 #endif
471 }
472
473 private_handle_t *hnd = (private_handle_t *)*pHandle;
474 int private_usage = usage & (GRALLOC_USAGE_PRIVATE_0 |
475 GRALLOC_USAGE_PRIVATE_1);
476
477 switch (private_usage)
478 {
479 case 0:
480 hnd->yuv_info = MALI_YUV_BT601_NARROW;
481 break;
482
483 case GRALLOC_USAGE_PRIVATE_1:
484 hnd->yuv_info = MALI_YUV_BT601_WIDE;
485 break;
486
487 case GRALLOC_USAGE_PRIVATE_0:
488 hnd->yuv_info = MALI_YUV_BT709_NARROW;
489 break;
490
491 case (GRALLOC_USAGE_PRIVATE_0 | GRALLOC_USAGE_PRIVATE_1):
492 hnd->yuv_info = MALI_YUV_BT709_WIDE;
493 break;
494 }
495
496 hnd->width = w;
497 hnd->height = h;
498 hnd->format = format;
499 hnd->stride = stride;
500
501 *pStride = stride;
502 return 0;
503 }
504
alloc_device_free(alloc_device_t * dev,buffer_handle_t handle)505 static int alloc_device_free(alloc_device_t *dev, buffer_handle_t handle)
506 {
507 if (private_handle_t::validate(handle) < 0)
508 {
509 return -EINVAL;
510 }
511
512 private_handle_t const *hnd = reinterpret_cast<private_handle_t const *>(handle);
513
514 if (hnd->flags & private_handle_t::PRIV_FLAGS_FRAMEBUFFER)
515 {
516 // free this buffer
517 private_module_t *m = reinterpret_cast<private_module_t *>(dev->common.module);
518 const size_t bufferSize = m->finfo.line_length * m->info.yres;
519 int index = ((uintptr_t)hnd->base - (uintptr_t)m->framebuffer->base) / bufferSize;
520 m->bufferMask &= ~(1 << index);
521 close(hnd->fd);
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 if (0 != ion_free(m->ion_client, hnd->ion_hnd))
564 {
565 AERR("Failed to ion_free( ion_client: %d ion_hnd: %p )", m->ion_client, (void *)(uintptr_t)hnd->ion_hnd);
566 }
567
568 memset((void *)hnd, 0, sizeof(*hnd));
569 #else
570 AERR("Can't free dma_buf memory for handle:0x%x. Not supported.", (unsigned int)hnd);
571 #endif
572
573 }
574
575 delete hnd;
576
577 return 0;
578 }
579
alloc_device_close(struct hw_device_t * device)580 static int alloc_device_close(struct hw_device_t *device)
581 {
582 alloc_device_t *dev = reinterpret_cast<alloc_device_t *>(device);
583
584 if (dev)
585 {
586 #if GRALLOC_ARM_DMA_BUF_MODULE
587 private_module_t *m = reinterpret_cast<private_module_t *>(device);
588
589 if (0 != ion_close(m->ion_client))
590 {
591 AERR("Failed to close ion_client: %d", m->ion_client);
592 }
593
594 close(m->ion_client);
595 #endif
596 delete dev;
597 #if GRALLOC_ARM_UMP_MODULE
598 ump_close(); // Our UMP memory refs will be released automatically here...
599 #endif
600 }
601
602 return 0;
603 }
604
alloc_device_open(hw_module_t const * module,const char * name,hw_device_t ** device)605 int alloc_device_open(hw_module_t const *module, const char *name, hw_device_t **device)
606 {
607 MALI_IGNORE(name);
608 alloc_device_t *dev;
609
610 dev = new alloc_device_t;
611
612 if (NULL == dev)
613 {
614 return -1;
615 }
616
617 #if GRALLOC_ARM_UMP_MODULE
618 ump_result ump_res = ump_open();
619
620 if (UMP_OK != ump_res)
621 {
622 AERR("UMP open failed with %d", ump_res);
623 delete dev;
624 return -1;
625 }
626
627 #endif
628
629 /* initialize our state here */
630 memset(dev, 0, sizeof(*dev));
631
632 /* initialize the procs */
633 dev->common.tag = HARDWARE_DEVICE_TAG;
634 dev->common.version = 0;
635 dev->common.module = const_cast<hw_module_t *>(module);
636 dev->common.close = alloc_device_close;
637 dev->alloc = alloc_device_alloc;
638 dev->free = alloc_device_free;
639
640 #if GRALLOC_ARM_DMA_BUF_MODULE
641 private_module_t *m = reinterpret_cast<private_module_t *>(dev->common.module);
642 m->ion_client = ion_open();
643
644 if (m->ion_client < 0)
645 {
646 AERR("ion_open failed with %s", strerror(errno));
647 delete dev;
648 return -1;
649 }
650
651 #endif
652
653 *device = &dev->common;
654
655 return 0;
656 }
657