1 /*
2 * Copyright (C) 2011 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 #include <string.h>
17 #include <pthread.h>
18 #ifdef HAVE_ANDROID_OS // just want PAGE_SIZE define
19 # include <asm/page.h>
20 #else
21 # include <sys/user.h>
22 #endif
23 #include <cutils/ashmem.h>
24 #include <unistd.h>
25 #include <errno.h>
26 #include <dlfcn.h>
27 #include <sys/mman.h>
28 #include "gralloc_cb.h"
29 #include "HostConnection.h"
30 #include "glUtils.h"
31 #include <cutils/log.h>
32 #include <cutils/properties.h>
33
34 /* Set to 1 or 2 to enable debug traces */
35 #define DEBUG 0
36
37 #if DEBUG >= 1
38 # define D(...) ALOGD(__VA_ARGS__)
39 #else
40 # define D(...) ((void)0)
41 #endif
42
43 #if DEBUG >= 2
44 # define DD(...) ALOGD(__VA_ARGS__)
45 #else
46 # define DD(...) ((void)0)
47 #endif
48
49 #define DBG_FUNC DBG("%s\n", __FUNCTION__)
50 //
51 // our private gralloc module structure
52 //
53 struct private_module_t {
54 gralloc_module_t base;
55 };
56
57 /* If not NULL, this is a pointer to the fallback module.
58 * This really is gralloc.default, which we'll use if we detect
59 * that the emulator we're running in does not support GPU emulation.
60 */
61 static gralloc_module_t* sFallback;
62 static pthread_once_t sFallbackOnce = PTHREAD_ONCE_INIT;
63
64 static void fallback_init(void); // forward
65
66
67 typedef struct _alloc_list_node {
68 buffer_handle_t handle;
69 _alloc_list_node *next;
70 _alloc_list_node *prev;
71 } AllocListNode;
72
73 //
74 // Our gralloc device structure (alloc interface)
75 //
76 struct gralloc_device_t {
77 alloc_device_t device;
78
79 AllocListNode *allocListHead; // double linked list of allocated buffers
80 pthread_mutex_t lock;
81 };
82
83 //
84 // Our framebuffer device structure
85 //
86 struct fb_device_t {
87 framebuffer_device_t device;
88 };
89
map_buffer(cb_handle_t * cb,void ** vaddr)90 static int map_buffer(cb_handle_t *cb, void **vaddr)
91 {
92 if (cb->fd < 0 || cb->ashmemSize <= 0) {
93 return -EINVAL;
94 }
95
96 void *addr = mmap(0, cb->ashmemSize, PROT_READ | PROT_WRITE,
97 MAP_SHARED, cb->fd, 0);
98 if (addr == MAP_FAILED) {
99 return -errno;
100 }
101
102 cb->ashmemBase = intptr_t(addr);
103 cb->ashmemBasePid = getpid();
104
105 *vaddr = addr;
106 return 0;
107 }
108
109 #define DEFINE_HOST_CONNECTION \
110 HostConnection *hostCon = HostConnection::get(); \
111 renderControl_encoder_context_t *rcEnc = (hostCon ? hostCon->rcEncoder() : NULL)
112
113 #define DEFINE_AND_VALIDATE_HOST_CONNECTION \
114 HostConnection *hostCon = HostConnection::get(); \
115 if (!hostCon) { \
116 ALOGE("gralloc: Failed to get host connection\n"); \
117 return -EIO; \
118 } \
119 renderControl_encoder_context_t *rcEnc = hostCon->rcEncoder(); \
120 if (!rcEnc) { \
121 ALOGE("gralloc: Failed to get renderControl encoder context\n"); \
122 return -EIO; \
123 }
124
125
126 //
127 // gralloc device functions (alloc interface)
128 //
gralloc_alloc(alloc_device_t * dev,int w,int h,int format,int usage,buffer_handle_t * pHandle,int * pStride)129 static int gralloc_alloc(alloc_device_t* dev,
130 int w, int h, int format, int usage,
131 buffer_handle_t* pHandle, int* pStride)
132 {
133 D("gralloc_alloc w=%d h=%d usage=0x%x\n", w, h, usage);
134
135 gralloc_device_t *grdev = (gralloc_device_t *)dev;
136 if (!grdev || !pHandle || !pStride) {
137 ALOGE("gralloc_alloc: Bad inputs (grdev: %p, pHandle: %p, pStride: %p",
138 grdev, pHandle, pStride);
139 return -EINVAL;
140 }
141
142 //
143 // Validate usage: buffer cannot be written both by s/w and h/w access.
144 //
145 bool sw_write = (0 != (usage & GRALLOC_USAGE_SW_WRITE_MASK));
146 bool hw_write = (usage & GRALLOC_USAGE_HW_RENDER);
147 if (hw_write && sw_write) {
148 ALOGE("gralloc_alloc: Mismatched usage flags: %d x %d, usage %x",
149 w, h, usage);
150 return -EINVAL;
151 }
152 bool sw_read = (0 != (usage & GRALLOC_USAGE_SW_READ_MASK));
153 bool hw_cam_write = usage & GRALLOC_USAGE_HW_CAMERA_WRITE;
154 bool hw_cam_read = usage & GRALLOC_USAGE_HW_CAMERA_READ;
155 bool hw_vid_enc_read = usage & GRALLOC_USAGE_HW_VIDEO_ENCODER;
156
157 // Pick the right concrete pixel format given the endpoints as encoded in
158 // the usage bits. Every end-point pair needs explicit listing here.
159 if (format == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED) {
160 // Camera as producer
161 if (usage & GRALLOC_USAGE_HW_CAMERA_WRITE) {
162 if (usage & GRALLOC_USAGE_HW_TEXTURE) {
163 // Camera-to-display is RGBA
164 format = HAL_PIXEL_FORMAT_RGBA_8888;
165 } else if (usage & GRALLOC_USAGE_HW_VIDEO_ENCODER) {
166 // Camera-to-encoder is NV21
167 format = HAL_PIXEL_FORMAT_YCrCb_420_SP;
168 } else if ((usage & GRALLOC_USAGE_HW_CAMERA_MASK) ==
169 GRALLOC_USAGE_HW_CAMERA_ZSL) {
170 // Camera-to-ZSL-queue is RGB_888
171 format = HAL_PIXEL_FORMAT_RGB_888;
172 }
173 }
174
175 if (format == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED) {
176 ALOGE("gralloc_alloc: Requested auto format selection, "
177 "but no known format for this usage: %d x %d, usage %x",
178 w, h, usage);
179 return -EINVAL;
180 }
181 }
182
183 bool yuv_format = false;
184
185 int ashmem_size = 0;
186 int stride = w;
187
188 GLenum glFormat = 0;
189 GLenum glType = 0;
190
191 int bpp = 0;
192 int align = 1;
193 switch (format) {
194 case HAL_PIXEL_FORMAT_RGBA_8888:
195 case HAL_PIXEL_FORMAT_RGBX_8888:
196 case HAL_PIXEL_FORMAT_BGRA_8888:
197 bpp = 4;
198 glFormat = GL_RGBA;
199 glType = GL_UNSIGNED_BYTE;
200 break;
201 case HAL_PIXEL_FORMAT_RGB_888:
202 bpp = 3;
203 glFormat = GL_RGB;
204 glType = GL_UNSIGNED_BYTE;
205 break;
206 case HAL_PIXEL_FORMAT_RGB_565:
207 bpp = 2;
208 glFormat = GL_RGB;
209 glType = GL_UNSIGNED_SHORT_5_6_5;
210 break;
211 case HAL_PIXEL_FORMAT_RGBA_5551:
212 bpp = 2;
213 glFormat = GL_RGB5_A1_OES;
214 glType = GL_UNSIGNED_SHORT_5_5_5_1;
215 break;
216 case HAL_PIXEL_FORMAT_RGBA_4444:
217 bpp = 2;
218 glFormat = GL_RGBA4_OES;
219 glType = GL_UNSIGNED_SHORT_4_4_4_4;
220 break;
221 case HAL_PIXEL_FORMAT_RAW_SENSOR:
222 bpp = 2;
223 align = 16*bpp;
224 if (! ((sw_read || hw_cam_read) && (sw_write || hw_cam_write) ) ) {
225 // Raw sensor data only goes between camera and CPU
226 return -EINVAL;
227 }
228 // Not expecting to actually create any GL surfaces for this
229 glFormat = GL_LUMINANCE;
230 glType = GL_UNSIGNED_SHORT;
231 break;
232 case HAL_PIXEL_FORMAT_BLOB:
233 bpp = 1;
234 if (! (sw_read && hw_cam_write) ) {
235 // Blob data cannot be used by HW other than camera emulator
236 return -EINVAL;
237 }
238 // Not expecting to actually create any GL surfaces for this
239 glFormat = GL_LUMINANCE;
240 glType = GL_UNSIGNED_BYTE;
241 break;
242 case HAL_PIXEL_FORMAT_YCrCb_420_SP:
243 align = 1;
244 bpp = 1; // per-channel bpp
245 yuv_format = true;
246 // Not expecting to actually create any GL surfaces for this
247 break;
248 case HAL_PIXEL_FORMAT_YV12:
249 align = 16;
250 bpp = 1; // per-channel bpp
251 yuv_format = true;
252 // Not expecting to actually create any GL surfaces for this
253 break;
254 default:
255 ALOGE("gralloc_alloc: Unknown format %d", format);
256 return -EINVAL;
257 }
258
259 if (usage & GRALLOC_USAGE_HW_FB) {
260 // keep space for postCounter
261 ashmem_size += sizeof(uint32_t);
262 }
263
264 if (sw_read || sw_write || hw_cam_write || hw_vid_enc_read) {
265 // keep space for image on guest memory if SW access is needed
266 // or if the camera is doing writing
267 if (yuv_format) {
268 size_t yStride = (w*bpp + (align - 1)) & ~(align-1);
269 size_t uvStride = (yStride / 2 + (align - 1)) & ~(align-1);
270 size_t uvHeight = h / 2;
271 ashmem_size += yStride * h + 2 * (uvHeight * uvStride);
272 stride = yStride / bpp;
273 } else {
274 size_t bpr = (w*bpp + (align-1)) & ~(align-1);
275 ashmem_size += (bpr * h);
276 stride = bpr / bpp;
277 }
278 }
279
280 D("gralloc_alloc format=%d, ashmem_size=%d, stride=%d, tid %d\n", format,
281 ashmem_size, stride, gettid());
282
283 //
284 // Allocate space in ashmem if needed
285 //
286 int fd = -1;
287 if (ashmem_size > 0) {
288 // round to page size;
289 ashmem_size = (ashmem_size + (PAGE_SIZE-1)) & ~(PAGE_SIZE-1);
290
291 fd = ashmem_create_region("gralloc-buffer", ashmem_size);
292 if (fd < 0) {
293 ALOGE("gralloc_alloc failed to create ashmem region: %s\n",
294 strerror(errno));
295 return -errno;
296 }
297 }
298
299 cb_handle_t *cb = new cb_handle_t(fd, ashmem_size, usage,
300 w, h, format, glFormat, glType);
301
302 if (ashmem_size > 0) {
303 //
304 // map ashmem region if exist
305 //
306 void *vaddr;
307 int err = map_buffer(cb, &vaddr);
308 if (err) {
309 close(fd);
310 delete cb;
311 return err;
312 }
313
314 cb->setFd(fd);
315 }
316
317 //
318 // Allocate ColorBuffer handle on the host (only if h/w access is allowed)
319 // Only do this for some h/w usages, not all.
320 //
321 if (usage & (GRALLOC_USAGE_HW_TEXTURE | GRALLOC_USAGE_HW_RENDER |
322 GRALLOC_USAGE_HW_2D | GRALLOC_USAGE_HW_COMPOSER |
323 GRALLOC_USAGE_HW_FB) ) {
324 DEFINE_HOST_CONNECTION;
325 if (hostCon && rcEnc) {
326 cb->hostHandle = rcEnc->rcCreateColorBuffer(rcEnc, w, h, glFormat);
327 D("Created host ColorBuffer 0x%x\n", cb->hostHandle);
328 }
329
330 if (!cb->hostHandle) {
331 // Could not create colorbuffer on host !!!
332 close(fd);
333 delete cb;
334 return -EIO;
335 }
336 }
337
338 //
339 // alloc succeeded - insert the allocated handle to the allocated list
340 //
341 AllocListNode *node = new AllocListNode();
342 pthread_mutex_lock(&grdev->lock);
343 node->handle = cb;
344 node->next = grdev->allocListHead;
345 node->prev = NULL;
346 if (grdev->allocListHead) {
347 grdev->allocListHead->prev = node;
348 }
349 grdev->allocListHead = node;
350 pthread_mutex_unlock(&grdev->lock);
351
352 *pHandle = cb;
353 *pStride = stride;
354 return 0;
355 }
356
gralloc_free(alloc_device_t * dev,buffer_handle_t handle)357 static int gralloc_free(alloc_device_t* dev,
358 buffer_handle_t handle)
359 {
360 const cb_handle_t *cb = (const cb_handle_t *)handle;
361 if (!cb_handle_t::validate((cb_handle_t*)cb)) {
362 ERR("gralloc_free: invalid handle");
363 return -EINVAL;
364 }
365
366 if (cb->hostHandle != 0) {
367 DEFINE_AND_VALIDATE_HOST_CONNECTION;
368 D("Closing host ColorBuffer 0x%x\n", cb->hostHandle);
369 rcEnc->rcCloseColorBuffer(rcEnc, cb->hostHandle);
370 }
371
372 //
373 // detach and unmap ashmem area if present
374 //
375 if (cb->fd > 0) {
376 if (cb->ashmemSize > 0 && cb->ashmemBase) {
377 munmap((void *)cb->ashmemBase, cb->ashmemSize);
378 }
379 close(cb->fd);
380 }
381
382 // remove it from the allocated list
383 gralloc_device_t *grdev = (gralloc_device_t *)dev;
384 pthread_mutex_lock(&grdev->lock);
385 AllocListNode *n = grdev->allocListHead;
386 while( n && n->handle != cb ) {
387 n = n->next;
388 }
389 if (n) {
390 // buffer found on list - remove it from list
391 if (n->next) {
392 n->next->prev = n->prev;
393 }
394 if (n->prev) {
395 n->prev->next = n->next;
396 }
397 else {
398 grdev->allocListHead = n->next;
399 }
400
401 delete n;
402 }
403 pthread_mutex_unlock(&grdev->lock);
404
405 delete cb;
406
407 return 0;
408 }
409
gralloc_device_close(struct hw_device_t * dev)410 static int gralloc_device_close(struct hw_device_t *dev)
411 {
412 gralloc_device_t* d = reinterpret_cast<gralloc_device_t*>(dev);
413 if (d) {
414
415 // free still allocated buffers
416 while( d->allocListHead != NULL ) {
417 gralloc_free(&d->device, d->allocListHead->handle);
418 }
419
420 // free device
421 free(d);
422 }
423 return 0;
424 }
425
fb_compositionComplete(struct framebuffer_device_t * dev)426 static int fb_compositionComplete(struct framebuffer_device_t* dev)
427 {
428 return 0;
429 }
430
431 //
432 // Framebuffer device functions
433 //
fb_post(struct framebuffer_device_t * dev,buffer_handle_t buffer)434 static int fb_post(struct framebuffer_device_t* dev, buffer_handle_t buffer)
435 {
436 fb_device_t *fbdev = (fb_device_t *)dev;
437 cb_handle_t *cb = (cb_handle_t *)buffer;
438
439 if (!fbdev || !cb_handle_t::validate(cb) || !cb->canBePosted()) {
440 return -EINVAL;
441 }
442
443 // Make sure we have host connection
444 DEFINE_AND_VALIDATE_HOST_CONNECTION;
445
446 // increment the post count of the buffer
447 uint32_t *postCountPtr = (uint32_t *)cb->ashmemBase;
448 if (!postCountPtr) {
449 // This should not happen
450 return -EINVAL;
451 }
452 (*postCountPtr)++;
453
454 // send post request to host
455 rcEnc->rcFBPost(rcEnc, cb->hostHandle);
456 hostCon->flush();
457
458 return 0;
459 }
460
fb_setUpdateRect(struct framebuffer_device_t * dev,int l,int t,int w,int h)461 static int fb_setUpdateRect(struct framebuffer_device_t* dev,
462 int l, int t, int w, int h)
463 {
464 fb_device_t *fbdev = (fb_device_t *)dev;
465
466 if (!fbdev) {
467 return -EINVAL;
468 }
469
470 // Make sure we have host connection
471 DEFINE_AND_VALIDATE_HOST_CONNECTION;
472
473 // send request to host
474 // TODO: XXX - should be implemented
475 //rcEnc->rc_XXX
476
477 return 0;
478 }
479
fb_setSwapInterval(struct framebuffer_device_t * dev,int interval)480 static int fb_setSwapInterval(struct framebuffer_device_t* dev,
481 int interval)
482 {
483 fb_device_t *fbdev = (fb_device_t *)dev;
484
485 if (!fbdev) {
486 return -EINVAL;
487 }
488
489 // Make sure we have host connection
490 DEFINE_AND_VALIDATE_HOST_CONNECTION;
491
492 // send request to host
493 rcEnc->rcFBSetSwapInterval(rcEnc, interval);
494 hostCon->flush();
495
496 return 0;
497 }
498
fb_close(struct hw_device_t * dev)499 static int fb_close(struct hw_device_t *dev)
500 {
501 fb_device_t *fbdev = (fb_device_t *)dev;
502
503 delete fbdev;
504
505 return 0;
506 }
507
508
509 //
510 // gralloc module functions - refcount + locking interface
511 //
gralloc_register_buffer(gralloc_module_t const * module,buffer_handle_t handle)512 static int gralloc_register_buffer(gralloc_module_t const* module,
513 buffer_handle_t handle)
514 {
515 pthread_once(&sFallbackOnce, fallback_init);
516 if (sFallback != NULL) {
517 return sFallback->registerBuffer(sFallback, handle);
518 }
519
520 D("gralloc_register_buffer(%p) called", handle);
521
522 private_module_t *gr = (private_module_t *)module;
523 cb_handle_t *cb = (cb_handle_t *)handle;
524 if (!gr || !cb_handle_t::validate(cb)) {
525 ERR("gralloc_register_buffer(%p): invalid buffer", cb);
526 return -EINVAL;
527 }
528
529 if (cb->hostHandle != 0) {
530 DEFINE_AND_VALIDATE_HOST_CONNECTION;
531 D("Opening host ColorBuffer 0x%x\n", cb->hostHandle);
532 rcEnc->rcOpenColorBuffer(rcEnc, cb->hostHandle);
533 }
534
535 //
536 // if the color buffer has ashmem region and it is not mapped in this
537 // process map it now.
538 //
539 if (cb->ashmemSize > 0 && cb->mappedPid != getpid()) {
540 void *vaddr;
541 int err = map_buffer(cb, &vaddr);
542 if (err) {
543 ERR("gralloc_register_buffer(%p): map failed: %s", cb, strerror(-err));
544 return -err;
545 }
546 cb->mappedPid = getpid();
547 }
548
549 return 0;
550 }
551
gralloc_unregister_buffer(gralloc_module_t const * module,buffer_handle_t handle)552 static int gralloc_unregister_buffer(gralloc_module_t const* module,
553 buffer_handle_t handle)
554 {
555 if (sFallback != NULL) {
556 return sFallback->unregisterBuffer(sFallback, handle);
557 }
558
559 private_module_t *gr = (private_module_t *)module;
560 cb_handle_t *cb = (cb_handle_t *)handle;
561 if (!gr || !cb_handle_t::validate(cb)) {
562 ERR("gralloc_unregister_buffer(%p): invalid buffer", cb);
563 return -EINVAL;
564 }
565
566 if (cb->hostHandle != 0) {
567 DEFINE_AND_VALIDATE_HOST_CONNECTION;
568 D("Closing host ColorBuffer 0x%x\n", cb->hostHandle);
569 rcEnc->rcCloseColorBuffer(rcEnc, cb->hostHandle);
570 }
571
572 //
573 // unmap ashmem region if it was previously mapped in this process
574 // (through register_buffer)
575 //
576 if (cb->ashmemSize > 0 && cb->mappedPid == getpid()) {
577 void *vaddr;
578 int err = munmap((void *)cb->ashmemBase, cb->ashmemSize);
579 if (err) {
580 ERR("gralloc_unregister_buffer(%p): unmap failed", cb);
581 return -EINVAL;
582 }
583 cb->ashmemBase = NULL;
584 cb->mappedPid = 0;
585 }
586
587 D("gralloc_unregister_buffer(%p) done\n", cb);
588
589 return 0;
590 }
591
gralloc_lock(gralloc_module_t const * module,buffer_handle_t handle,int usage,int l,int t,int w,int h,void ** vaddr)592 static int gralloc_lock(gralloc_module_t const* module,
593 buffer_handle_t handle, int usage,
594 int l, int t, int w, int h,
595 void** vaddr)
596 {
597 if (sFallback != NULL) {
598 return sFallback->lock(sFallback, handle, usage, l, t, w, h, vaddr);
599 }
600
601 private_module_t *gr = (private_module_t *)module;
602 cb_handle_t *cb = (cb_handle_t *)handle;
603 if (!gr || !cb_handle_t::validate(cb)) {
604 ALOGE("gralloc_lock bad handle\n");
605 return -EINVAL;
606 }
607
608 // Validate usage,
609 // 1. cannot be locked for hw access
610 // 2. lock for either sw read or write.
611 // 3. locked sw access must match usage during alloc time.
612 bool sw_read = (0 != (usage & GRALLOC_USAGE_SW_READ_MASK));
613 bool sw_write = (0 != (usage & GRALLOC_USAGE_SW_WRITE_MASK));
614 bool hw_read = (usage & GRALLOC_USAGE_HW_TEXTURE);
615 bool hw_write = (usage & GRALLOC_USAGE_HW_RENDER);
616 bool hw_vid_enc_read = (usage & GRALLOC_USAGE_HW_VIDEO_ENCODER);
617 bool hw_cam_write = (usage & GRALLOC_USAGE_HW_CAMERA_WRITE);
618 bool hw_cam_read = (usage & GRALLOC_USAGE_HW_CAMERA_READ);
619 bool sw_read_allowed = (0 != (cb->usage & GRALLOC_USAGE_SW_READ_MASK));
620 bool sw_write_allowed = (0 != (cb->usage & GRALLOC_USAGE_SW_WRITE_MASK));
621
622 if ( (hw_read || hw_write) ||
623 (!sw_read && !sw_write &&
624 !hw_cam_write && !hw_cam_read &&
625 !hw_vid_enc_read) ||
626 (sw_read && !sw_read_allowed) ||
627 (sw_write && !sw_write_allowed) ) {
628 ALOGE("gralloc_lock usage mismatch usage=0x%x cb->usage=0x%x\n", usage,
629 cb->usage);
630 return -EINVAL;
631 }
632
633 EGLint postCount = 0;
634 void *cpu_addr = NULL;
635
636 //
637 // make sure ashmem area is mapped if needed
638 //
639 if (cb->canBePosted() || sw_read || sw_write ||
640 hw_cam_write || hw_cam_read ||
641 hw_vid_enc_read) {
642 if (cb->ashmemBasePid != getpid() || !cb->ashmemBase) {
643 return -EACCES;
644 }
645
646 if (cb->canBePosted()) {
647 postCount = *((int *)cb->ashmemBase);
648 cpu_addr = (void *)(cb->ashmemBase + sizeof(int));
649 }
650 else {
651 cpu_addr = (void *)(cb->ashmemBase);
652 }
653 }
654
655 if (cb->hostHandle) {
656 // Make sure we have host connection
657 DEFINE_AND_VALIDATE_HOST_CONNECTION;
658
659 //
660 // flush color buffer write cache on host and get its sync status.
661 //
662 int hostSyncStatus = rcEnc->rcColorBufferCacheFlush(rcEnc, cb->hostHandle,
663 postCount,
664 sw_read);
665 if (hostSyncStatus < 0) {
666 // host failed the color buffer sync - probably since it was already
667 // locked for write access. fail the lock.
668 ALOGE("gralloc_lock cacheFlush failed postCount=%d sw_read=%d\n",
669 postCount, sw_read);
670 return -EBUSY;
671 }
672
673 }
674
675 //
676 // is virtual address required ?
677 //
678 if (sw_read || sw_write || hw_cam_write || hw_cam_read || hw_vid_enc_read) {
679 *vaddr = cpu_addr;
680 }
681
682 if (sw_write || hw_cam_write) {
683 //
684 // Keep locked region if locked for s/w write access.
685 //
686 cb->lockedLeft = l;
687 cb->lockedTop = t;
688 cb->lockedWidth = w;
689 cb->lockedHeight = h;
690 }
691
692 DD("gralloc_lock success. vaddr: %p, *vaddr: %p, usage: %x, cpu_addr: %p",
693 vaddr, vaddr ? *vaddr : 0, usage, cpu_addr);
694
695 return 0;
696 }
697
gralloc_unlock(gralloc_module_t const * module,buffer_handle_t handle)698 static int gralloc_unlock(gralloc_module_t const* module,
699 buffer_handle_t handle)
700 {
701 if (sFallback != NULL) {
702 return sFallback->unlock(sFallback, handle);
703 }
704
705 private_module_t *gr = (private_module_t *)module;
706 cb_handle_t *cb = (cb_handle_t *)handle;
707 if (!gr || !cb_handle_t::validate(cb)) {
708 return -EINVAL;
709 }
710
711 //
712 // if buffer was locked for s/w write, we need to update the host with
713 // the updated data
714 //
715 if (cb->lockedWidth > 0 && cb->lockedHeight > 0 && cb->hostHandle) {
716
717 // Make sure we have host connection
718 DEFINE_AND_VALIDATE_HOST_CONNECTION;
719
720 void *cpu_addr;
721 if (cb->canBePosted()) {
722 cpu_addr = (void *)(cb->ashmemBase + sizeof(int));
723 }
724 else {
725 cpu_addr = (void *)(cb->ashmemBase);
726 }
727
728 if (cb->lockedWidth < cb->width || cb->lockedHeight < cb->height) {
729 int bpp = glUtilsPixelBitSize(cb->glFormat, cb->glType) >> 3;
730 char *tmpBuf = new char[cb->lockedWidth * cb->lockedHeight * bpp];
731
732 int dst_line_len = cb->lockedWidth * bpp;
733 int src_line_len = cb->width * bpp;
734 char *src = (char *)cpu_addr + cb->lockedTop*src_line_len + cb->lockedLeft*bpp;
735 char *dst = tmpBuf;
736 for (int y=0; y<cb->lockedHeight; y++) {
737 memcpy(dst, src, dst_line_len);
738 src += src_line_len;
739 dst += dst_line_len;
740 }
741
742 rcEnc->rcUpdateColorBuffer(rcEnc, cb->hostHandle,
743 cb->lockedLeft, cb->lockedTop,
744 cb->lockedWidth, cb->lockedHeight,
745 cb->glFormat, cb->glType,
746 tmpBuf);
747
748 delete [] tmpBuf;
749 }
750 else {
751 rcEnc->rcUpdateColorBuffer(rcEnc, cb->hostHandle, 0, 0,
752 cb->width, cb->height,
753 cb->glFormat, cb->glType,
754 cpu_addr);
755 }
756 }
757
758 cb->lockedWidth = cb->lockedHeight = 0;
759 return 0;
760 }
761
762
gralloc_device_open(const hw_module_t * module,const char * name,hw_device_t ** device)763 static int gralloc_device_open(const hw_module_t* module,
764 const char* name,
765 hw_device_t** device)
766 {
767 int status = -EINVAL;
768
769 D("gralloc_device_open %s\n", name);
770
771 pthread_once( &sFallbackOnce, fallback_init );
772 if (sFallback != NULL) {
773 return sFallback->common.methods->open(&sFallback->common, name, device);
774 }
775
776 if (!strcmp(name, GRALLOC_HARDWARE_GPU0)) {
777
778 // Create host connection and keep it in the TLS.
779 // return error if connection with host can not be established
780 HostConnection *hostCon = HostConnection::get();
781 if (!hostCon) {
782 ALOGE("gralloc: failed to get host connection while opening %s\n", name);
783 return -EIO;
784 }
785
786 //
787 // Allocate memory for the gralloc device (alloc interface)
788 //
789 gralloc_device_t *dev;
790 dev = (gralloc_device_t*)malloc(sizeof(gralloc_device_t));
791 if (NULL == dev) {
792 return -ENOMEM;
793 }
794
795 // Initialize our device structure
796 //
797 dev->device.common.tag = HARDWARE_DEVICE_TAG;
798 dev->device.common.version = 0;
799 dev->device.common.module = const_cast<hw_module_t*>(module);
800 dev->device.common.close = gralloc_device_close;
801
802 dev->device.alloc = gralloc_alloc;
803 dev->device.free = gralloc_free;
804 dev->allocListHead = NULL;
805 pthread_mutex_init(&dev->lock, NULL);
806
807 *device = &dev->device.common;
808 status = 0;
809 }
810 else if (!strcmp(name, GRALLOC_HARDWARE_FB0)) {
811
812 // return error if connection with host can not be established
813 DEFINE_AND_VALIDATE_HOST_CONNECTION;
814
815 //
816 // Query the host for Framebuffer attributes
817 //
818 D("gralloc: query Frabuffer attribs\n");
819 EGLint width = rcEnc->rcGetFBParam(rcEnc, FB_WIDTH);
820 D("gralloc: width=%d\n", width);
821 EGLint height = rcEnc->rcGetFBParam(rcEnc, FB_HEIGHT);
822 D("gralloc: height=%d\n", height);
823 EGLint xdpi = rcEnc->rcGetFBParam(rcEnc, FB_XDPI);
824 D("gralloc: xdpi=%d\n", xdpi);
825 EGLint ydpi = rcEnc->rcGetFBParam(rcEnc, FB_YDPI);
826 D("gralloc: ydpi=%d\n", ydpi);
827 EGLint fps = rcEnc->rcGetFBParam(rcEnc, FB_FPS);
828 D("gralloc: fps=%d\n", fps);
829 EGLint min_si = rcEnc->rcGetFBParam(rcEnc, FB_MIN_SWAP_INTERVAL);
830 D("gralloc: min_swap=%d\n", min_si);
831 EGLint max_si = rcEnc->rcGetFBParam(rcEnc, FB_MAX_SWAP_INTERVAL);
832 D("gralloc: max_swap=%d\n", max_si);
833
834 //
835 // Allocate memory for the framebuffer device
836 //
837 fb_device_t *dev;
838 dev = (fb_device_t*)malloc(sizeof(fb_device_t));
839 if (NULL == dev) {
840 return -ENOMEM;
841 }
842 memset(dev, 0, sizeof(fb_device_t));
843
844 // Initialize our device structure
845 //
846 dev->device.common.tag = HARDWARE_DEVICE_TAG;
847 dev->device.common.version = 0;
848 dev->device.common.module = const_cast<hw_module_t*>(module);
849 dev->device.common.close = fb_close;
850 dev->device.setSwapInterval = fb_setSwapInterval;
851 dev->device.post = fb_post;
852 dev->device.setUpdateRect = 0; //fb_setUpdateRect;
853 dev->device.compositionComplete = fb_compositionComplete; //XXX: this is a dummy
854
855 const_cast<uint32_t&>(dev->device.flags) = 0;
856 const_cast<uint32_t&>(dev->device.width) = width;
857 const_cast<uint32_t&>(dev->device.height) = height;
858 const_cast<int&>(dev->device.stride) = width;
859 const_cast<int&>(dev->device.format) = HAL_PIXEL_FORMAT_RGBA_8888;
860 const_cast<float&>(dev->device.xdpi) = xdpi;
861 const_cast<float&>(dev->device.ydpi) = ydpi;
862 const_cast<float&>(dev->device.fps) = fps;
863 const_cast<int&>(dev->device.minSwapInterval) = min_si;
864 const_cast<int&>(dev->device.maxSwapInterval) = max_si;
865 *device = &dev->device.common;
866
867 status = 0;
868 }
869
870 return status;
871 }
872
873 //
874 // define the HMI symbol - our module interface
875 //
876 static struct hw_module_methods_t gralloc_module_methods = {
877 open: gralloc_device_open
878 };
879
880 struct private_module_t HAL_MODULE_INFO_SYM = {
881 base: {
882 common: {
883 tag: HARDWARE_MODULE_TAG,
884 version_major: 1,
885 version_minor: 0,
886 id: GRALLOC_HARDWARE_MODULE_ID,
887 name: "Graphics Memory Allocator Module",
888 author: "The Android Open Source Project",
889 methods: &gralloc_module_methods,
890 dso: NULL,
891 reserved: {0, }
892 },
893 registerBuffer: gralloc_register_buffer,
894 unregisterBuffer: gralloc_unregister_buffer,
895 lock: gralloc_lock,
896 unlock: gralloc_unlock,
897 perform: NULL,
898 reserved_proc : {NULL, }
899 }
900 };
901
902 /* This function is called once to detect whether the emulator supports
903 * GPU emulation (this is done by looking at the qemu.gles kernel
904 * parameter, which must be > 0 if this is the case).
905 *
906 * If not, then load gralloc.default instead as a fallback.
907 */
908 static void
fallback_init(void)909 fallback_init(void)
910 {
911 char prop[PROPERTY_VALUE_MAX];
912 void* module;
913
914 property_get("ro.kernel.qemu.gles", prop, "0");
915 if (atoi(prop) > 0) {
916 return;
917 }
918 ALOGD("Emulator without GPU emulation detected.");
919 module = dlopen("/system/lib/hw/gralloc.default.so", RTLD_LAZY|RTLD_LOCAL);
920 if (module != NULL) {
921 sFallback = reinterpret_cast<gralloc_module_t*>(dlsym(module, HAL_MODULE_INFO_SYM_AS_STR));
922 if (sFallback == NULL) {
923 dlclose(module);
924 }
925 }
926 if (sFallback == NULL) {
927 ALOGE("Could not find software fallback module!?");
928 }
929 }
930