1/*
2* Copyright (c) 2015 - 2016, 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#include <memalloc.h>
32#include <gr.h>
33#include <alloc_controller.h>
34#include <utils/constants.h>
35#include <utils/debug.h>
36#include <core/buffer_allocator.h>
37
38#include "hwc_debugger.h"
39#include "hwc_buffer_allocator.h"
40
41#define __CLASS__ "HWCBufferAllocator"
42
43namespace sdm {
44
45HWCBufferAllocator::HWCBufferAllocator() {
46  alloc_controller_ = gralloc::IAllocController::getInstance();
47}
48
49DisplayError HWCBufferAllocator::AllocateBuffer(BufferInfo *buffer_info) {
50  gralloc::alloc_data data;
51
52  const BufferConfig &buffer_config = buffer_info->buffer_config;
53  AllocatedBufferInfo *alloc_buffer_info = &buffer_info->alloc_buffer_info;
54  MetaBufferInfo *meta_buffer_info = new MetaBufferInfo();
55
56  if (!meta_buffer_info) {
57    return kErrorMemory;
58  }
59
60  int alloc_flags = INT(GRALLOC_USAGE_PRIVATE_IOMMU_HEAP);
61  int error = 0;
62
63  int width = INT(buffer_config.width);
64  int height = INT(buffer_config.height);
65  int format;
66
67  if (buffer_config.secure) {
68    alloc_flags = INT(GRALLOC_USAGE_PRIVATE_MM_HEAP);
69    alloc_flags |= INT(GRALLOC_USAGE_PROTECTED);
70    data.align = SECURE_ALIGN;
71  } else {
72    data.align = UINT32(getpagesize());
73  }
74
75  if (buffer_config.cache == false) {
76    // Allocate uncached buffers
77    alloc_flags |= GRALLOC_USAGE_PRIVATE_UNCACHED;
78  }
79
80  error = SetBufferInfo(buffer_config.format, &format, &alloc_flags);
81  if (error != 0) {
82    delete meta_buffer_info;
83    return kErrorParameters;
84  }
85
86  int aligned_width = 0, aligned_height = 0;
87  uint32_t buffer_size = getBufferSizeAndDimensions(width, height, format, alloc_flags,
88                                                    aligned_width, aligned_height);
89
90  buffer_size = ROUND_UP(buffer_size, data.align) * buffer_config.buffer_count;
91
92  data.base = 0;
93  data.fd = -1;
94  data.offset = 0;
95  data.size = buffer_size;
96  data.uncached = !buffer_config.cache;
97
98  error = alloc_controller_->allocate(data, alloc_flags);
99  if (error != 0) {
100    DLOGE("Error allocating memory size %d uncached %d", data.size, data.uncached);
101    delete meta_buffer_info;
102    return kErrorMemory;
103  }
104
105  alloc_buffer_info->fd = data.fd;
106  alloc_buffer_info->stride = UINT32(aligned_width);
107  alloc_buffer_info->size = buffer_size;
108
109  meta_buffer_info->base_addr = data.base;
110  meta_buffer_info->alloc_type = data.allocType;
111
112  buffer_info->private_data = meta_buffer_info;
113
114  return kErrorNone;
115}
116
117DisplayError HWCBufferAllocator::FreeBuffer(BufferInfo *buffer_info) {
118  int ret = 0;
119
120  AllocatedBufferInfo *alloc_buffer_info = &buffer_info->alloc_buffer_info;
121
122  // Deallocate the buffer, only if the buffer fd is valid.
123  if (alloc_buffer_info->fd > 0) {
124    MetaBufferInfo *meta_buffer_info = static_cast<MetaBufferInfo *> (buffer_info->private_data);
125    gralloc::IMemAlloc *memalloc = alloc_controller_->getAllocator(meta_buffer_info->alloc_type);
126    if (memalloc == NULL) {
127      DLOGE("Memalloc handle is NULL, alloc type %d", meta_buffer_info->alloc_type);
128      return kErrorResources;
129    }
130
131    ret = memalloc->free_buffer(meta_buffer_info->base_addr, alloc_buffer_info->size, 0,
132                                alloc_buffer_info->fd);
133    if (ret != 0) {
134      DLOGE("Error freeing buffer base_addr %p size %d fd %d", meta_buffer_info->base_addr,
135            alloc_buffer_info->size, alloc_buffer_info->fd);
136      return kErrorMemory;
137    }
138
139    alloc_buffer_info->fd = -1;
140    alloc_buffer_info->stride = 0;
141    alloc_buffer_info->size = 0;
142
143    meta_buffer_info->base_addr = NULL;
144    meta_buffer_info->alloc_type = 0;
145
146    delete meta_buffer_info;
147    meta_buffer_info = NULL;
148  }
149
150  return kErrorNone;
151}
152
153uint32_t HWCBufferAllocator::GetBufferSize(BufferInfo *buffer_info) {
154  uint32_t align = UINT32(getpagesize());
155
156  const BufferConfig &buffer_config = buffer_info->buffer_config;
157
158  int alloc_flags = INT(GRALLOC_USAGE_PRIVATE_IOMMU_HEAP);
159
160  int width = INT(buffer_config.width);
161  int height = INT(buffer_config.height);
162  int format;
163
164  if (buffer_config.secure) {
165    alloc_flags = INT(GRALLOC_USAGE_PRIVATE_MM_HEAP);
166    alloc_flags |= INT(GRALLOC_USAGE_PROTECTED);
167    align = SECURE_ALIGN;
168  }
169
170  if (buffer_config.cache == false) {
171    // Allocate uncached buffers
172    alloc_flags |= GRALLOC_USAGE_PRIVATE_UNCACHED;
173  }
174
175  if (SetBufferInfo(buffer_config.format, &format, &alloc_flags) < 0) {
176    return 0;
177  }
178
179  int aligned_width = 0;
180  int aligned_height = 0;
181  uint32_t buffer_size = getBufferSizeAndDimensions(width, height, format, alloc_flags,
182                                                    aligned_width, aligned_height);
183
184  buffer_size = ROUND_UP(buffer_size, align) * buffer_config.buffer_count;
185
186  return buffer_size;
187}
188
189int HWCBufferAllocator::SetBufferInfo(LayerBufferFormat format, int *target, int *flags) {
190  switch (format) {
191  case kFormatRGBA8888:                 *target = HAL_PIXEL_FORMAT_RGBA_8888;             break;
192  case kFormatRGBX8888:                 *target = HAL_PIXEL_FORMAT_RGBX_8888;             break;
193  case kFormatRGB888:                   *target = HAL_PIXEL_FORMAT_RGB_888;               break;
194  case kFormatRGB565:                   *target = HAL_PIXEL_FORMAT_RGB_565;               break;
195  case kFormatBGR565:                   *target = HAL_PIXEL_FORMAT_BGR_565;               break;
196  case kFormatBGRA8888:                 *target = HAL_PIXEL_FORMAT_BGRA_8888;             break;
197  case kFormatYCrCb420PlanarStride16:   *target = HAL_PIXEL_FORMAT_YV12;                  break;
198  case kFormatYCrCb420SemiPlanar:       *target = HAL_PIXEL_FORMAT_YCrCb_420_SP;          break;
199  case kFormatYCbCr420SemiPlanar:       *target = HAL_PIXEL_FORMAT_YCbCr_420_SP;          break;
200  case kFormatYCbCr422H2V1Packed:       *target = HAL_PIXEL_FORMAT_YCbCr_422_I;           break;
201  case kFormatYCbCr422H2V1SemiPlanar:   *target = HAL_PIXEL_FORMAT_YCbCr_422_SP;          break;
202  case kFormatYCbCr420SemiPlanarVenus:  *target = HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS;    break;
203  case kFormatYCrCb420SemiPlanarVenus:  *target = HAL_PIXEL_FORMAT_YCrCb_420_SP_VENUS;    break;
204  case kFormatYCbCr420SPVenusUbwc:    *target = HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC; break;
205  case kFormatRGBA5551:                 *target = HAL_PIXEL_FORMAT_RGBA_5551;             break;
206  case kFormatRGBA4444:                 *target = HAL_PIXEL_FORMAT_RGBA_4444;             break;
207  case kFormatRGBA1010102:              *target = HAL_PIXEL_FORMAT_RGBA_1010102;          break;
208  case kFormatARGB2101010:              *target = HAL_PIXEL_FORMAT_ARGB_2101010;          break;
209  case kFormatRGBX1010102:              *target = HAL_PIXEL_FORMAT_RGBX_1010102;          break;
210  case kFormatXRGB2101010:              *target = HAL_PIXEL_FORMAT_XRGB_2101010;          break;
211  case kFormatBGRA1010102:              *target = HAL_PIXEL_FORMAT_BGRA_1010102;          break;
212  case kFormatABGR2101010:              *target = HAL_PIXEL_FORMAT_ABGR_2101010;          break;
213  case kFormatBGRX1010102:              *target = HAL_PIXEL_FORMAT_BGRX_1010102;          break;
214  case kFormatXBGR2101010:              *target = HAL_PIXEL_FORMAT_XBGR_2101010;          break;
215  case kFormatYCbCr420P010:             *target = HAL_PIXEL_FORMAT_YCbCr_420_P010;        break;
216  case kFormatYCbCr420TP10Ubwc:         *target = HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC;   break;
217  case kFormatRGBA8888Ubwc:
218    *target = HAL_PIXEL_FORMAT_RGBA_8888;
219    *flags |= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
220    break;
221  case kFormatRGBX8888Ubwc:
222    *target = HAL_PIXEL_FORMAT_RGBX_8888;
223    *flags |= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
224    break;
225  case kFormatBGR565Ubwc:
226    *target = HAL_PIXEL_FORMAT_BGR_565;
227    *flags |= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
228    break;
229  case kFormatRGBA1010102Ubwc:
230    *target = HAL_PIXEL_FORMAT_RGBA_1010102;
231    *flags |= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
232    break;
233  case kFormatRGBX1010102Ubwc:
234    *target = HAL_PIXEL_FORMAT_RGBX_1010102;
235    *flags |= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
236    break;
237  default:
238    DLOGE("Unsupported format = 0x%x", format);
239    return -EINVAL;
240  }
241
242  return 0;
243}
244
245}  // namespace sdm
246