First hwcomposer code drop for marvin

Issued from Intel internal commit : 58771d

Change-Id: I8437d663e3b9baa0164517c0ece83b77b5864e8f
Signed-off-by: Benjamin Pujol <benjamin.pujol@intel.com>
Signed-off-by: Victor Tasayco Loarte <victorx.tasayco.loarte@intel.com>
Signed-off-by: Guilhem IMBERTON <guilhem.imberton@intel.com>

1 files changed, 196 insertions, 0 deletions

diff --git a/merrifield/ips/tangier/TngPlaneManager.cpp b/merrifield/ips/tangier/TngPlaneManager.cpp
new file mode 100644
index 0000000..d973aa9
--- /dev/null
+++ b/merrifield/ips/tangier/TngPlaneManager.cpp
@@ -0,0 +1,196 @@
+/*
+// Copyright (c) 2014 Intel Corporation 
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+#include <HwcTrace.h>
+#include <tangier/TngPlaneManager.h>
+#include <tangier/TngPrimaryPlane.h>
+#include <tangier/TngSpritePlane.h>
+#include <tangier/TngOverlayPlane.h>
+#include <tangier/TngCursorPlane.h>
+
+namespace android {
+namespace intel {
+
+TngPlaneManager::TngPlaneManager()
+    : DisplayPlaneManager()
+{
+    memset(&mZorder, 0, sizeof(mZorder));
+}
+
+TngPlaneManager::~TngPlaneManager()
+{
+}
+
+bool TngPlaneManager::initialize()
+{
+    mSpritePlaneCount = 1;  // Sprite D
+    mOverlayPlaneCount = 2;  // Overlay A & C
+    mPrimaryPlaneCount = 3;  // Primary A, B, C
+    mCursorPlaneCount = 3;
+
+    return DisplayPlaneManager::initialize();
+}
+
+void TngPlaneManager::deinitialize()
+{
+    DisplayPlaneManager::deinitialize();
+}
+
+DisplayPlane* TngPlaneManager::allocPlane(int index, int type)
+{
+    DisplayPlane *plane = 0;
+
+    switch (type) {
+    case DisplayPlane::PLANE_PRIMARY:
+        plane = new TngPrimaryPlane(index, index);
+        break;
+    case DisplayPlane::PLANE_SPRITE:
+        plane = new TngSpritePlane(index, 0);
+        break;
+    case DisplayPlane::PLANE_OVERLAY:
+        plane = new TngOverlayPlane(index, 0);
+        break;
+    case DisplayPlane::PLANE_CURSOR:
+        plane = new TngCursorPlane(index, index /*disp */);
+        break;
+    default:
+        ETRACE("unsupported type %d", type);
+        break;
+    }
+    if (plane && !plane->initialize(DisplayPlane::MIN_DATA_BUFFER_COUNT)) {
+        ETRACE("failed to initialize plane.");
+        DEINIT_AND_DELETE_OBJ(plane);
+    }
+
+    return plane;
+}
+
+bool TngPlaneManager::isValidZOrder(int dsp, ZOrderConfig& config)
+{
+    // check whether it's a supported z order config
+    int firstRGB = -1;
+    int lastRGB = -1;
+    int firstOverlay = -1;
+    int lastOverlay = -1;
+
+    for (int i = 0; i < (int)config.size(); i++) {
+        const ZOrderLayer *layer = config[i];
+        switch (layer->planeType) {
+        case DisplayPlane::PLANE_PRIMARY:
+        case DisplayPlane::PLANE_SPRITE:
+            if (firstRGB == -1) {
+                firstRGB = i;
+                lastRGB = i;
+            } else {
+                lastRGB = i;
+            }
+            break;
+        case DisplayPlane::PLANE_OVERLAY:
+        case DisplayPlane::PLANE_CURSOR:
+            if (firstOverlay == -1) {
+                firstOverlay = i;
+                lastOverlay = i;
+            } else {
+                lastOverlay = i;
+            }
+            break;
+        }
+    }
+
+    if ((lastRGB < firstOverlay) || (firstRGB > lastOverlay)) {
+        return true;
+    } else {
+        VTRACE("invalid z order config. rgb (%d, %d) yuv (%d, %d)",
+               firstRGB, lastRGB, firstOverlay, lastOverlay);
+        return false;
+    }
+}
+
+bool TngPlaneManager::assignPlanes(int dsp, ZOrderConfig& config)
+{
+    // probe if plane is available
+    int size = (int)config.size();
+    for (int i = 0; i < size; i++) {
+        const ZOrderLayer *layer = config.itemAt(i);
+        if (!getFreePlanes(dsp, layer->planeType)) {
+            DTRACE("no plane available for dsp %d, type %d", dsp, layer->planeType);
+            return false;
+        }
+    }
+
+    if (config.size() == 1 && config[0]->planeType == DisplayPlane::PLANE_SPRITE) {
+        config[0]->planeType == DisplayPlane::PLANE_PRIMARY;
+    }
+
+    // allocate planes
+    for (int i = 0; i < size; i++) {
+        ZOrderLayer *layer = config.itemAt(i);
+        layer->plane = getPlaneHelper(dsp, layer->planeType);
+        if (layer->plane == NULL) {
+            // should never happen!!
+            ETRACE("failed to assign plane for type %d", layer->planeType);
+            return false;
+        }
+        // sequence !!!!! enabling plane before setting zorder
+        // see TngSpritePlane::enablePlane implementation!!!!
+        layer->plane->enable();
+    }
+
+    // setup Z order
+    for (int i = 0; i < size; i++) {
+        ZOrderLayer *layer = config.itemAt(i);
+        layer->plane->setZOrderConfig(config, &mZorder);
+    }
+
+    return true;
+}
+
+void* TngPlaneManager::getZOrderConfig() const
+{
+    return (void*)&mZorder;
+}
+
+DisplayPlane* TngPlaneManager::getPlaneHelper(int dsp, int type)
+{
+    RETURN_NULL_IF_NOT_INIT();
+
+    if (dsp < 0 || dsp > IDisplayDevice::DEVICE_EXTERNAL) {
+        ETRACE("Invalid display device %d", dsp);
+        return 0;
+    }
+
+    int index = dsp == IDisplayDevice::DEVICE_PRIMARY ? 0 : 1;
+
+    if (type == DisplayPlane::PLANE_PRIMARY ||
+        type == DisplayPlane::PLANE_CURSOR) {
+        return getPlane(type, index);
+    } else if (type == DisplayPlane::PLANE_SPRITE) {
+        return getAnyPlane(type);
+    } else if (type == DisplayPlane::PLANE_OVERLAY) {
+        // use overlay A for pipe A and overlay C for pipe B if possible
+        DisplayPlane *plane = getPlane(type, index);
+        if (plane == NULL) {
+            plane = getPlane(type, !index);
+        }
+        return plane;
+    } else {
+        ETRACE("invalid plane type %d", type);
+        return 0;
+    }
+}
+
+} // namespace intel
+} // namespace android
+