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 30 using namespace gralloc; 31 32 #define SZ_1M 0x100000 33 34 gpu_context_t::gpu_context_t(const private_module_t* module, 35 IAllocController* alloc_ctrl ) : 36 mAllocCtrl(alloc_ctrl) 37 { 38 // Zero out the alloc_device_t 39 memset(static_cast<alloc_device_t*>(this), 0, sizeof(alloc_device_t)); 40 41 // Initialize the procs 42 common.tag = HARDWARE_DEVICE_TAG; 43 common.version = 0; 44 common.module = const_cast<hw_module_t*>(&module->base.common); 45 common.close = gralloc_close; 46 alloc = gralloc_alloc; 47 #ifdef QCOM_BSP 48 allocSize = gralloc_alloc_size; 49 #endif 50 free = gralloc_free; 51 52 } 53 54 int gpu_context_t::gralloc_alloc_buffer(unsigned int size, int usage, 55 buffer_handle_t* pHandle, int bufferType, 56 int format, int width, int height) 57 { 58 int err = 0; 59 int flags = 0; 60 size = roundUpToPageSize(size); 61 alloc_data data; 62 data.offset = 0; 63 data.fd = -1; 64 data.base = 0; 65 if(format == HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED) 66 data.align = 8192; 67 else 68 data.align = getpagesize(); 69 70 /* force 1MB alignment selectively for secure buffers, MDP5 onwards */ 71 #ifdef MDSS_TARGET 72 if ((usage & GRALLOC_USAGE_PROTECTED) && 73 (usage & GRALLOC_USAGE_PRIVATE_MM_HEAP)) { 74 data.align = ALIGN((int) data.align, SZ_1M); 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 if(usage & (GRALLOC_USAGE_SW_READ_MASK | GRALLOC_USAGE_SW_WRITE_MASK)) { 156 flags |= private_handle_t::PRIV_FLAGS_CPU_RENDERED; 157 } 158 159 flags |= data.allocType; 160 uint64_t eBaseAddr = (uint64_t)(eData.base) + eData.offset; 161 private_handle_t *hnd = new private_handle_t(data.fd, size, flags, 162 bufferType, format, width, height, eData.fd, eData.offset, 163 eBaseAddr); 164 165 hnd->offset = data.offset; 166 hnd->base = (uint64_t)(data.base) + data.offset; 167 hnd->gpuaddr = 0; 168 setMetaData(hnd, UPDATE_COLOR_SPACE, (void*) &colorSpace); 169 170 *pHandle = hnd; 171 } 172 173 ALOGE_IF(err, "gralloc failed err=%s", strerror(-err)); 174 175 return err; 176 } 177 178 void gpu_context_t::getGrallocInformationFromFormat(int inputFormat, 179 int *bufferType) 180 { 181 *bufferType = BUFFER_TYPE_VIDEO; 182 183 if (inputFormat <= HAL_PIXEL_FORMAT_BGRA_8888) { 184 // RGB formats 185 *bufferType = BUFFER_TYPE_UI; 186 } else if ((inputFormat == HAL_PIXEL_FORMAT_R_8) || 187 (inputFormat == HAL_PIXEL_FORMAT_RG_88)) { 188 *bufferType = BUFFER_TYPE_UI; 189 } 190 } 191 192 int gpu_context_t::gralloc_alloc_framebuffer_locked(int usage, 193 buffer_handle_t* pHandle) 194 { 195 private_module_t* m = reinterpret_cast<private_module_t*>(common.module); 196 197 // we don't support framebuffer allocations with graphics heap flags 198 if (usage & GRALLOC_HEAP_MASK) { 199 return -EINVAL; 200 } 201 202 if (m->framebuffer == NULL) { 203 ALOGE("%s: Invalid framebuffer", __FUNCTION__); 204 return -EINVAL; 205 } 206 207 const unsigned int bufferMask = m->bufferMask; 208 const uint32_t numBuffers = m->numBuffers; 209 unsigned int bufferSize = m->finfo.line_length * m->info.yres; 210 211 //adreno needs FB size to be page aligned 212 bufferSize = roundUpToPageSize(bufferSize); 213 214 if (numBuffers == 1) { 215 // If we have only one buffer, we never use page-flipping. Instead, 216 // we return a regular buffer which will be memcpy'ed to the main 217 // screen when post is called. 218 int newUsage = (usage & ~GRALLOC_USAGE_HW_FB) | GRALLOC_USAGE_HW_2D; 219 return gralloc_alloc_buffer(bufferSize, newUsage, pHandle, BUFFER_TYPE_UI, 220 m->fbFormat, m->info.xres, m->info.yres); 221 } 222 223 if (bufferMask >= ((1LU<<numBuffers)-1)) { 224 // We ran out of buffers. 225 return -ENOMEM; 226 } 227 228 // create a "fake" handle for it 229 uint64_t vaddr = uint64_t(m->framebuffer->base); 230 private_handle_t* hnd = new private_handle_t( 231 dup(m->framebuffer->fd), bufferSize, 232 private_handle_t::PRIV_FLAGS_USES_PMEM | 233 private_handle_t::PRIV_FLAGS_FRAMEBUFFER, 234 BUFFER_TYPE_UI, m->fbFormat, m->info.xres, 235 m->info.yres); 236 237 // find a free slot 238 for (uint32_t i=0 ; i<numBuffers ; i++) { 239 if ((bufferMask & (1LU<<i)) == 0) { 240 m->bufferMask |= (uint32_t)(1LU<<i); 241 break; 242 } 243 vaddr += bufferSize; 244 } 245 hnd->base = vaddr; 246 hnd->offset = (unsigned int)(vaddr - m->framebuffer->base); 247 *pHandle = hnd; 248 return 0; 249 } 250 251 252 int gpu_context_t::gralloc_alloc_framebuffer(int usage, 253 buffer_handle_t* pHandle) 254 { 255 private_module_t* m = reinterpret_cast<private_module_t*>(common.module); 256 pthread_mutex_lock(&m->lock); 257 int err = gralloc_alloc_framebuffer_locked(usage, pHandle); 258 pthread_mutex_unlock(&m->lock); 259 return err; 260 } 261 262 int gpu_context_t::alloc_impl(int w, int h, int format, int usage, 263 buffer_handle_t* pHandle, int* pStride, 264 unsigned int bufferSize) { 265 if (!pHandle || !pStride) 266 return -EINVAL; 267 268 unsigned int size; 269 int alignedw, alignedh; 270 int grallocFormat = format; 271 int bufferType; 272 273 //If input format is HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED then based on 274 //the usage bits, gralloc assigns a format. 275 if(format == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED || 276 format == HAL_PIXEL_FORMAT_YCbCr_420_888) { 277 if(usage & GRALLOC_USAGE_HW_VIDEO_ENCODER) 278 grallocFormat = HAL_PIXEL_FORMAT_NV12_ENCODEABLE; //NV12 279 else if((usage & GRALLOC_USAGE_HW_CAMERA_MASK) 280 == GRALLOC_USAGE_HW_CAMERA_ZSL) 281 grallocFormat = HAL_PIXEL_FORMAT_NV21_ZSL; //NV21 ZSL 282 else if(usage & GRALLOC_USAGE_HW_CAMERA_READ) 283 grallocFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP; //NV21 284 else if(usage & GRALLOC_USAGE_HW_CAMERA_WRITE) 285 grallocFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP; //NV21 286 else if(usage & GRALLOC_USAGE_HW_COMPOSER) 287 //XXX: If we still haven't set a format, default to RGBA8888 288 grallocFormat = HAL_PIXEL_FORMAT_RGBA_8888; 289 else if(format == HAL_PIXEL_FORMAT_YCbCr_420_888) 290 // If no other usage flags are detected, default the flexible YUV 291 // format to NV21_ZSL. 292 grallocFormat = HAL_PIXEL_FORMAT_NV21_ZSL; 293 } 294 295 getGrallocInformationFromFormat(grallocFormat, &bufferType); 296 size = getBufferSizeAndDimensions(w, h, grallocFormat, usage, alignedw, 297 alignedh); 298 299 if ((unsigned int)size <= 0) 300 return -EINVAL; 301 size = (bufferSize >= size)? bufferSize : size; 302 303 bool useFbMem = false; 304 char property[PROPERTY_VALUE_MAX]; 305 if((usage & GRALLOC_USAGE_HW_FB) && 306 (property_get("debug.gralloc.map_fb_memory", property, NULL) > 0) && 307 (!strncmp(property, "1", PROPERTY_VALUE_MAX ) || 308 (!strncasecmp(property,"true", PROPERTY_VALUE_MAX )))) { 309 useFbMem = true; 310 } 311 312 int err = 0; 313 if(useFbMem) { 314 err = gralloc_alloc_framebuffer(usage, pHandle); 315 } else { 316 err = gralloc_alloc_buffer(size, usage, pHandle, bufferType, 317 grallocFormat, alignedw, alignedh); 318 } 319 320 if (err < 0) { 321 return err; 322 } 323 324 *pStride = alignedw; 325 return 0; 326 } 327 328 int gpu_context_t::free_impl(private_handle_t const* hnd) { 329 private_module_t* m = reinterpret_cast<private_module_t*>(common.module); 330 if (hnd->flags & private_handle_t::PRIV_FLAGS_FRAMEBUFFER) { 331 const unsigned int bufferSize = m->finfo.line_length * m->info.yres; 332 unsigned int index = (unsigned int) ((hnd->base - m->framebuffer->base) 333 / bufferSize); 334 m->bufferMask &= (uint32_t)~(1LU<<index); 335 } else { 336 337 terminateBuffer(&m->base, const_cast<private_handle_t*>(hnd)); 338 IMemAlloc* memalloc = mAllocCtrl->getAllocator(hnd->flags); 339 int err = memalloc->free_buffer((void*)hnd->base, hnd->size, 340 hnd->offset, hnd->fd); 341 if(err) 342 return err; 343 // free the metadata space 344 unsigned int size = ROUND_UP_PAGESIZE(sizeof(MetaData_t)); 345 err = memalloc->free_buffer((void*)hnd->base_metadata, 346 size, hnd->offset_metadata, 347 hnd->fd_metadata); 348 if (err) 349 return err; 350 } 351 delete hnd; 352 return 0; 353 } 354 355 int gpu_context_t::gralloc_alloc(alloc_device_t* dev, int w, int h, int format, 356 int usage, buffer_handle_t* pHandle, 357 int* pStride) 358 { 359 if (!dev) { 360 return -EINVAL; 361 } 362 gpu_context_t* gpu = reinterpret_cast<gpu_context_t*>(dev); 363 return gpu->alloc_impl(w, h, format, usage, pHandle, pStride, 0); 364 } 365 int gpu_context_t::gralloc_alloc_size(alloc_device_t* dev, int w, int h, 366 int format, int usage, 367 buffer_handle_t* pHandle, int* pStride, 368 int bufferSize) 369 { 370 if (!dev) { 371 return -EINVAL; 372 } 373 gpu_context_t* gpu = reinterpret_cast<gpu_context_t*>(dev); 374 return gpu->alloc_impl(w, h, format, usage, pHandle, pStride, bufferSize); 375 } 376 377 378 int gpu_context_t::gralloc_free(alloc_device_t* dev, 379 buffer_handle_t handle) 380 { 381 if (private_handle_t::validate(handle) < 0) 382 return -EINVAL; 383 384 private_handle_t const* hnd = reinterpret_cast<private_handle_t const*>(handle); 385 gpu_context_t* gpu = reinterpret_cast<gpu_context_t*>(dev); 386 return gpu->free_impl(hnd); 387 } 388 389 /*****************************************************************************/ 390 391 int gpu_context_t::gralloc_close(struct hw_device_t *dev) 392 { 393 gpu_context_t* ctx = reinterpret_cast<gpu_context_t*>(dev); 394 if (ctx) { 395 /* TODO: keep a list of all buffer_handle_t created, and free them 396 * all here. 397 */ 398 delete ctx; 399 } 400 return 0; 401 } 402
