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
OvMem()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
~OvMem()114 inline OvMem::~OvMem() { }
115
open(uint32_t numbufs,uint32_t bufSz,bool isSecure)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
close()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
valid()176 inline bool OvMem::valid() const
177 {
178 return (mFd != -1) && (mBaseAddr != MAP_FAILED);
179 }
180
getFD()181 inline int OvMem::getFD() const
182 {
183 return mFd;
184 }
185
addr()186 inline void* OvMem::addr() const
187 {
188 return mBaseAddr;
189 }
190
bufSz()191 inline uint32_t OvMem::bufSz() const
192 {
193 return mBufSz;
194 }
195
numBufs()196 inline uint32_t OvMem::numBufs() const
197 {
198 return mNumBuffers;
199 }
200
dump()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