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
42namespace overlay {
43
44/*
45* Holds base address, offset and the fd
46* */
47class OvMem {
48public:
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
80private:
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
102using gralloc::IMemAlloc;
103using gralloc::alloc_data;
104
105inline 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
114inline OvMem::~OvMem() { }
115
116inline 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
153inline 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
176inline bool OvMem::valid() const
177{
178    return (mFd != -1) && (mBaseAddr != MAP_FAILED);
179}
180
181inline int OvMem::getFD() const
182{
183    return mFd;
184}
185
186inline void* OvMem::addr() const
187{
188    return mBaseAddr;
189}
190
191inline uint32_t OvMem::bufSz() const
192{
193    return mBufSz;
194}
195
196inline uint32_t OvMem::numBufs() const
197{
198    return mNumBuffers;
199}
200
201inline 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