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