1 /* 2 * Copyright (C) 2008 The Android Open Source Project 3 * Copyright (c) 2011 - 2017, 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 #ifndef GR_H_ 19 #define GR_H_ 20 21 #include <stdint.h> 22 #include <limits.h> 23 #include <sys/cdefs.h> 24 #include <hardware/gralloc.h> 25 #include <pthread.h> 26 #include <errno.h> 27 #include <unistd.h> 28 29 #include <cutils/native_handle.h> 30 #include <utils/Singleton.h> 31 #include "adreno_utils.h" 32 33 /*****************************************************************************/ 34 35 struct private_module_t; 36 struct private_handle_t; 37 38 inline unsigned int roundUpToPageSize(unsigned int x) { 39 return (x + (getpagesize()-1)) & ~(getpagesize()-1); 40 } 41 42 template <class Type> 43 inline Type ALIGN(Type x, Type align) { 44 return (x + align-1) & ~(align-1); 45 } 46 47 #define FALSE 0 48 #define TRUE 1 49 50 int mapFrameBufferLocked(struct private_module_t* module); 51 int terminateBuffer(gralloc_module_t const* module, private_handle_t* hnd); 52 unsigned int getBufferSizeAndDimensions(int width, int height, int format, 53 int usage, int& alignedw, int &alignedh); 54 unsigned int getBufferSizeAndDimensions(int width, int height, int format, 55 int& alignedw, int &alignedh); 56 57 int decideBufferHandlingMechanism(int format, const char *compositionUsed, 58 int hasBlitEngine, int *needConversion, 59 int *useBufferDirectly); 60 61 // Allocate buffer from width, height, format into a private_handle_t 62 // It is the responsibility of the caller to free the buffer 63 int alloc_buffer(private_handle_t **pHnd, int w, int h, int format, int usage); 64 void free_buffer(private_handle_t *hnd); 65 int getYUVPlaneInfo(private_handle_t* pHnd, struct android_ycbcr* ycbcr); 66 int getRgbDataAddress(private_handle_t* pHnd, void** rgb_data); 67 68 // To query if UBWC is enabled, based on format and usage flags 69 bool isUBwcEnabled(int format, int usage); 70 71 // Function to check if the format is an RGB format 72 bool isUncompressedRgbFormat(int format); 73 74 // Returns number of planes, stride and offset of each plane for a given w,h,f 75 int getBufferLayout(private_handle_t *hnd, uint32_t stride[4], 76 uint32_t offset[4], uint32_t *num_planes); 77 /*****************************************************************************/ 78 79 class Locker { 80 pthread_mutex_t mutex; 81 pthread_cond_t cond; 82 public: 83 class Autolock { 84 Locker& locker; 85 public: 86 inline Autolock(Locker& locker) : locker(locker) { locker.lock(); } 87 inline ~Autolock() { locker.unlock(); } 88 }; 89 inline Locker() { 90 pthread_mutex_init(&mutex, 0); 91 pthread_cond_init(&cond, 0); 92 } 93 inline ~Locker() { 94 pthread_mutex_destroy(&mutex); 95 pthread_cond_destroy(&cond); 96 } 97 inline void lock() { pthread_mutex_lock(&mutex); } 98 inline void wait() { pthread_cond_wait(&cond, &mutex); } 99 inline void unlock() { pthread_mutex_unlock(&mutex); } 100 inline void signal() { pthread_cond_signal(&cond); } 101 }; 102 103 104 class AdrenoMemInfo : public android::Singleton <AdrenoMemInfo> 105 { 106 public: 107 AdrenoMemInfo(); 108 109 ~AdrenoMemInfo(); 110 111 /* 112 * Function to compute aligned width and aligned height based on 113 * width, height, format and usage flags. 114 * 115 * @return aligned width, aligned height 116 */ 117 void getAlignedWidthAndHeight(int width, int height, int format, 118 int usage, int& aligned_w, int& aligned_h); 119 120 /* 121 * Function to compute aligned width and aligned height based on 122 * private handle 123 * 124 * @return aligned width, aligned height 125 */ 126 void getAlignedWidthAndHeight(const private_handle_t *hnd, int& aligned_w, int& aligned_h); 127 128 /* 129 * Function to compute the adreno aligned width and aligned height 130 * based on the width and format. 131 * 132 * @return aligned width, aligned height 133 */ 134 void getGpuAlignedWidthHeight(int width, int height, int format, 135 int tileEnabled, int& alignedw, int &alignedh); 136 137 /* 138 * Function to compute unaligned width and unaligned height based on 139 * private handle 140 * 141 * @return unaligned width, unaligned height 142 */ 143 void getUnalignedWidthAndHeight(const private_handle_t *hnd, int& unaligned_w, 144 int& unaligned_h); 145 /* 146 * Function to query whether GPU supports UBWC for given HAL format 147 * @return > 0 : supported 148 * 0 : not supported 149 */ 150 int isUBWCSupportedByGPU(int format); 151 152 /* 153 * Function to get the corresponding Adreno format for given HAL format 154 */ 155 ADRENOPIXELFORMAT getGpuPixelFormat(int hal_format); 156 157 private: 158 // Overriding flag to disable UBWC alloc for graphics stack 159 int gfx_ubwc_disable; 160 // Pointer to the padding library. 161 void *libadreno_utils; 162 163 // link(s)to adreno surface padding library. 164 int (*LINK_adreno_compute_padding) (int width, int bpp, 165 int surface_tile_height, 166 int screen_tile_height, 167 int padding_threshold); 168 169 void (*LINK_adreno_compute_aligned_width_and_height) (int width, 170 int height, 171 int bpp, 172 int tile_mode, 173 int raster_mode, 174 int padding_threshold, 175 int *aligned_w, 176 int *aligned_h); 177 178 void(*LINK_adreno_compute_compressedfmt_aligned_width_and_height)( 179 int width, 180 int height, 181 int format, 182 int tile_mode, 183 int raster_mode, 184 int padding_threshold, 185 int *aligned_w, 186 int *aligned_h, 187 int *bpp); 188 189 int (*LINK_adreno_isUBWCSupportedByGpu) (ADRENOPIXELFORMAT format); 190 191 unsigned int (*LINK_adreno_get_gpu_pixel_alignment) (); 192 }; 193 194 195 class MDPCapabilityInfo : public android::Singleton <MDPCapabilityInfo> 196 { 197 int isUBwcSupported = 0; 198 int isWBUBWCSupported = 0; 199 200 public: 201 MDPCapabilityInfo(); 202 /* 203 * Function to return whether MDP supports UBWC feature 204 * 205 * @return 1 : supported 206 * 0 : not supported 207 */ 208 int isUBwcSupportedByMDP() { return isUBwcSupported; } 209 /* 210 * Function to return whether MDP WB block outputs UBWC format 211 * 212 * @return 1 : supported 213 * 0 : not supported 214 */ 215 int isWBUBWCSupportedByMDP() { return isWBUBWCSupported; } 216 }; 217 218 #endif /* GR_H_ */ 219
