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 <cutils/ashmem.h>
31 #include <cutils/log.h>
32 #include <cutils/atomic.h>
33
34 #include <hardware/hardware.h>
35 #include <hardware/gralloc.h>
36
37 #include "gralloc_priv.h"
38 #include "gr.h"
39
40 /*****************************************************************************/
41
42 struct gralloc_context_t {
43 alloc_device_t device;
44 /* our private data here */
45 };
46
47 static int gralloc_alloc_buffer(alloc_device_t* dev,
48 size_t size, int usage, buffer_handle_t* pHandle);
49
50 /*****************************************************************************/
51
52 int fb_device_open(const hw_module_t* module, const char* name,
53 hw_device_t** device);
54
55 static int gralloc_device_open(const hw_module_t* module, const char* name,
56 hw_device_t** device);
57
58 extern int gralloc_lock(gralloc_module_t const* module,
59 buffer_handle_t handle, int usage,
60 int l, int t, int w, int h,
61 void** vaddr);
62
63 extern int gralloc_unlock(gralloc_module_t const* module,
64 buffer_handle_t handle);
65
66 extern int gralloc_register_buffer(gralloc_module_t const* module,
67 buffer_handle_t handle);
68
69 extern int gralloc_unregister_buffer(gralloc_module_t const* module,
70 buffer_handle_t handle);
71
72 /*****************************************************************************/
73
74 static struct hw_module_methods_t gralloc_module_methods = {
75 open: gralloc_device_open
76 };
77
78 struct private_module_t HAL_MODULE_INFO_SYM = {
79 base: {
80 common: {
81 tag: HARDWARE_MODULE_TAG,
82 version_major: 1,
83 version_minor: 0,
84 id: GRALLOC_HARDWARE_MODULE_ID,
85 name: "Graphics Memory Allocator Module",
86 author: "The Android Open Source Project",
87 methods: &gralloc_module_methods
88 },
89 registerBuffer: gralloc_register_buffer,
90 unregisterBuffer: gralloc_unregister_buffer,
91 lock: gralloc_lock,
92 unlock: gralloc_unlock,
93 },
94 framebuffer: 0,
95 flags: 0,
96 numBuffers: 0,
97 bufferMask: 0,
98 lock: PTHREAD_MUTEX_INITIALIZER,
99 currentBuffer: 0,
100 };
101
102 /*****************************************************************************/
103
gralloc_alloc_framebuffer_locked(alloc_device_t * dev,size_t size,int usage,buffer_handle_t * pHandle)104 static int gralloc_alloc_framebuffer_locked(alloc_device_t* dev,
105 size_t size, int usage, buffer_handle_t* pHandle)
106 {
107 private_module_t* m = reinterpret_cast<private_module_t*>(
108 dev->common.module);
109
110 // allocate the framebuffer
111 if (m->framebuffer == NULL) {
112 // initialize the framebuffer, the framebuffer is mapped once
113 // and forever.
114 int err = mapFrameBufferLocked(m);
115 if (err < 0) {
116 return err;
117 }
118 }
119
120 const uint32_t bufferMask = m->bufferMask;
121 const uint32_t numBuffers = m->numBuffers;
122 const size_t bufferSize = m->finfo.line_length * m->info.yres;
123 if (numBuffers == 1) {
124 // If we have only one buffer, we never use page-flipping. Instead,
125 // we return a regular buffer which will be memcpy'ed to the main
126 // screen when post is called.
127 int newUsage = (usage & ~GRALLOC_USAGE_HW_FB) | GRALLOC_USAGE_HW_2D;
128 return gralloc_alloc_buffer(dev, bufferSize, newUsage, pHandle);
129 }
130
131 if (bufferMask >= ((1LU<<numBuffers)-1)) {
132 // We ran out of buffers.
133 return -ENOMEM;
134 }
135
136 // create a "fake" handles for it
137 intptr_t vaddr = intptr_t(m->framebuffer->base);
138 private_handle_t* hnd = new private_handle_t(dup(m->framebuffer->fd), size,
139 private_handle_t::PRIV_FLAGS_FRAMEBUFFER);
140
141 // find a free slot
142 for (uint32_t i=0 ; i<numBuffers ; i++) {
143 if ((bufferMask & (1LU<<i)) == 0) {
144 m->bufferMask |= (1LU<<i);
145 break;
146 }
147 vaddr += bufferSize;
148 }
149
150 hnd->base = vaddr;
151 hnd->offset = vaddr - intptr_t(m->framebuffer->base);
152 *pHandle = hnd;
153
154 return 0;
155 }
156
gralloc_alloc_framebuffer(alloc_device_t * dev,size_t size,int usage,buffer_handle_t * pHandle)157 static int gralloc_alloc_framebuffer(alloc_device_t* dev,
158 size_t size, int usage, buffer_handle_t* pHandle)
159 {
160 private_module_t* m = reinterpret_cast<private_module_t*>(
161 dev->common.module);
162 pthread_mutex_lock(&m->lock);
163 int err = gralloc_alloc_framebuffer_locked(dev, size, usage, pHandle);
164 pthread_mutex_unlock(&m->lock);
165 return err;
166 }
167
gralloc_alloc_buffer(alloc_device_t * dev,size_t size,int usage,buffer_handle_t * pHandle)168 static int gralloc_alloc_buffer(alloc_device_t* dev,
169 size_t size, int usage, buffer_handle_t* pHandle)
170 {
171 int err = 0;
172 int fd = -1;
173
174 size = roundUpToPageSize(size);
175
176 fd = ashmem_create_region("gralloc-buffer", size);
177 if (fd < 0) {
178 ALOGE("couldn't create ashmem (%s)", strerror(-errno));
179 err = -errno;
180 }
181
182 if (err == 0) {
183 private_handle_t* hnd = new private_handle_t(fd, size, 0);
184 gralloc_module_t* module = reinterpret_cast<gralloc_module_t*>(
185 dev->common.module);
186 err = mapBuffer(module, hnd);
187 if (err == 0) {
188 *pHandle = hnd;
189 }
190 }
191
192 ALOGE_IF(err, "gralloc failed err=%s", strerror(-err));
193
194 return err;
195 }
196
197 /*****************************************************************************/
198
gralloc_alloc(alloc_device_t * dev,int w,int h,int format,int usage,buffer_handle_t * pHandle,int * pStride)199 static int gralloc_alloc(alloc_device_t* dev,
200 int w, int h, int format, int usage,
201 buffer_handle_t* pHandle, int* pStride)
202 {
203 if (!pHandle || !pStride)
204 return -EINVAL;
205
206 size_t size, stride;
207
208 int align = 4;
209 int bpp = 0;
210 switch (format) {
211 case HAL_PIXEL_FORMAT_RGBA_8888:
212 case HAL_PIXEL_FORMAT_RGBX_8888:
213 case HAL_PIXEL_FORMAT_BGRA_8888:
214 bpp = 4;
215 break;
216 case HAL_PIXEL_FORMAT_RGB_888:
217 bpp = 3;
218 break;
219 case HAL_PIXEL_FORMAT_RGB_565:
220 case HAL_PIXEL_FORMAT_RGBA_5551:
221 case HAL_PIXEL_FORMAT_RGBA_4444:
222 bpp = 2;
223 break;
224 default:
225 return -EINVAL;
226 }
227 size_t bpr = (w*bpp + (align-1)) & ~(align-1);
228 size = bpr * h;
229 stride = bpr / bpp;
230
231 int err;
232 if (usage & GRALLOC_USAGE_HW_FB) {
233 err = gralloc_alloc_framebuffer(dev, size, usage, pHandle);
234 } else {
235 err = gralloc_alloc_buffer(dev, size, usage, pHandle);
236 }
237
238 if (err < 0) {
239 return err;
240 }
241
242 *pStride = stride;
243 return 0;
244 }
245
gralloc_free(alloc_device_t * dev,buffer_handle_t handle)246 static int gralloc_free(alloc_device_t* dev,
247 buffer_handle_t handle)
248 {
249 if (private_handle_t::validate(handle) < 0)
250 return -EINVAL;
251
252 private_handle_t const* hnd = reinterpret_cast<private_handle_t const*>(handle);
253 if (hnd->flags & private_handle_t::PRIV_FLAGS_FRAMEBUFFER) {
254 // free this buffer
255 private_module_t* m = reinterpret_cast<private_module_t*>(
256 dev->common.module);
257 const size_t bufferSize = m->finfo.line_length * m->info.yres;
258 int index = (hnd->base - m->framebuffer->base) / bufferSize;
259 m->bufferMask &= ~(1<<index);
260 } else {
261 gralloc_module_t* module = reinterpret_cast<gralloc_module_t*>(
262 dev->common.module);
263 terminateBuffer(module, const_cast<private_handle_t*>(hnd));
264 }
265
266 close(hnd->fd);
267 delete hnd;
268 return 0;
269 }
270
271 /*****************************************************************************/
272
gralloc_close(struct hw_device_t * dev)273 static int gralloc_close(struct hw_device_t *dev)
274 {
275 gralloc_context_t* ctx = reinterpret_cast<gralloc_context_t*>(dev);
276 if (ctx) {
277 /* TODO: keep a list of all buffer_handle_t created, and free them
278 * all here.
279 */
280 free(ctx);
281 }
282 return 0;
283 }
284
gralloc_device_open(const hw_module_t * module,const char * name,hw_device_t ** device)285 int gralloc_device_open(const hw_module_t* module, const char* name,
286 hw_device_t** device)
287 {
288 int status = -EINVAL;
289 if (!strcmp(name, GRALLOC_HARDWARE_GPU0)) {
290 gralloc_context_t *dev;
291 dev = (gralloc_context_t*)malloc(sizeof(*dev));
292
293 /* initialize our state here */
294 memset(dev, 0, sizeof(*dev));
295
296 /* initialize the procs */
297 dev->device.common.tag = HARDWARE_DEVICE_TAG;
298 dev->device.common.version = 0;
299 dev->device.common.module = const_cast<hw_module_t*>(module);
300 dev->device.common.close = gralloc_close;
301
302 dev->device.alloc = gralloc_alloc;
303 dev->device.free = gralloc_free;
304
305 *device = &dev->device.common;
306 status = 0;
307 } else {
308 status = fb_device_open(module, name, device);
309 }
310 return status;
311 }
312