liboverlay/overlayWriteback.h

/*
* Copyright (c) 2013 The Linux Foundation. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*    * Redistributions of source code must retain the above copyright
*      notice, this list of conditions and the following disclaimer.
*    * Redistributions in binary form must reproduce the above
*      copyright notice, this list of conditions and the following
*      disclaimer in the documentation and/or other materials provided
*      with the distribution.
*    * Neither the name of The Linux Foundation. nor the names of its
*      contributors may be used to endorse or promote products derived
*      from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef OVERLAY_WRITEBACK_H
#define OVERLAY_WRITEBACK_H

#include "overlayMem.h"

namespace overlay {

class WritebackMgr;

class WritebackMem {
public:
    explicit WritebackMem() : mCurrOffsetIndex(0) {
        memset(&mOffsets, 0, sizeof(mOffsets));
    }
    ~WritebackMem() { dealloc(); }
    bool manageMem(uint32_t size, bool isSecure);
    void useNextBuffer() {
            mCurrOffsetIndex = (mCurrOffsetIndex + 1) % NUM_BUFS;
    }
    uint32_t getOffset() const { return mOffsets[mCurrOffsetIndex]; }
    int getDstFd() const { return mBuf.getFD(); }
private:
    bool alloc(uint32_t size, bool isSecure);
    bool dealloc();
    enum { NUM_BUFS = 2 };
    OvMem mBuf;
    uint32_t mOffsets[NUM_BUFS];
    uint32_t mCurrOffsetIndex;
};

//Abstracts the WB2 interface of MDP
//Has modes to either manage memory or work with memory allocated elsewhere
class Writeback {
public:
    ~Writeback();
    bool configureDpyInfo(int xres, int yres);
    bool configureMemory(uint32_t size, bool isSecure);
    /* Blocking write. (queue, commit, dequeue)
     * This class will do writeback memory management.
     * This class will call display-commit on writeback mixer.
     */
    bool writeSync();
    /* Blocking write. (queue, commit, dequeue)
     * Client must do writeback memory management.
     * Client must not call display-commit on writeback mixer.
     */
    bool writeSync(int opFd, uint32_t opOffset);
    /* Async queue. (Does not write)
     * Client must do writeback memory management.
     * Client must call display-commit on their own.
     * Client must use sync mechanism e.g sync pt.
     */
    bool queueBuffer(int opFd, uint32_t opOffset);
    uint32_t getOffset() const { return mWbMem.getOffset(); }
    int getDstFd() const { return mWbMem.getDstFd(); }
    /* Subject to GC if writeback isnt used for a drawing round.
     * Get always if caching the value.
     */
    int getFbFd() const { return mFd.getFD(); }
    int getOutputFormat();
    bool setOutputFormat(int mdpFormat);

    static Writeback* getInstance();
    static void configBegin() { sUsed = false; }
    static void configDone();
    static void clear();
    //Will take a dump of data structure only if there is an instance existing
    //Returns true if dump is added to the input buffer, false otherwise
    static bool getDump(char *buf, size_t len);

private:
    explicit Writeback();
    bool startSession();
    bool stopSession();
    //Actually block_until_write_done for the usage here.
    bool dequeueBuffer();
    OvFD mFd;
    WritebackMem mWbMem;
    struct msmfb_data mFbData;
    int mXres;
    int mYres;
    int mOpFmt;

    static bool sUsed;
    static Writeback *sWb;
};

}

#endif