1 /* 2 * Copyright (c) 2015-2017, The Linux Foundation. All rights reserved. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions are 6 * met: 7 * * Redistributions of source code must retain the above copyright 8 * notice, this list of conditions and the following disclaimer. 9 * * Redistributions in binary form must reproduce the above 10 * copyright notice, this list of conditions and the following 11 * disclaimer in the documentation and/or other materials provided 12 * with the distribution. 13 * * Neither the name of The Linux Foundation nor the names of its 14 * contributors may be used to endorse or promote products derived 15 * from this software without specific prior written permission. 16 * 17 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED 18 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 19 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS 21 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 22 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 23 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 24 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 25 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 26 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN 27 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 */ 29 30 #include <gralloc_priv.h> 31 32 #include <core/buffer_allocator.h> 33 #include <utils/constants.h> 34 #include <utils/debug.h> 35 36 #include "hwc_buffer_allocator.h" 37 #include "hwc_debugger.h" 38 39 #define __CLASS__ "HWCBufferAllocator" 40 namespace sdm { 41 42 HWCBufferAllocator::HWCBufferAllocator() { 43 int err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module_); 44 if (err != 0) { 45 DLOGE("FATAL: can not open GRALLOC module"); 46 } else { 47 gralloc1_open(module_, &gralloc_device_); 48 } 49 ReleaseBuffer_ = reinterpret_cast<GRALLOC1_PFN_RELEASE>( 50 gralloc_device_->getFunction(gralloc_device_, GRALLOC1_FUNCTION_RELEASE)); 51 Perform_ = reinterpret_cast<GRALLOC1_PFN_PERFORM>( 52 gralloc_device_->getFunction(gralloc_device_, GRALLOC1_FUNCTION_PERFORM)); 53 } 54 55 HWCBufferAllocator::~HWCBufferAllocator() { 56 if (gralloc_device_ != nullptr) { 57 gralloc1_close(gralloc_device_); 58 } 59 } 60 61 DisplayError HWCBufferAllocator::AllocateBuffer(BufferInfo *buffer_info) { 62 const BufferConfig &buffer_config = buffer_info->buffer_config; 63 AllocatedBufferInfo *alloc_buffer_info = &buffer_info->alloc_buffer_info; 64 uint32_t width = buffer_config.width; 65 uint32_t height = buffer_config.height; 66 int format; 67 int alloc_flags = 0; 68 int error = SetBufferInfo(buffer_config.format, &format, &alloc_flags); 69 if (error != 0) { 70 return kErrorParameters; 71 } 72 73 if (buffer_config.secure) { 74 alloc_flags |= GRALLOC1_PRODUCER_USAGE_PROTECTED; 75 } 76 77 if (!buffer_config.cache) { 78 // Allocate uncached buffers 79 alloc_flags |= GRALLOC_USAGE_PRIVATE_UNCACHED; 80 } 81 uint64_t producer_usage = UINT64(alloc_flags); 82 uint64_t consumer_usage = UINT64(alloc_flags); 83 // CreateBuffer 84 private_handle_t *hnd = nullptr; 85 Perform_(gralloc_device_, GRALLOC1_MODULE_PERFORM_ALLOCATE_BUFFER, width, height, format, 86 producer_usage, consumer_usage, &hnd); 87 88 if (hnd) { 89 alloc_buffer_info->fd = hnd->fd; 90 alloc_buffer_info->stride = UINT32(hnd->width); 91 alloc_buffer_info->size = hnd->size; 92 } else { 93 DLOGE("Failed to allocate memory"); 94 return kErrorMemory; 95 } 96 97 buffer_info->private_data = reinterpret_cast<void *>(hnd); 98 return kErrorNone; 99 } 100 101 DisplayError HWCBufferAllocator::FreeBuffer(BufferInfo *buffer_info) { 102 DisplayError err = kErrorNone; 103 buffer_handle_t hnd = static_cast<private_handle_t *>(buffer_info->private_data); 104 ReleaseBuffer_(gralloc_device_, hnd); 105 AllocatedBufferInfo *alloc_buffer_info = &buffer_info->alloc_buffer_info; 106 alloc_buffer_info->fd = -1; 107 alloc_buffer_info->stride = 0; 108 alloc_buffer_info->size = 0; 109 buffer_info->private_data = NULL; 110 return err; 111 } 112 113 void HWCBufferAllocator::GetCustomWidthAndHeight(const private_handle_t *handle, int *width, 114 int *height) { 115 Perform_(gralloc_device_, GRALLOC_MODULE_PERFORM_GET_CUSTOM_STRIDE_AND_HEIGHT_FROM_HANDLE, handle, 116 width, height); 117 } 118 119 void HWCBufferAllocator::GetAlignedWidthAndHeight(int width, int height, int format, 120 uint32_t alloc_type, int *aligned_width, 121 int *aligned_height) { 122 int tile_enabled; 123 gralloc1_producer_usage_t producer_usage = GRALLOC1_PRODUCER_USAGE_NONE; 124 gralloc1_consumer_usage_t consumer_usage = GRALLOC1_CONSUMER_USAGE_NONE; 125 if (alloc_type & GRALLOC_USAGE_HW_FB) { 126 consumer_usage = GRALLOC1_CONSUMER_USAGE_CLIENT_TARGET; 127 } 128 129 Perform_(gralloc_device_, GRALLOC_MODULE_PERFORM_GET_ATTRIBUTES, width, height, format, 130 producer_usage, consumer_usage, aligned_width, aligned_height, &tile_enabled); 131 } 132 133 uint32_t HWCBufferAllocator::GetBufferSize(BufferInfo *buffer_info) { 134 const BufferConfig &buffer_config = buffer_info->buffer_config; 135 int alloc_flags = INT(GRALLOC_USAGE_PRIVATE_IOMMU_HEAP); 136 137 int width = INT(buffer_config.width); 138 int height = INT(buffer_config.height); 139 int format; 140 141 if (buffer_config.secure) { 142 alloc_flags |= INT(GRALLOC_USAGE_PROTECTED); 143 } 144 145 if (!buffer_config.cache) { 146 // Allocate uncached buffers 147 alloc_flags |= GRALLOC_USAGE_PRIVATE_UNCACHED; 148 } 149 150 if (SetBufferInfo(buffer_config.format, &format, &alloc_flags) < 0) { 151 return 0; 152 } 153 154 uint32_t aligned_width = 0, aligned_height = 0, buffer_size = 0; 155 uint64_t producer_usage = GRALLOC1_PRODUCER_USAGE_NONE; 156 uint64_t consumer_usage = GRALLOC1_CONSUMER_USAGE_NONE; 157 // TODO(user): Currently both flags are treated similarly in gralloc 158 producer_usage = UINT64(alloc_flags); 159 consumer_usage = producer_usage; 160 Perform_(gralloc_device_, GRALLOC1_MODULE_PERFORM_GET_BUFFER_SIZE_AND_DIMENSIONS, width, height, 161 format, producer_usage, consumer_usage, &aligned_width, &aligned_height, &buffer_size); 162 return buffer_size; 163 } 164 165 int HWCBufferAllocator::SetBufferInfo(LayerBufferFormat format, int *target, int *flags) { 166 switch (format) { 167 case kFormatRGBA8888: 168 *target = HAL_PIXEL_FORMAT_RGBA_8888; 169 break; 170 case kFormatRGBX8888: 171 *target = HAL_PIXEL_FORMAT_RGBX_8888; 172 break; 173 case kFormatRGB888: 174 *target = HAL_PIXEL_FORMAT_RGB_888; 175 break; 176 case kFormatRGB565: 177 *target = HAL_PIXEL_FORMAT_RGB_565; 178 break; 179 case kFormatBGR565: 180 *target = HAL_PIXEL_FORMAT_BGR_565; 181 break; 182 case kFormatBGRA8888: 183 *target = HAL_PIXEL_FORMAT_BGRA_8888; 184 break; 185 case kFormatYCrCb420PlanarStride16: 186 *target = HAL_PIXEL_FORMAT_YV12; 187 break; 188 case kFormatYCrCb420SemiPlanar: 189 *target = HAL_PIXEL_FORMAT_YCrCb_420_SP; 190 break; 191 case kFormatYCbCr420SemiPlanar: 192 *target = HAL_PIXEL_FORMAT_YCbCr_420_SP; 193 break; 194 case kFormatYCbCr422H2V1Packed: 195 *target = HAL_PIXEL_FORMAT_YCbCr_422_I; 196 break; 197 case kFormatYCbCr422H2V1SemiPlanar: 198 *target = HAL_PIXEL_FORMAT_YCbCr_422_SP; 199 break; 200 case kFormatYCbCr420SemiPlanarVenus: 201 *target = HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS; 202 break; 203 case kFormatYCrCb420SemiPlanarVenus: 204 *target = HAL_PIXEL_FORMAT_YCrCb_420_SP_VENUS; 205 break; 206 case kFormatYCbCr420SPVenusUbwc: 207 *target = HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC; 208 break; 209 case kFormatRGBA5551: 210 *target = HAL_PIXEL_FORMAT_RGBA_5551; 211 break; 212 case kFormatRGBA4444: 213 *target = HAL_PIXEL_FORMAT_RGBA_4444; 214 break; 215 case kFormatRGBA1010102: 216 *target = HAL_PIXEL_FORMAT_RGBA_1010102; 217 break; 218 case kFormatARGB2101010: 219 *target = HAL_PIXEL_FORMAT_ARGB_2101010; 220 break; 221 case kFormatRGBX1010102: 222 *target = HAL_PIXEL_FORMAT_RGBX_1010102; 223 break; 224 case kFormatXRGB2101010: 225 *target = HAL_PIXEL_FORMAT_XRGB_2101010; 226 break; 227 case kFormatBGRA1010102: 228 *target = HAL_PIXEL_FORMAT_BGRA_1010102; 229 break; 230 case kFormatABGR2101010: 231 *target = HAL_PIXEL_FORMAT_ABGR_2101010; 232 break; 233 case kFormatBGRX1010102: 234 *target = HAL_PIXEL_FORMAT_BGRX_1010102; 235 break; 236 case kFormatXBGR2101010: 237 *target = HAL_PIXEL_FORMAT_XBGR_2101010; 238 break; 239 case kFormatYCbCr420P010: 240 *target = HAL_PIXEL_FORMAT_YCbCr_420_P010; 241 break; 242 case kFormatYCbCr420TP10Ubwc: 243 *target = HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC; 244 break; 245 case kFormatRGBA8888Ubwc: 246 *target = HAL_PIXEL_FORMAT_RGBA_8888; 247 *flags |= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC; 248 break; 249 case kFormatRGBX8888Ubwc: 250 *target = HAL_PIXEL_FORMAT_RGBX_8888; 251 *flags |= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC; 252 break; 253 case kFormatBGR565Ubwc: 254 *target = HAL_PIXEL_FORMAT_BGR_565; 255 *flags |= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC; 256 break; 257 case kFormatRGBA1010102Ubwc: 258 *target = HAL_PIXEL_FORMAT_RGBA_1010102; 259 *flags |= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC; 260 break; 261 case kFormatRGBX1010102Ubwc: 262 *target = HAL_PIXEL_FORMAT_RGBX_1010102; 263 *flags |= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC; 264 break; 265 default: 266 DLOGE("Unsupported format = 0x%x", format); 267 return -EINVAL; 268 } 269 return 0; 270 } 271 272 DisplayError HWCBufferAllocator::GetAllocatedBufferInfo( 273 const BufferConfig &buffer_config, AllocatedBufferInfo *allocated_buffer_info) { 274 // TODO(user): This API should pass the buffer_info of the already allocated buffer 275 // The private_data can then be typecast to the private_handle and used directly. 276 int alloc_flags = INT(GRALLOC_USAGE_PRIVATE_IOMMU_HEAP); 277 278 int width = INT(buffer_config.width); 279 int height = INT(buffer_config.height); 280 int format; 281 282 if (buffer_config.secure) { 283 alloc_flags |= INT(GRALLOC_USAGE_PROTECTED); 284 } 285 286 if (!buffer_config.cache) { 287 // Allocate uncached buffers 288 alloc_flags |= GRALLOC_USAGE_PRIVATE_UNCACHED; 289 } 290 291 if (SetBufferInfo(buffer_config.format, &format, &alloc_flags) < 0) { 292 return kErrorParameters; 293 } 294 295 uint32_t aligned_width = 0, aligned_height = 0, buffer_size = 0; 296 uint64_t producer_usage = GRALLOC1_PRODUCER_USAGE_NONE; 297 uint64_t consumer_usage = GRALLOC1_CONSUMER_USAGE_NONE; 298 // TODO(user): Currently both flags are treated similarly in gralloc 299 producer_usage = UINT64(alloc_flags); 300 consumer_usage = producer_usage; 301 Perform_(gralloc_device_, GRALLOC1_MODULE_PERFORM_GET_BUFFER_SIZE_AND_DIMENSIONS, width, height, 302 format, producer_usage, consumer_usage, &aligned_width, &aligned_height, &buffer_size); 303 allocated_buffer_info->stride = UINT32(aligned_width); 304 allocated_buffer_info->size = UINT32(buffer_size); 305 306 return kErrorNone; 307 } 308 309 } // namespace sdm 310