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 42struct gralloc_context_t { 43 alloc_device_t device; 44 /* our private data here */ 45}; 46 47static int gralloc_alloc_buffer(alloc_device_t* dev, 48 size_t size, int usage, buffer_handle_t* pHandle); 49 50/*****************************************************************************/ 51 52int fb_device_open(const hw_module_t* module, const char* name, 53 hw_device_t** device); 54 55static int gralloc_device_open(const hw_module_t* module, const char* name, 56 hw_device_t** device); 57 58extern 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 63extern int gralloc_unlock(gralloc_module_t const* module, 64 buffer_handle_t handle); 65 66extern int gralloc_register_buffer(gralloc_module_t const* module, 67 buffer_handle_t handle); 68 69extern int gralloc_unregister_buffer(gralloc_module_t const* module, 70 buffer_handle_t handle); 71 72/*****************************************************************************/ 73 74static struct hw_module_methods_t gralloc_module_methods = { 75 open: gralloc_device_open 76}; 77 78struct 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 104static 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 157static 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 168static 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 199static 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 246static 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 273static 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 285int 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