1/*
2* Copyright (c) 2011-2014, 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_UTILS_H
31#define OVERLAY_UTILS_H
32
33#include <cutils/log.h> // ALOGE, etc
34#include <errno.h>
35#include <fcntl.h> // open, O_RDWR, etc
36#include <hardware/hardware.h>
37#include <hardware/gralloc.h> // buffer_handle_t
38#include <linux/msm_mdp.h> // flags
39#include <linux/msm_rotator.h>
40#include <stdio.h>
41#include <stdlib.h>
42#include <string.h>
43#include <sys/stat.h>
44#include <sys/types.h>
45#include <utils/Log.h>
46#include "gralloc_priv.h" //for interlace
47
48// Older platforms do not support Venus
49#ifndef VENUS_COLOR_FORMAT
50#define MDP_Y_CBCR_H2V2_VENUS MDP_IMGTYPE_LIMIT
51#endif
52
53/*
54*
55* Collection of utilities functions/structs/enums etc...
56*
57* */
58
59// comment that out if you want to remove asserts
60// or put it as -D in Android.mk. your choice.
61#define OVERLAY_HAS_ASSERT
62
63#ifdef OVERLAY_HAS_ASSERT
64# define OVASSERT(x, ...) if(!(x)) { ALOGE(__VA_ARGS__); abort(); }
65#else
66# define OVASSERT(x, ...) ALOGE_IF(!(x), __VA_ARGS__)
67#endif // OVERLAY_HAS_ASSERT
68
69#define DEBUG_OVERLAY 0
70#define PROFILE_OVERLAY 0
71
72#ifndef MDSS_MDP_RIGHT_MIXER
73#define MDSS_MDP_RIGHT_MIXER 0x100
74#endif
75
76#ifndef MDP_OV_PIPE_FORCE_DMA
77#define MDP_OV_PIPE_FORCE_DMA 0x4000
78#endif
79
80#ifndef MDSS_MDP_DUAL_PIPE
81#define MDSS_MDP_DUAL_PIPE 0x200
82#endif
83
84#define FB_DEVICE_TEMPLATE "/dev/graphics/fb%u"
85
86namespace overlay {
87
88// fwd
89class Overlay;
90class OvFD;
91
92/* helper function to open by using fbnum */
93bool open(OvFD& fd, uint32_t fbnum, const char* const dev,
94    int flags = O_RDWR);
95
96namespace utils {
97struct Whf;
98struct Dim;
99
100inline uint32_t setBit(uint32_t x, uint32_t mask) {
101    return (x | mask);
102}
103
104inline uint32_t clrBit(uint32_t x, uint32_t mask) {
105    return (x & ~mask);
106}
107
108/* Utility class to help avoid copying instances by making the copy ctor
109* and assignment operator private
110*
111* Usage:
112*    class SomeClass : utils::NoCopy {...};
113*/
114class NoCopy {
115protected:
116    NoCopy(){}
117    ~NoCopy() {}
118private:
119    NoCopy(const NoCopy&);
120    const NoCopy& operator=(const NoCopy&);
121};
122
123bool isMdssRotator();
124void normalizeCrop(uint32_t& xy, uint32_t& wh);
125
126template <class Type>
127void swapWidthHeight(Type& width, Type& height);
128
129struct Dim {
130    Dim () : x(0), y(0),
131    w(0), h(0),
132    o(0) {}
133    Dim(uint32_t _x, uint32_t _y, uint32_t _w, uint32_t _h) :
134        x(_x), y(_y),
135        w(_w), h(_h) {}
136    Dim(uint32_t _x, uint32_t _y, uint32_t _w, uint32_t _h, uint32_t _o) :
137        x(_x), y(_y),
138        w(_w), h(_h),
139        o(_o) {}
140    bool check(uint32_t _w, uint32_t _h) const {
141        return (x+w <= _w && y+h <= _h);
142
143    }
144
145    bool operator==(const Dim& d) const {
146        return d.x == x && d.y == y &&
147                d.w == w && d.h == h &&
148                d.o == o;
149    }
150
151    bool operator!=(const Dim& d) const {
152        return !operator==(d);
153    }
154
155    void dump() const;
156    uint32_t x;
157    uint32_t y;
158    uint32_t w;
159    uint32_t h;
160    uint32_t o;
161};
162
163// TODO have Whfz
164
165struct Whf {
166    Whf() : w(0), h(0), format(0), size(0) {}
167    Whf(uint32_t wi, uint32_t he, uint32_t f) :
168        w(wi), h(he), format(f), size(0) {}
169    Whf(uint32_t wi, uint32_t he, uint32_t f, uint32_t s) :
170        w(wi), h(he), format(f), size(s) {}
171    // FIXME not comparing size at the moment
172    bool operator==(const Whf& whf) const {
173        return whf.w == w && whf.h == h &&
174                whf.format == format;
175    }
176    bool operator!=(const Whf& whf) const {
177        return !operator==(whf);
178    }
179    void dump() const;
180    uint32_t w;
181    uint32_t h;
182    uint32_t format;
183    uint32_t size;
184};
185
186enum { MAX_PATH_LEN = 256 };
187
188enum { DEFAULT_PLANE_ALPHA = 0xFF };
189
190/**
191 * Rotator flags: not to be confused with orientation flags.
192 * Usually, you want to open the rotator to make sure it is
193 * ready for business.
194 * */
195 enum eRotFlags {
196    ROT_FLAGS_NONE = 0,
197    //Use rotator for 0 rotation. It is used anyway for others.
198    ROT_0_ENABLED = 1 << 0,
199    //Enable rotator downscale optimization for hardware bugs not handled in
200    //driver. If downscale optimizatation is required,
201    //then rotator will be used even if its 0 rotation case.
202    ROT_DOWNSCALE_ENABLED = 1 << 1,
203    ROT_PREROTATED = 1 << 2,
204};
205
206enum eRotDownscale {
207    ROT_DS_NONE = 0,
208    ROT_DS_HALF = 1,
209    ROT_DS_FOURTH = 2,
210    ROT_DS_EIGHTH = 3,
211};
212
213/*
214 * Various mdp flags like PIPE SHARE, DEINTERLACE etc...
215 * kernel/common/linux/msm_mdp.h
216 * INTERLACE_MASK: hardware/qcom/display/libgralloc/badger/fb_priv.h
217 * */
218enum eMdpFlags {
219    OV_MDP_FLAGS_NONE = 0,
220    OV_MDP_PIPE_SHARE =  MDP_OV_PIPE_SHARE,
221    OV_MDP_PIPE_FORCE_DMA = MDP_OV_PIPE_FORCE_DMA,
222    OV_MDP_DEINTERLACE = MDP_DEINTERLACE,
223    OV_MDP_SECURE_OVERLAY_SESSION = MDP_SECURE_OVERLAY_SESSION,
224    OV_MDP_SECURE_DISPLAY_OVERLAY_SESSION = MDP_SECURE_DISPLAY_OVERLAY_SESSION,
225    OV_MDP_SOURCE_ROTATED_90 = MDP_SOURCE_ROTATED_90,
226    OV_MDP_BLEND_FG_PREMULT = MDP_BLEND_FG_PREMULT,
227    OV_MDP_FLIP_H = MDP_FLIP_LR,
228    OV_MDP_FLIP_V = MDP_FLIP_UD,
229    OV_MDSS_MDP_RIGHT_MIXER = MDSS_MDP_RIGHT_MIXER,
230    OV_MDP_PP_EN = MDP_OVERLAY_PP_CFG_EN,
231    OV_MDSS_MDP_BWC_EN = MDP_BWC_EN,
232    OV_MDSS_MDP_DUAL_PIPE = MDSS_MDP_DUAL_PIPE,
233    OV_MDP_SOLID_FILL = MDP_SOLID_FILL,
234    OV_MDP_SMP_FORCE_ALLOC = MDP_SMP_FORCE_ALLOC,
235};
236
237enum eZorder {
238    ZORDER_0 = 0,
239    ZORDER_1,
240    ZORDER_2,
241    ZORDER_3,
242    ZORDER_4,
243    ZORDER_5,
244    ZORDER_6,
245    Z_SYSTEM_ALLOC = 0xFFFF
246};
247
248enum eMdpPipeType {
249    OV_MDP_PIPE_RGB = 0,
250    OV_MDP_PIPE_VG,
251    OV_MDP_PIPE_DMA,
252    OV_MDP_PIPE_ANY, //Any
253};
254
255// Identify destination pipes
256// TODO Names useless, replace with int and change all interfaces
257enum eDest {
258    OV_P0 = 0,
259    OV_P1,
260    OV_P2,
261    OV_P3,
262    OV_P4,
263    OV_P5,
264    OV_P6,
265    OV_P7,
266    OV_P8,
267    OV_P9,
268    OV_INVALID,
269    OV_MAX = OV_INVALID,
270};
271
272/* Used when a buffer is split over 2 pipes and sent to display */
273enum {
274    OV_LEFT_SPLIT = 0,
275    OV_RIGHT_SPLIT,
276};
277
278/* values for copybit_set_parameter(OVERLAY_TRANSFORM) */
279enum eTransform {
280    /* No rot */
281    OVERLAY_TRANSFORM_0 = 0x0,
282    /* flip source image horizontally 0x1 */
283    OVERLAY_TRANSFORM_FLIP_H = HAL_TRANSFORM_FLIP_H,
284    /* flip source image vertically 0x2 */
285    OVERLAY_TRANSFORM_FLIP_V = HAL_TRANSFORM_FLIP_V,
286    /* rotate source image 180 degrees
287     * It is basically bit-or-ed  H | V == 0x3 */
288    OVERLAY_TRANSFORM_ROT_180 = HAL_TRANSFORM_ROT_180,
289    /* rotate source image 90 degrees 0x4 */
290    OVERLAY_TRANSFORM_ROT_90 = HAL_TRANSFORM_ROT_90,
291    /* rotate source image 90 degrees and flip horizontally 0x5 */
292    OVERLAY_TRANSFORM_ROT_90_FLIP_H = HAL_TRANSFORM_ROT_90 |
293                                      HAL_TRANSFORM_FLIP_H,
294    /* rotate source image 90 degrees and flip vertically 0x6 */
295    OVERLAY_TRANSFORM_ROT_90_FLIP_V = HAL_TRANSFORM_ROT_90 |
296                                      HAL_TRANSFORM_FLIP_V,
297    /* rotate source image 270 degrees
298     * Basically 180 | 90 == 0x7 */
299    OVERLAY_TRANSFORM_ROT_270 = HAL_TRANSFORM_ROT_270,
300    /* rotate invalid like in Transform.h */
301    OVERLAY_TRANSFORM_INV = 0x80
302};
303
304enum eBlending {
305    OVERLAY_BLENDING_UNDEFINED = 0x0,
306    /* No blending */
307    OVERLAY_BLENDING_OPAQUE,
308    /* src.rgb + dst.rgb*(1-src_alpha) */
309    OVERLAY_BLENDING_PREMULT,
310    /* src.rgb * src_alpha + dst.rgb (1 - src_alpha) */
311    OVERLAY_BLENDING_COVERAGE,
312};
313
314// Used to consolidate pipe params
315struct PipeArgs {
316    PipeArgs() : mdpFlags(OV_MDP_FLAGS_NONE),
317        zorder(Z_SYSTEM_ALLOC),
318        rotFlags(ROT_FLAGS_NONE),
319        planeAlpha(DEFAULT_PLANE_ALPHA),
320        blending(OVERLAY_BLENDING_COVERAGE){
321    }
322
323    PipeArgs(eMdpFlags f, Whf _whf,
324            eZorder z, eRotFlags r,
325            int pA = DEFAULT_PLANE_ALPHA, eBlending b = OVERLAY_BLENDING_COVERAGE) :
326        mdpFlags(f),
327        whf(_whf),
328        zorder(z),
329        rotFlags(r),
330        planeAlpha(pA),
331        blending(b){
332    }
333
334    eMdpFlags mdpFlags; // for mdp_overlay flags
335    Whf whf;
336    eZorder zorder; // stage number
337    eRotFlags rotFlags;
338    int planeAlpha;
339    eBlending blending;
340};
341
342// Cannot use HW_OVERLAY_MAGNIFICATION_LIMIT, since at the time
343// of integration, HW_OVERLAY_MAGNIFICATION_LIMIT was a define
344enum { HW_OV_MAGNIFICATION_LIMIT = 20,
345    HW_OV_MINIFICATION_LIMIT  = 8
346};
347
348inline void setMdpFlags(eMdpFlags& f, eMdpFlags v) {
349    f = static_cast<eMdpFlags>(setBit(f, v));
350}
351
352inline void clearMdpFlags(eMdpFlags& f, eMdpFlags v) {
353    f = static_cast<eMdpFlags>(clrBit(f, v));
354}
355
356enum { FB0, FB1, FB2 };
357
358struct ScreenInfo {
359    ScreenInfo() : mFBWidth(0),
360    mFBHeight(0),
361    mFBbpp(0),
362    mFBystride(0) {}
363    void dump(const char* const s) const;
364    uint32_t mFBWidth;
365    uint32_t mFBHeight;
366    uint32_t mFBbpp;
367    uint32_t mFBystride;
368};
369
370int getMdpFormat(int format);
371int getMdpFormat(int format, int flags);
372int getHALFormat(int mdpFormat);
373void getDecimationFactor(const int& src_w, const int& src_h,
374        const int& dst_w, const int& dst_h, uint8_t& horzDeci,
375        uint8_t& vertDeci);
376
377/* flip is upside down and such. V, H flip
378 * rotation is 90, 180 etc
379 * It returns MDP related enum/define that match rot+flip*/
380int getMdpOrient(eTransform rotation);
381const char* getFormatString(int format);
382
383template <class T>
384inline void memset0(T& t) { ::memset(&t, 0, sizeof(t)); }
385
386template <class T> inline void swap ( T& a, T& b )
387{
388    T c(a); a=b; b=c;
389}
390
391template<typename T> inline T max(T a, T b) { return (a > b) ? a : b; }
392
393template<typename T> inline T min(T a, T b) { return (a < b) ? a : b; }
394
395inline int alignup(int value, int a) {
396    //if align = 0, return the value. Else, do alignment.
397    return a ? ((((value - 1) / a) + 1) * a) : value;
398}
399
400inline int aligndown(int value, int a) {
401    //if align = 0, return the value. Else, do alignment.
402    return a ? ((value) & ~(a-1)) : value;
403}
404
405// FIXME that align should replace the upper one.
406inline int align(int value, int a) {
407    //if align = 0, return the value. Else, do alignment.
408    return a ? ((value + (a-1)) & ~(a-1)) : value;
409}
410
411inline bool isYuv(uint32_t format) {
412    switch(format){
413        case MDP_Y_CBCR_H2V1:
414        case MDP_Y_CBCR_H2V2:
415        case MDP_Y_CRCB_H2V2:
416        case MDP_Y_CRCB_H1V1:
417        case MDP_Y_CRCB_H2V1:
418        case MDP_Y_CRCB_H2V2_TILE:
419        case MDP_Y_CBCR_H2V2_TILE:
420        case MDP_Y_CR_CB_H2V2:
421        case MDP_Y_CR_CB_GH2V2:
422        case MDP_Y_CBCR_H2V2_VENUS:
423        case MDP_YCBYCR_H2V1:
424        case MDP_YCRYCB_H2V1:
425            return true;
426        default:
427            return false;
428    }
429    return false;
430}
431
432inline bool isRgb(uint32_t format) {
433    switch(format) {
434        case MDP_RGBA_8888:
435        case MDP_BGRA_8888:
436        case MDP_RGBX_8888:
437        case MDP_RGB_565:
438        case MDP_RGBA_4444:
439        case MDP_RGBA_5551:
440            return true;
441        default:
442            return false;
443    }
444    return false;
445}
446
447inline const char* getFormatString(int format){
448    #define STR(f) #f;
449    static const char* formats[MDP_IMGTYPE_LIMIT + 1] = {0};
450    formats[MDP_RGB_565] = STR(MDP_RGB_565);
451    formats[MDP_RGBA_5551] = STR(MDP_RGBA_5551);
452    formats[MDP_RGBA_4444] = STR(MDP_RGBA_4444);
453    formats[MDP_XRGB_8888] = STR(MDP_XRGB_8888);
454    formats[MDP_Y_CBCR_H2V2] = STR(MDP_Y_CBCR_H2V2);
455    formats[MDP_Y_CBCR_H2V2_ADRENO] = STR(MDP_Y_CBCR_H2V2_ADRENO);
456    formats[MDP_ARGB_8888] = STR(MDP_ARGB_8888);
457    formats[MDP_RGB_888] = STR(MDP_RGB_888);
458    formats[MDP_Y_CRCB_H2V2] = STR(MDP_Y_CRCB_H2V2);
459    formats[MDP_YCBYCR_H2V1] = STR(MDP_YCBYCR_H2V1);
460    formats[MDP_YCRYCB_H2V1] = STR(MDP_YCRYCB_H2V1);
461    formats[MDP_CBYCRY_H2V1] = STR(MDP_CBYCRY_H2V1);
462    formats[MDP_Y_CRCB_H2V1] = STR(MDP_Y_CRCB_H2V1);
463    formats[MDP_Y_CBCR_H2V1] = STR(MDP_Y_CBCR_H2V1);
464    formats[MDP_Y_CRCB_H1V2] = STR(MDP_Y_CRCB_H1V2);
465    formats[MDP_Y_CBCR_H1V2] = STR(MDP_Y_CBCR_H1V2);
466    formats[MDP_RGBA_8888] = STR(MDP_RGBA_8888);
467    formats[MDP_BGRA_8888] = STR(MDP_BGRA_8888);
468    formats[MDP_RGBX_8888] = STR(MDP_RGBX_8888);
469    formats[MDP_Y_CRCB_H2V2_TILE] = STR(MDP_Y_CRCB_H2V2_TILE);
470    formats[MDP_Y_CBCR_H2V2_TILE] = STR(MDP_Y_CBCR_H2V2_TILE);
471    formats[MDP_Y_CR_CB_H2V2] = STR(MDP_Y_CR_CB_H2V2);
472    formats[MDP_Y_CR_CB_GH2V2] = STR(MDP_Y_CR_CB_GH2V2);
473    formats[MDP_Y_CB_CR_H2V2] = STR(MDP_Y_CB_CR_H2V2);
474    formats[MDP_Y_CRCB_H1V1] = STR(MDP_Y_CRCB_H1V1);
475    formats[MDP_Y_CBCR_H1V1] = STR(MDP_Y_CBCR_H1V1);
476    formats[MDP_YCRCB_H1V1] = STR(MDP_YCRCB_H1V1);
477    formats[MDP_YCBCR_H1V1] = STR(MDP_YCBCR_H1V1);
478    formats[MDP_BGR_565] = STR(MDP_BGR_565);
479    formats[MDP_BGR_888] = STR(MDP_BGR_888);
480    formats[MDP_Y_CBCR_H2V2_VENUS] = STR(MDP_Y_CBCR_H2V2_VENUS);
481    formats[MDP_BGRX_8888] = STR(MDP_BGRX_8888);
482    formats[MDP_RGBA_8888_TILE] = STR(MDP_RGBA_8888_TILE);
483    formats[MDP_ARGB_8888_TILE] = STR(MDP_ARGB_8888_TILE);
484    formats[MDP_ABGR_8888_TILE] = STR(MDP_ABGR_8888_TILE);
485    formats[MDP_BGRA_8888_TILE] = STR(MDP_BGRA_8888_TILE);
486    formats[MDP_RGBX_8888_TILE] = STR(MDP_RGBX_8888_TILE);
487    formats[MDP_XRGB_8888_TILE] = STR(MDP_XRGB_8888_TILE);
488    formats[MDP_XBGR_8888_TILE] = STR(MDP_XBGR_8888_TILE);
489    formats[MDP_BGRX_8888_TILE] = STR(MDP_BGRX_8888_TILE);
490    formats[MDP_RGB_565_TILE] = STR(MDP_RGB_565_TILE);
491    formats[MDP_IMGTYPE_LIMIT] = STR(MDP_IMGTYPE_LIMIT);
492
493    if(format < 0 || format >= MDP_IMGTYPE_LIMIT) {
494        ALOGE("%s wrong fmt %d", __FUNCTION__, format);
495        return "Unsupported format";
496    }
497    if(formats[format] == 0) {
498        ALOGE("%s: table missing format %d from header", __FUNCTION__, format);
499        return "";
500    }
501    return formats[format];
502}
503
504inline void Whf::dump() const {
505    ALOGE("== Dump WHF w=%d h=%d f=%d s=%d start/end ==",
506            w, h, format, size);
507}
508
509inline void Dim::dump() const {
510    ALOGE("== Dump Dim x=%d y=%d w=%d h=%d start/end ==", x, y, w, h);
511}
512
513template <class Type>
514void swapWidthHeight(Type& width, Type& height) {
515    Type tmp = width;
516    width = height;
517    height = tmp;
518}
519
520inline void ScreenInfo::dump(const char* const s) const {
521    ALOGE("== Dump %s ScreenInfo w=%d h=%d"
522            " bpp=%d stride=%d start/end ==",
523            s, mFBWidth, mFBHeight, mFBbpp, mFBystride);
524}
525
526inline bool openDev(OvFD& fd, int fbnum,
527    const char* const devpath, int flags) {
528    return overlay::open(fd, fbnum, devpath, flags);
529}
530
531template <class T>
532inline void even_ceil(T& value) {
533    if(value & 1)
534        value++;
535}
536
537template <class T>
538inline void even_floor(T& value) {
539    if(value & 1)
540        value--;
541}
542
543/* Prerotation adjusts crop co-ordinates to the new transformed values within
544 * destination buffer. This is necessary only when the entire buffer is rotated
545 * irrespective of crop (A-family). If only the crop portion of the buffer is
546 * rotated into a destination buffer matching the size of crop, we don't need to
547 * use this helper (B-family).
548 * @Deprecated as of now, retained for the case where a full buffer needs
549 * transform and also as a reference.
550 */
551void preRotateSource(const eTransform& tr, Whf& whf, Dim& srcCrop);
552void getDump(char *buf, size_t len, const char *prefix, const mdp_overlay& ov);
553void getDump(char *buf, size_t len, const char *prefix, const msmfb_img& ov);
554void getDump(char *buf, size_t len, const char *prefix, const mdp_rect& ov);
555void getDump(char *buf, size_t len, const char *prefix,
556        const msmfb_overlay_data& ov);
557void getDump(char *buf, size_t len, const char *prefix, const msmfb_data& ov);
558void getDump(char *buf, size_t len, const char *prefix,
559        const msm_rotator_img_info& ov);
560void getDump(char *buf, size_t len, const char *prefix,
561        const msm_rotator_data_info& ov);
562
563} // namespace utils ends
564
565//--------------------Class Res stuff (namespace overlay only) -----------
566
567class Res {
568public:
569    // /dev/graphics/fb%u
570    static const char* const fbPath;
571    // /dev/msm_rotator
572    static const char* const rotPath;
573};
574
575
576//--------------------Class OvFD stuff (namespace overlay only) -----------
577
578/*
579* Holds one FD
580* Dtor will NOT close the underlying FD.
581* That enables us to copy that object around
582* */
583class OvFD {
584public:
585    /* Ctor */
586    explicit OvFD();
587
588    /* dtor will NOT close the underlying FD */
589    ~OvFD();
590
591    /* Open fd using the path given by dev.
592     * return false in failure */
593    bool open(const char* const dev,
594            int flags = O_RDWR);
595
596    /* populate path */
597    void setPath(const char* const dev);
598
599    /* Close fd if we have a valid fd. */
600    bool close();
601
602    /* returns underlying fd.*/
603    int getFD() const;
604
605    /* returns true if fd is valid */
606    bool valid() const;
607
608    /* like operator= */
609    void copy(int fd);
610
611    /* dump the state of the instance */
612    void dump() const;
613private:
614    /* helper enum for determine valid/invalid fd */
615    enum { INVAL = -1 };
616
617    /* actual os fd */
618    int mFD;
619
620    /* path, for debugging */
621    char mPath[utils::MAX_PATH_LEN];
622};
623
624//-------------------Inlines--------------------------
625
626inline bool open(OvFD& fd, uint32_t fbnum, const char* const dev, int flags)
627{
628    char dev_name[64] = {0};
629    snprintf(dev_name, sizeof(dev_name), dev, fbnum);
630    return fd.open(dev_name, flags);
631}
632
633inline OvFD::OvFD() : mFD (INVAL) {
634    mPath[0] = 0;
635}
636
637inline OvFD::~OvFD() {
638    //no op since copy() can be used to share fd, in 3d cases.
639}
640
641inline bool OvFD::open(const char* const dev, int flags)
642{
643    mFD = ::open(dev, flags, 0);
644    if (mFD < 0) {
645        // FIXME errno, strerror in bionic?
646        ALOGE("Cant open device %s err=%d", dev, errno);
647        return false;
648    }
649    setPath(dev);
650    return true;
651}
652
653inline void OvFD::setPath(const char* const dev)
654{
655    ::strlcpy(mPath, dev, sizeof(mPath));
656}
657
658inline bool OvFD::close()
659{
660    int ret = 0;
661    if(valid()) {
662        ret = ::close(mFD);
663        mFD = INVAL;
664    }
665    return (ret == 0);
666}
667
668inline bool OvFD::valid() const
669{
670    return (mFD != INVAL);
671}
672
673inline int OvFD::getFD() const { return mFD; }
674
675inline void OvFD::copy(int fd) {
676    mFD = fd;
677}
678
679inline void OvFD::dump() const
680{
681    ALOGE("== Dump OvFD fd=%d path=%s start/end ==",
682            mFD, mPath);
683}
684
685//--------------- class OvFD stuff ends ---------------------
686
687} // overlay
688
689
690#endif // OVERLAY_UTILS_H
691