1 /* 2 * Copyright (c) 2011, 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 31 #ifndef OVERLAY_MEM_H 32 #define OVERLAY_MEM_H 33 34 #include <sys/mman.h> 35 #include <fcntl.h> 36 #include <alloc_controller.h> 37 #include <memalloc.h> 38 39 #include "gralloc_priv.h" 40 #include "overlayUtils.h" 41 42 namespace overlay { 43 44 /* 45 * Holds base address, offset and the fd 46 * */ 47 class OvMem { 48 public: 49 /* ctor init*/ 50 explicit OvMem(); 51 52 /* dtor DO NOT call close so it can be copied */ 53 ~OvMem(); 54 55 /* Use libgralloc to retrieve fd, base addr, alloc type */ 56 bool open(uint32_t numbufs, 57 uint32_t bufSz, bool isSecure); 58 59 /* close fd. assign base address to invalid*/ 60 bool close(); 61 62 /* return underlying fd */ 63 int getFD() const; 64 65 /* return true if fd is valid and base address is valid */ 66 bool valid() const; 67 68 /* dump the state of the object */ 69 void dump() const; 70 71 /* return underlying address */ 72 void* addr() const; 73 74 /* return underlying offset */ 75 uint32_t bufSz() const; 76 77 /* return number of bufs */ 78 uint32_t numBufs() const ; 79 80 private: 81 /* actual os fd */ 82 int mFd; 83 84 /* points to base addr (mmap)*/ 85 void* mBaseAddr; 86 87 /* allocated buffer type determined by gralloc (ashmem, ion, etc) */ 88 int mAllocType; 89 90 /* holds buf size */ 91 uint32_t mBufSz; 92 93 /* num of bufs */ 94 uint32_t mNumBuffers; 95 96 /* gralloc alloc controller */ 97 gralloc::IAllocController* mAlloc; 98 }; 99 100 //-------------------Inlines----------------------------------- 101 102 using gralloc::IMemAlloc; 103 using gralloc::alloc_data; 104 105 inline OvMem::OvMem() { 106 mFd = -1; 107 mBaseAddr = MAP_FAILED; 108 mAllocType = 0; 109 mBufSz = 0; 110 mNumBuffers = 0; 111 mAlloc = gralloc::IAllocController::getInstance(); 112 } 113 114 inline OvMem::~OvMem() { } 115 116 inline bool OvMem::open(uint32_t numbufs, 117 uint32_t bufSz, bool isSecure) 118 { 119 alloc_data data; 120 int allocFlags = GRALLOC_USAGE_PRIVATE_IOMMU_HEAP; 121 if(isSecure) { 122 allocFlags = GRALLOC_USAGE_PRIVATE_MM_HEAP; 123 allocFlags |= GRALLOC_USAGE_PROTECTED; 124 } 125 // Allocate uncached rotator buffers 126 allocFlags |= GRALLOC_USAGE_PRIVATE_UNCACHED; 127 128 int err = 0; 129 OVASSERT(numbufs && bufSz, "numbufs=%d bufSz=%d", numbufs, bufSz); 130 131 mBufSz = bufSz; 132 mNumBuffers = numbufs; 133 134 data.base = 0; 135 data.fd = -1; 136 data.offset = 0; 137 data.size = mBufSz * mNumBuffers; 138 data.align = getpagesize(); 139 data.uncached = true; 140 141 err = mAlloc->allocate(data, allocFlags); 142 if (err != 0) { 143 ALOGE("OvMem: Error allocating memory"); 144 return false; 145 } 146 147 mFd = data.fd; 148 mBaseAddr = data.base; 149 mAllocType = data.allocType; 150 151 return true; 152 } 153 154 inline bool OvMem::close() 155 { 156 int ret = 0; 157 158 if(!valid()) { 159 return true; 160 } 161 162 IMemAlloc* memalloc = mAlloc->getAllocator(mAllocType); 163 ret = memalloc->free_buffer(mBaseAddr, mBufSz * mNumBuffers, 0, mFd); 164 if (ret != 0) { 165 ALOGE("OvMem: error freeing buffer"); 166 return false; 167 } 168 169 mFd = -1; 170 mBaseAddr = MAP_FAILED; 171 mAllocType = 0; 172 mBufSz = 0; 173 mNumBuffers = 0; 174 return true; 175 } 176 177 inline bool OvMem::valid() const 178 { 179 return (mFd != -1) && (mBaseAddr != MAP_FAILED); 180 } 181 182 inline int OvMem::getFD() const 183 { 184 return mFd; 185 } 186 187 inline void* OvMem::addr() const 188 { 189 return mBaseAddr; 190 } 191 192 inline uint32_t OvMem::bufSz() const 193 { 194 return mBufSz; 195 } 196 197 inline uint32_t OvMem::numBufs() const 198 { 199 return mNumBuffers; 200 } 201 202 inline void OvMem::dump() const 203 { 204 ALOGE("== Dump OvMem start =="); 205 ALOGE("fd=%d addr=%p type=%d bufsz=%u", mFd, mBaseAddr, mAllocType, mBufSz); 206 ALOGE("== Dump OvMem end =="); 207 } 208 209 } // overlay 210 211 #endif // OVERLAY_MEM_H 212
