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 allocFlags |= GRALLOC_USAGE_PRIVATE_UNCACHED; 125 } 126 127 int err = 0; 128 OVASSERT(numbufs && bufSz, "numbufs=%d bufSz=%d", numbufs, bufSz); 129 130 mBufSz = bufSz; 131 mNumBuffers = numbufs; 132 133 data.base = 0; 134 data.fd = -1; 135 data.offset = 0; 136 data.size = mBufSz * mNumBuffers; 137 data.align = getpagesize(); 138 data.uncached = true; 139 140 err = mAlloc->allocate(data, allocFlags); 141 if (err != 0) { 142 ALOGE("OvMem: Error allocating memory"); 143 return false; 144 } 145 146 mFd = data.fd; 147 mBaseAddr = data.base; 148 mAllocType = data.allocType; 149 150 return true; 151 } 152 153 inline bool OvMem::close() 154 { 155 int ret = 0; 156 157 if(!valid()) { 158 return true; 159 } 160 161 IMemAlloc* memalloc = mAlloc->getAllocator(mAllocType); 162 ret = memalloc->free_buffer(mBaseAddr, mBufSz * mNumBuffers, 0, mFd); 163 if (ret != 0) { 164 ALOGE("OvMem: error freeing buffer"); 165 return false; 166 } 167 168 mFd = -1; 169 mBaseAddr = MAP_FAILED; 170 mAllocType = 0; 171 mBufSz = 0; 172 mNumBuffers = 0; 173 return true; 174 } 175 176 inline bool OvMem::valid() const 177 { 178 return (mFd != -1) && (mBaseAddr != MAP_FAILED); 179 } 180 181 inline int OvMem::getFD() const 182 { 183 return mFd; 184 } 185 186 inline void* OvMem::addr() const 187 { 188 return mBaseAddr; 189 } 190 191 inline uint32_t OvMem::bufSz() const 192 { 193 return mBufSz; 194 } 195 196 inline uint32_t OvMem::numBufs() const 197 { 198 return mNumBuffers; 199 } 200 201 inline void OvMem::dump() const 202 { 203 ALOGE("== Dump OvMem start =="); 204 ALOGE("fd=%d addr=%p type=%d bufsz=%u", mFd, mBaseAddr, mAllocType, mBufSz); 205 ALOGE("== Dump OvMem end =="); 206 } 207 208 } // overlay 209 210 #endif // OVERLAY_MEM_H 211
