1/*
2 * Copyright (c) 2011-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 <cutils/log.h>
31#include <cutils/properties.h>
32#include <dlfcn.h>
33
34#include "gralloc_priv.h"
35#include "gr_adreno_info.h"
36#include "gr_utils.h"
37
38namespace gralloc1 {
39
40AdrenoMemInfo::AdrenoMemInfo() {
41}
42
43bool AdrenoMemInfo::Init() {
44  libadreno_utils_ = ::dlopen("libadreno_utils.so", RTLD_NOW);
45  if (libadreno_utils_) {
46    *reinterpret_cast<void **>(&LINK_adreno_compute_aligned_width_and_height) =
47        ::dlsym(libadreno_utils_, "compute_aligned_width_and_height");
48    *reinterpret_cast<void **>(&LINK_adreno_compute_padding) =
49        ::dlsym(libadreno_utils_, "compute_surface_padding");
50    *reinterpret_cast<void **>(&LINK_adreno_compute_compressedfmt_aligned_width_and_height) =
51        ::dlsym(libadreno_utils_, "compute_compressedfmt_aligned_width_and_height");
52    *reinterpret_cast<void **>(&LINK_adreno_isUBWCSupportedByGpu) =
53        ::dlsym(libadreno_utils_, "isUBWCSupportedByGpu");
54    *reinterpret_cast<void **>(&LINK_adreno_get_gpu_pixel_alignment) =
55        ::dlsym(libadreno_utils_, "get_gpu_pixel_alignment");
56  } else {
57    ALOGE(" Failed to load libadreno_utils.so");
58    return false;
59  }
60
61  // Check if the overriding property debug.gralloc.gfx_ubwc_disable_
62  // that disables UBWC allocations for the graphics stack is set
63  char property[PROPERTY_VALUE_MAX];
64  property_get("debug.gralloc.gfx_ubwc_disable_", property, "0");
65  if (!(strncmp(property, "1", PROPERTY_VALUE_MAX)) ||
66      !(strncmp(property, "true", PROPERTY_VALUE_MAX))) {
67    gfx_ubwc_disable_ = true;
68  }
69
70  if ((property_get("debug.gralloc.map_fb_memory", property, NULL) > 0) &&
71      (!strncmp(property, "1", PROPERTY_VALUE_MAX) ||
72       (!strncasecmp(property, "true", PROPERTY_VALUE_MAX)))) {
73    map_fb_ = true;
74  }
75
76  return true;
77}
78
79AdrenoMemInfo::~AdrenoMemInfo() {
80  if (libadreno_utils_) {
81    ::dlclose(libadreno_utils_);
82  }
83}
84
85void AdrenoMemInfo::AlignUnCompressedRGB(int width, int height, int format, int tile_enabled,
86                                         unsigned int *aligned_w, unsigned int *aligned_h) {
87  *aligned_w = (unsigned int)ALIGN(width, 32);
88  *aligned_h = (unsigned int)ALIGN(height, 32);
89
90  // Don't add any additional padding if debug.gralloc.map_fb_memory
91  // is enabled
92  if (map_fb_) {
93    return;
94  }
95
96  int bpp = 4;
97  switch (format) {
98    case HAL_PIXEL_FORMAT_RGB_888:
99      bpp = 3;
100      break;
101    case HAL_PIXEL_FORMAT_RGB_565:
102    case HAL_PIXEL_FORMAT_BGR_565:
103    case HAL_PIXEL_FORMAT_RGBA_5551:
104    case HAL_PIXEL_FORMAT_RGBA_4444:
105      bpp = 2;
106      break;
107    default:
108      break;
109  }
110
111  int raster_mode = 0;          // Adreno unknown raster mode.
112  int padding_threshold = 512;  // Threshold for padding surfaces.
113  // the function below computes aligned width and aligned height
114  // based on linear or macro tile mode selected.
115  if (LINK_adreno_compute_aligned_width_and_height) {
116    LINK_adreno_compute_aligned_width_and_height(
117        width, height, bpp, tile_enabled, raster_mode, padding_threshold,
118        reinterpret_cast<int *>(aligned_w), reinterpret_cast<int *>(aligned_h));
119  } else if (LINK_adreno_compute_padding) {
120    int surface_tile_height = 1;  // Linear surface
121    *aligned_w = UINT(LINK_adreno_compute_padding(width, bpp, surface_tile_height, raster_mode,
122                                                  padding_threshold));
123    ALOGW("%s: Warning!! Old GFX API is used to calculate stride", __FUNCTION__);
124  } else {
125    ALOGW(
126        "%s: Warning!! Symbols compute_surface_padding and "
127        "compute_aligned_width_and_height not found",
128        __FUNCTION__);
129  }
130}
131
132void AdrenoMemInfo::AlignCompressedRGB(int width, int height, int format, unsigned int *aligned_w,
133                                       unsigned int *aligned_h) {
134  if (LINK_adreno_compute_compressedfmt_aligned_width_and_height) {
135    int bytesPerPixel = 0;
136    int raster_mode = 0;          // Adreno unknown raster mode.
137    int padding_threshold = 512;  // Threshold for padding
138    // surfaces.
139
140    LINK_adreno_compute_compressedfmt_aligned_width_and_height(
141        width, height, format, 0, raster_mode, padding_threshold,
142        reinterpret_cast<int *>(aligned_w), reinterpret_cast<int *>(aligned_h), &bytesPerPixel);
143  } else {
144    ALOGW("%s: Warning!! compute_compressedfmt_aligned_width_and_height not found", __FUNCTION__);
145  }
146}
147
148bool AdrenoMemInfo::IsUBWCSupportedByGPU(int format) {
149  if (!gfx_ubwc_disable_ && LINK_adreno_isUBWCSupportedByGpu) {
150    ADRENOPIXELFORMAT gpu_format = GetGpuPixelFormat(format);
151    return LINK_adreno_isUBWCSupportedByGpu(gpu_format);
152  }
153
154  return false;
155}
156
157uint32_t AdrenoMemInfo::GetGpuPixelAlignment() {
158  if (LINK_adreno_get_gpu_pixel_alignment) {
159    return LINK_adreno_get_gpu_pixel_alignment();
160  }
161
162  return 1;
163}
164
165ADRENOPIXELFORMAT AdrenoMemInfo::GetGpuPixelFormat(int hal_format) {
166  switch (hal_format) {
167    case HAL_PIXEL_FORMAT_RGBA_8888:
168      return ADRENO_PIXELFORMAT_R8G8B8A8;
169    case HAL_PIXEL_FORMAT_RGBX_8888:
170      return ADRENO_PIXELFORMAT_R8G8B8X8;
171    case HAL_PIXEL_FORMAT_RGB_565:
172      return ADRENO_PIXELFORMAT_B5G6R5;
173    case HAL_PIXEL_FORMAT_BGR_565:
174      return ADRENO_PIXELFORMAT_R5G6B5;
175    case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:
176      return ADRENO_PIXELFORMAT_NV12;
177    case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
178    case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC:
179      return ADRENO_PIXELFORMAT_NV12_EXT;
180    default:
181      ALOGE("%s: No map for format: 0x%x", __FUNCTION__, hal_format);
182      break;
183  }
184
185  return ADRENO_PIXELFORMAT_UNKNOWN;
186}
187
188}  // namespace gralloc1
189