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