1 /*
2 * Copyright (c) 2011,2013 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 #ifndef OVERlAY_ROTATOR_H
31 #define OVERlAY_ROTATOR_H
32 
33 #include <stdlib.h>
34 
35 #include "mdpWrapper.h"
36 #include "overlayUtils.h"
37 #include "overlayMem.h"
38 #include "sync/sync.h"
39 
40 namespace overlay {
41 
42 /*
43    Manages the case where new rotator memory needs to be
44    allocated, before previous is freed, due to resolution change etc. If we make
45    rotator memory to be always max size, irrespctive of source resolution then
46    we don't need this RotMem wrapper. The inner class is sufficient.
47 */
48 struct RotMem {
49     // Max rotator buffers
50     enum { ROT_NUM_BUFS = 2 };
51     RotMem();
52     ~RotMem();
53     bool close();
validRotMem54     bool valid() { return mem.valid(); }
sizeRotMem55     uint32_t size() const { return mem.bufSz(); }
56     void setReleaseFd(const int& fence);
57 
58     // rotator data info dst offset
59     uint32_t mRotOffset[ROT_NUM_BUFS];
60     int mRelFence[ROT_NUM_BUFS];
61     // current slot being used
62     uint32_t mCurrIndex;
63     OvMem mem;
64 };
65 
66 class Rotator
67 {
68 public:
69     enum { TYPE_MDP, TYPE_MDSS };
70     virtual ~Rotator();
71     virtual void setSource(const utils::Whf& wfh) = 0;
72     virtual void setCrop(const utils::Dim& crop) = 0;
73     virtual void setFlags(const utils::eMdpFlags& flags) = 0;
74     virtual void setTransform(const utils::eTransform& rot) = 0;
75     virtual bool commit() = 0;
76     virtual void setDownscale(int ds) = 0;
77     //Mem id and offset should be retrieved only after rotator kickoff
78     virtual int getDstMemId() const = 0;
79     virtual uint32_t getDstOffset() const = 0;
80     //Destination width, height, format, position should be retrieved only after
81     //rotator configuration is committed via commit API
82     virtual uint32_t getDstFormat() const = 0;
83     virtual utils::Whf getDstWhf() const = 0;
84     virtual utils::Dim getDstDimensions() const = 0;
85     virtual uint32_t getSessId() const = 0;
86     virtual bool queueBuffer(int fd, uint32_t offset) = 0;
87     virtual void dump() const = 0;
88     virtual void getDump(char *buf, size_t len) const = 0;
setReleaseFd(const int & fence)89     void setReleaseFd(const int& fence) { mMem.setReleaseFd(fence); }
90     static Rotator *getRotator();
91 
92 protected:
93     /* Rotator memory manager */
94     RotMem mMem;
Rotator()95     explicit Rotator() {}
96     static uint32_t calcOutputBufSize(const utils::Whf& destWhf);
97 
98 private:
99     /*Returns rotator h/w type */
100     static int getRotatorHwType();
101     friend class RotMgr;
102 };
103 
104 /*
105 * MDP rot holds MDP's rotation related structures.
106 *
107 * */
108 class MdpRot : public Rotator {
109 public:
110     virtual ~MdpRot();
111     virtual void setSource(const utils::Whf& wfh);
112     virtual void setCrop(const utils::Dim& crop);
113     virtual void setFlags(const utils::eMdpFlags& flags);
114     virtual void setTransform(const utils::eTransform& rot);
115     virtual bool commit();
116     virtual void setDownscale(int ds);
117     virtual int getDstMemId() const;
118     virtual uint32_t getDstOffset() const;
119     virtual uint32_t getDstFormat() const;
120     virtual utils::Whf getDstWhf() const;
121     virtual utils::Dim getDstDimensions() const;
122     virtual uint32_t getSessId() const;
123     virtual bool queueBuffer(int fd, uint32_t offset);
124     virtual void dump() const;
125     virtual void getDump(char *buf, size_t len) const;
126 
127 private:
128     explicit MdpRot();
129     bool init();
130     bool close();
131     void setRotations(uint32_t r);
132     bool enabled () const;
133     /* remap rot buffers */
134     bool remap(uint32_t numbufs);
135     bool open_i(uint32_t numbufs, uint32_t bufsz);
136     /* Deferred transform calculations */
137     void doTransform();
138     /* reset underlying data, basically memset 0 */
139     void reset();
140     /* return true if current rotator config is different
141      * than last known config */
142     bool rotConfChanged() const;
143     /* save mRotImgInfo to be last known good config*/
144     void save();
145     /* Calculates the rotator's o/p buffer size post the transform calcs and
146      * knowing the o/p format depending on whether fastYuv is enabled or not */
147     uint32_t calcOutputBufSize();
148 
149     /* rot info*/
150     msm_rotator_img_info mRotImgInfo;
151     /* Last saved rot info*/
152     msm_rotator_img_info mLSRotImgInfo;
153     /* rot data */
154     msm_rotator_data_info mRotDataInfo;
155     /* Orientation */
156     utils::eTransform mOrientation;
157     /* rotator fd */
158     OvFD mFd;
159 
160     friend Rotator* Rotator::getRotator();
161 };
162 
163 /*
164 +* MDSS Rot holds MDSS's rotation related structures.
165 +*
166 +* */
167 class MdssRot : public Rotator {
168 public:
169     virtual ~MdssRot();
170     virtual void setSource(const utils::Whf& wfh);
171     virtual void setCrop(const utils::Dim& crop);
172     virtual void setFlags(const utils::eMdpFlags& flags);
173     virtual void setTransform(const utils::eTransform& rot);
174     virtual bool commit();
175     virtual void setDownscale(int ds);
176     virtual int getDstMemId() const;
177     virtual uint32_t getDstOffset() const;
178     virtual uint32_t getDstFormat() const;
179     virtual utils::Whf getDstWhf() const;
180     virtual utils::Dim getDstDimensions() const;
181     virtual uint32_t getSessId() const;
182     virtual bool queueBuffer(int fd, uint32_t offset);
183     virtual void dump() const;
184     virtual void getDump(char *buf, size_t len) const;
185 
186 private:
187     explicit MdssRot();
188     bool init();
189     bool close();
190     void setRotations(uint32_t r);
191     bool enabled () const;
192     /* remap rot buffers */
193     bool remap(uint32_t numbufs);
194     bool open_i(uint32_t numbufs, uint32_t bufsz);
195     /* Deferred transform calculations */
196     void doTransform();
197     /* reset underlying data, basically memset 0 */
198     void reset();
199     /* Calculates the rotator's o/p buffer size post the transform calcs and
200      * knowing the o/p format depending on whether fastYuv is enabled or not */
201     uint32_t calcOutputBufSize();
202     // Calculate the compressed o/p buffer size for BWC
203     uint32_t calcCompressedBufSize(const utils::Whf& destWhf);
204 
205     /* MdssRot info structure */
206     mdp_overlay   mRotInfo;
207     /* MdssRot data structure */
208     msmfb_overlay_data mRotData;
209     /* Orientation */
210     utils::eTransform mOrientation;
211     /* rotator fd */
212     OvFD mFd;
213     /* Enable/Disable Mdss Rot*/
214     bool mEnabled;
215 
216     friend Rotator* Rotator::getRotator();
217 };
218 
219 // Holder of rotator objects. Manages lifetimes
220 class RotMgr {
221 public:
222     //Virtually we can support as many rotator sessions as possible, However
223     // more number of rotator sessions leads to performance issues, so
224     // restricting the max rotator session to 4
225 #ifdef TARGET_SPECIFIC_MAX_ROT_SESSION
226     enum { MAX_ROT_SESS = TARGET_SPECIFIC_MAX_ROT_SESSION };
227 #else
228     enum { MAX_ROT_SESS = 4 };
229 #endif
230 
231     ~RotMgr();
232     void configBegin();
233     void configDone();
234     overlay::Rotator *getNext();
235     void clear(); //Removes all instances
236     //Resets the usage of top count objects, making them available for reuse
markUnusedTop(const uint32_t & count)237     void markUnusedTop(const uint32_t& count) { mUseCount -= count; }
238     /* Returns rot dump.
239      * Expects a NULL terminated buffer of big enough size.
240      */
241     void getDump(char *buf, size_t len);
242     int getRotDevFd();
getNumActiveSessions()243     int getNumActiveSessions() { return mUseCount; }
244 
245     static RotMgr *getInstance();
246 
247 private:
248     RotMgr();
249     static RotMgr *sRotMgr;
250 
251     overlay::Rotator *mRot[MAX_ROT_SESS];
252     uint32_t mUseCount;
253     int mRotDevFd;
254 };
255 
256 
257 } // overlay
258 
259 #endif // OVERlAY_ROTATOR_H
260