1/* 2 * Copyright (C) 2010 The Android Open Source Project 3 * Copyright (c) 2011-2014 The Linux Foundation. All rights reserved. 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 18#include <limits.h> 19#include <unistd.h> 20#include <fcntl.h> 21#include <cutils/properties.h> 22#include <sys/mman.h> 23 24#include "gr.h" 25#include "gpu.h" 26#include "memalloc.h" 27#include "alloc_controller.h" 28#include <qdMetaData.h> 29 30using namespace gralloc; 31 32#define SZ_1M 0x100000 33#define SZ_2M 0x200000 34 35gpu_context_t::gpu_context_t(const private_module_t* module, 36 IAllocController* alloc_ctrl ) : 37 mAllocCtrl(alloc_ctrl) 38{ 39 // Zero out the alloc_device_t 40 memset(static_cast<alloc_device_t*>(this), 0, sizeof(alloc_device_t)); 41 42 // Initialize the procs 43 common.tag = HARDWARE_DEVICE_TAG; 44 common.version = 0; 45 common.module = const_cast<hw_module_t*>(&module->base.common); 46 common.close = gralloc_close; 47 alloc = gralloc_alloc; 48#ifdef QCOM_BSP 49 allocSize = gralloc_alloc_size; 50#endif 51 free = gralloc_free; 52 53} 54 55int gpu_context_t::gralloc_alloc_buffer(size_t size, int usage, 56 buffer_handle_t* pHandle, int bufferType, 57 int format, int width, int height) 58{ 59 int err = 0; 60 int flags = 0; 61 size = roundUpToPageSize(size); 62 alloc_data data; 63 data.offset = 0; 64 data.fd = -1; 65 data.base = 0; 66 if(format == HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED) 67 data.align = 8192; 68 else 69 data.align = getpagesize(); 70 71 /* force 1MB alignment selectively for secure buffers, MDP5 onwards */ 72#ifdef MDSS_TARGET 73 if (usage & GRALLOC_USAGE_PROTECTED) { 74 data.align = ALIGN((int) data.align, SZ_2M); 75 size = ALIGN(size, data.align); 76 } 77#endif 78 79 data.size = size; 80 data.pHandle = (uintptr_t) pHandle; 81 err = mAllocCtrl->allocate(data, usage); 82 83 if (!err) { 84 /* allocate memory for enhancement data */ 85 alloc_data eData; 86 eData.fd = -1; 87 eData.base = 0; 88 eData.offset = 0; 89 eData.size = ROUND_UP_PAGESIZE(sizeof(MetaData_t)); 90 eData.pHandle = data.pHandle; 91 eData.align = getpagesize(); 92 int eDataUsage = GRALLOC_USAGE_PRIVATE_SYSTEM_HEAP; 93 int eDataErr = mAllocCtrl->allocate(eData, eDataUsage); 94 ALOGE_IF(eDataErr, "gralloc failed for eDataErr=%s", 95 strerror(-eDataErr)); 96 97 if (usage & GRALLOC_USAGE_PRIVATE_EXTERNAL_ONLY) { 98 flags |= private_handle_t::PRIV_FLAGS_EXTERNAL_ONLY; 99 } 100 101 ColorSpace_t colorSpace = ITU_R_601; 102 flags |= private_handle_t::PRIV_FLAGS_ITU_R_601; 103 if (bufferType == BUFFER_TYPE_VIDEO) { 104 if (usage & GRALLOC_USAGE_HW_CAMERA_WRITE) { 105#ifndef MDSS_TARGET 106 colorSpace = ITU_R_601_FR; 107 flags |= private_handle_t::PRIV_FLAGS_ITU_R_601_FR; 108#else 109 // Per the camera spec ITU 709 format should be set only for 110 // video encoding. 111 // It should be set to ITU 601 full range format for any other 112 // camera buffer 113 // 114 if (usage & GRALLOC_USAGE_HW_CAMERA_MASK) { 115 if (usage & GRALLOC_USAGE_HW_VIDEO_ENCODER) { 116 flags |= private_handle_t::PRIV_FLAGS_ITU_R_709; 117 colorSpace = ITU_R_709; 118 } else { 119 flags |= private_handle_t::PRIV_FLAGS_ITU_R_601_FR; 120 colorSpace = ITU_R_601_FR; 121 } 122 } 123#endif 124 } 125 } 126 127 if (usage & GRALLOC_USAGE_HW_VIDEO_ENCODER ) { 128 flags |= private_handle_t::PRIV_FLAGS_VIDEO_ENCODER; 129 } 130 131 if (usage & GRALLOC_USAGE_HW_CAMERA_WRITE) { 132 flags |= private_handle_t::PRIV_FLAGS_CAMERA_WRITE; 133 } 134 135 if (usage & GRALLOC_USAGE_HW_CAMERA_READ) { 136 flags |= private_handle_t::PRIV_FLAGS_CAMERA_READ; 137 } 138 139 if (usage & GRALLOC_USAGE_HW_COMPOSER) { 140 flags |= private_handle_t::PRIV_FLAGS_HW_COMPOSER; 141 } 142 143 if (usage & GRALLOC_USAGE_HW_TEXTURE) { 144 flags |= private_handle_t::PRIV_FLAGS_HW_TEXTURE; 145 } 146 147 if(usage & GRALLOC_USAGE_PRIVATE_SECURE_DISPLAY) { 148 flags |= private_handle_t::PRIV_FLAGS_SECURE_DISPLAY; 149 } 150 151 if(isMacroTileEnabled(format, usage)) { 152 flags |= private_handle_t::PRIV_FLAGS_TILE_RENDERED; 153 } 154 155 flags |= data.allocType; 156 uintptr_t eBaseAddr = (uintptr_t)(eData.base) + eData.offset; 157 private_handle_t *hnd = new private_handle_t(data.fd, size, flags, 158 bufferType, format, width, height, eData.fd, eData.offset, 159 eBaseAddr); 160 161 hnd->offset = data.offset; 162 hnd->base = (uintptr_t)(data.base) + data.offset; 163 hnd->gpuaddr = 0; 164 setMetaData(hnd, UPDATE_COLOR_SPACE, (void*) &colorSpace); 165 166 *pHandle = hnd; 167 } 168 169 ALOGE_IF(err, "gralloc failed err=%s", strerror(-err)); 170 171 return err; 172} 173 174void gpu_context_t::getGrallocInformationFromFormat(int inputFormat, 175 int *bufferType) 176{ 177 *bufferType = BUFFER_TYPE_VIDEO; 178 179 if (inputFormat <= HAL_PIXEL_FORMAT_BGRA_8888) { 180 // RGB formats 181 *bufferType = BUFFER_TYPE_UI; 182 } else if ((inputFormat == HAL_PIXEL_FORMAT_R_8) || 183 (inputFormat == HAL_PIXEL_FORMAT_RG_88)) { 184 *bufferType = BUFFER_TYPE_UI; 185 } 186} 187 188int gpu_context_t::gralloc_alloc_framebuffer_locked(int usage, 189 buffer_handle_t* pHandle) 190{ 191 private_module_t* m = reinterpret_cast<private_module_t*>(common.module); 192 193 // we don't support framebuffer allocations with graphics heap flags 194 if (usage & GRALLOC_HEAP_MASK) { 195 return -EINVAL; 196 } 197 198 if (m->framebuffer == NULL) { 199 ALOGE("%s: Invalid framebuffer", __FUNCTION__); 200 return -EINVAL; 201 } 202 203 const size_t bufferMask = m->bufferMask; 204 const uint32_t numBuffers = m->numBuffers; 205 size_t bufferSize = m->finfo.line_length * m->info.yres; 206 207 //adreno needs FB size to be page aligned 208 bufferSize = roundUpToPageSize(bufferSize); 209 210 if (numBuffers == 1) { 211 // If we have only one buffer, we never use page-flipping. Instead, 212 // we return a regular buffer which will be memcpy'ed to the main 213 // screen when post is called. 214 int newUsage = (usage & ~GRALLOC_USAGE_HW_FB) | GRALLOC_USAGE_HW_2D; 215 return gralloc_alloc_buffer(bufferSize, newUsage, pHandle, BUFFER_TYPE_UI, 216 m->fbFormat, m->info.xres, m->info.yres); 217 } 218 219 if (bufferMask >= ((1LU<<numBuffers)-1)) { 220 // We ran out of buffers. 221 return -ENOMEM; 222 } 223 224 // create a "fake" handle for it 225 uintptr_t vaddr = uintptr_t(m->framebuffer->base); 226 private_handle_t* hnd = new private_handle_t( 227 dup(m->framebuffer->fd), bufferSize, 228 private_handle_t::PRIV_FLAGS_USES_PMEM | 229 private_handle_t::PRIV_FLAGS_FRAMEBUFFER, 230 BUFFER_TYPE_UI, m->fbFormat, m->info.xres, 231 m->info.yres); 232 233 // find a free slot 234 for (uint32_t i=0 ; i<numBuffers ; i++) { 235 if ((bufferMask & (1LU<<i)) == 0) { 236 m->bufferMask |= (1LU<<i); 237 break; 238 } 239 vaddr += bufferSize; 240 } 241 hnd->base = vaddr; 242 hnd->offset = vaddr - uintptr_t(m->framebuffer->base); 243 *pHandle = hnd; 244 return 0; 245} 246 247 248int gpu_context_t::gralloc_alloc_framebuffer(int usage, 249 buffer_handle_t* pHandle) 250{ 251 private_module_t* m = reinterpret_cast<private_module_t*>(common.module); 252 pthread_mutex_lock(&m->lock); 253 int err = gralloc_alloc_framebuffer_locked(usage, pHandle); 254 pthread_mutex_unlock(&m->lock); 255 return err; 256} 257 258int gpu_context_t::alloc_impl(int w, int h, int format, int usage, 259 buffer_handle_t* pHandle, int* pStride, 260 size_t bufferSize) { 261 if (!pHandle || !pStride) 262 return -EINVAL; 263 264 size_t size; 265 int alignedw, alignedh; 266 int grallocFormat = format; 267 int bufferType; 268 269 //If input format is HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED then based on 270 //the usage bits, gralloc assigns a format. 271 if(format == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED || 272 format == HAL_PIXEL_FORMAT_YCbCr_420_888) { 273 if(usage & GRALLOC_USAGE_HW_VIDEO_ENCODER) 274 grallocFormat = HAL_PIXEL_FORMAT_NV12_ENCODEABLE; //NV12 275 else if((usage & GRALLOC_USAGE_HW_CAMERA_MASK) 276 == GRALLOC_USAGE_HW_CAMERA_ZSL) 277 grallocFormat = HAL_PIXEL_FORMAT_NV21_ZSL; //NV21 ZSL 278 else if(usage & GRALLOC_USAGE_HW_CAMERA_READ) 279 grallocFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP; //NV21 280 else if(usage & GRALLOC_USAGE_HW_CAMERA_WRITE) 281 grallocFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP; //NV21 282 else if(usage & GRALLOC_USAGE_HW_COMPOSER) 283 grallocFormat = HAL_PIXEL_FORMAT_RGBA_8888; 284 //If flexible yuv is used for sw read/write, need map to NV21 285 else if(format == HAL_PIXEL_FORMAT_YCbCr_420_888 && 286 (usage & GRALLOC_USAGE_SW_WRITE_MASK || 287 usage & GRALLOC_USAGE_SW_READ_MASK)) { 288 grallocFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP; 289 } 290 } 291 292 getGrallocInformationFromFormat(grallocFormat, &bufferType); 293 size = getBufferSizeAndDimensions(w, h, grallocFormat, usage, alignedw, 294 alignedh); 295 296 if ((ssize_t)size <= 0) 297 return -EINVAL; 298 size = (bufferSize >= size)? bufferSize : size; 299 300 bool useFbMem = false; 301 char property[PROPERTY_VALUE_MAX]; 302 if((usage & GRALLOC_USAGE_HW_FB) && 303 (property_get("debug.gralloc.map_fb_memory", property, NULL) > 0) && 304 (!strncmp(property, "1", PROPERTY_VALUE_MAX ) || 305 (!strncasecmp(property,"true", PROPERTY_VALUE_MAX )))) { 306 useFbMem = true; 307 } 308 309 int err = 0; 310 if(useFbMem) { 311 err = gralloc_alloc_framebuffer(usage, pHandle); 312 } else { 313 err = gralloc_alloc_buffer(size, usage, pHandle, bufferType, 314 grallocFormat, alignedw, alignedh); 315 } 316 317 if (err < 0) { 318 return err; 319 } 320 321 *pStride = alignedw; 322 return 0; 323} 324 325int gpu_context_t::free_impl(private_handle_t const* hnd) { 326 private_module_t* m = reinterpret_cast<private_module_t*>(common.module); 327 if (hnd->flags & private_handle_t::PRIV_FLAGS_FRAMEBUFFER) { 328 const size_t bufferSize = m->finfo.line_length * m->info.yres; 329 size_t index = (hnd->base - m->framebuffer->base) / bufferSize; 330 m->bufferMask &= ~(1LU<<index); 331 } else { 332 333 terminateBuffer(&m->base, const_cast<private_handle_t*>(hnd)); 334 IMemAlloc* memalloc = mAllocCtrl->getAllocator(hnd->flags); 335 int err = memalloc->free_buffer((void*)hnd->base, (size_t) hnd->size, 336 hnd->offset, hnd->fd); 337 if(err) 338 return err; 339 // free the metadata space 340 size_t size = ROUND_UP_PAGESIZE(sizeof(MetaData_t)); 341 err = memalloc->free_buffer((void*)hnd->base_metadata, 342 size, hnd->offset_metadata, 343 hnd->fd_metadata); 344 if (err) 345 return err; 346 } 347 delete hnd; 348 return 0; 349} 350 351int gpu_context_t::gralloc_alloc(alloc_device_t* dev, int w, int h, int format, 352 int usage, buffer_handle_t* pHandle, 353 int* pStride) 354{ 355 if (!dev) { 356 return -EINVAL; 357 } 358 gpu_context_t* gpu = reinterpret_cast<gpu_context_t*>(dev); 359 return gpu->alloc_impl(w, h, format, usage, pHandle, pStride, 0); 360} 361int gpu_context_t::gralloc_alloc_size(alloc_device_t* dev, int w, int h, 362 int format, int usage, 363 buffer_handle_t* pHandle, int* pStride, 364 int bufferSize) 365{ 366 if (!dev) { 367 return -EINVAL; 368 } 369 gpu_context_t* gpu = reinterpret_cast<gpu_context_t*>(dev); 370 return gpu->alloc_impl(w, h, format, usage, pHandle, pStride, bufferSize); 371} 372 373 374int gpu_context_t::gralloc_free(alloc_device_t* dev, 375 buffer_handle_t handle) 376{ 377 if (private_handle_t::validate(handle) < 0) 378 return -EINVAL; 379 380 private_handle_t const* hnd = reinterpret_cast<private_handle_t const*>(handle); 381 gpu_context_t* gpu = reinterpret_cast<gpu_context_t*>(dev); 382 return gpu->free_impl(hnd); 383} 384 385/*****************************************************************************/ 386 387int gpu_context_t::gralloc_close(struct hw_device_t *dev) 388{ 389 gpu_context_t* ctx = reinterpret_cast<gpu_context_t*>(dev); 390 if (ctx) { 391 /* TODO: keep a list of all buffer_handle_t created, and free them 392 * all here. 393 */ 394 delete ctx; 395 } 396 return 0; 397} 398