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,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_RAW_SENSOR:
221 bpp = 2;
222 break;
223 default:
224 return -EINVAL;
225 }
226 size_t bpr = (w*bpp + (align-1)) & ~(align-1);
227 size = bpr * h;
228 stride = bpr / bpp;
229
230 int err;
231 if (usage & GRALLOC_USAGE_HW_FB) {
232 err = gralloc_alloc_framebuffer(dev, size, usage, pHandle);
233 } else {
234 err = gralloc_alloc_buffer(dev, size, usage, pHandle);
235 }
236
237 if (err < 0) {
238 return err;
239 }
240
241 *pStride = stride;
242 return 0;
243 }
244
gralloc_free(alloc_device_t * dev,buffer_handle_t handle)245 static int gralloc_free(alloc_device_t* dev,
246 buffer_handle_t handle)
247 {
248 if (private_handle_t::validate(handle) < 0)
249 return -EINVAL;
250
251 private_handle_t const* hnd = reinterpret_cast<private_handle_t const*>(handle);
252 if (hnd->flags & private_handle_t::PRIV_FLAGS_FRAMEBUFFER) {
253 // free this buffer
254 private_module_t* m = reinterpret_cast<private_module_t*>(
255 dev->common.module);
256 const size_t bufferSize = m->finfo.line_length * m->info.yres;
257 int index = (hnd->base - m->framebuffer->base) / bufferSize;
258 m->bufferMask &= ~(1<<index);
259 } else {
260 gralloc_module_t* module = reinterpret_cast<gralloc_module_t*>(
261 dev->common.module);
262 terminateBuffer(module, const_cast<private_handle_t*>(hnd));
263 }
264
265 close(hnd->fd);
266 delete hnd;
267 return 0;
268 }
269
270 /*****************************************************************************/
271
gralloc_close(struct hw_device_t * dev)272 static int gralloc_close(struct hw_device_t *dev)
273 {
274 gralloc_context_t* ctx = reinterpret_cast<gralloc_context_t*>(dev);
275 if (ctx) {
276 /* TODO: keep a list of all buffer_handle_t created, and free them
277 * all here.
278 */
279 free(ctx);
280 }
281 return 0;
282 }
283
gralloc_device_open(const hw_module_t * module,const char * name,hw_device_t ** device)284 int gralloc_device_open(const hw_module_t* module, const char* name,
285 hw_device_t** device)
286 {
287 int status = -EINVAL;
288 if (!strcmp(name, GRALLOC_HARDWARE_GPU0)) {
289 gralloc_context_t *dev;
290 dev = (gralloc_context_t*)malloc(sizeof(*dev));
291
292 /* initialize our state here */
293 memset(dev, 0, sizeof(*dev));
294
295 /* initialize the procs */
296 dev->device.common.tag = HARDWARE_DEVICE_TAG;
297 dev->device.common.version = 0;
298 dev->device.common.module = const_cast<hw_module_t*>(module);
299 dev->device.common.close = gralloc_close;
300
301 dev->device.alloc = gralloc_alloc;
302 dev->device.free = gralloc_free;
303
304 *device = &dev->device.common;
305 status = 0;
306 } else {
307 status = fb_device_open(module, name, device);
308 }
309 return status;
310 }
311