diff --git a/modules/gralloc/gralloc_priv.h b/modules/gralloc/gralloc_priv.h
new file mode 100644
index 0000000..a6fa69a
--- /dev/null
+++ b/modules/gralloc/gralloc_priv.h
@@ -0,0 +1,209 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#ifndef GRALLOC_PRIV_H_
+#define GRALLOC_PRIV_H_
+
+#include <stdint.h>
+#include <asm/page.h>
+#include <limits.h>
+#include <sys/cdefs.h>
+#include <hardware/gralloc.h>
+#include <pthread.h>
+
+#include <cutils/native_handle.h>
+
+#if HAVE_ANDROID_OS
+#include <linux/fb.h>
+#endif
+
+/*****************************************************************************/
+
+inline size_t roundUpToPageSize(size_t x) {
+    return (x + (PAGESIZE-1)) & ~(PAGESIZE-1);
+}
+
+int mapFrameBufferLocked(struct private_module_t* module);
+
+/*****************************************************************************/
+
+struct private_handle_t;
+
+struct private_module_t {
+    gralloc_module_t base;
+
+    private_handle_t* framebuffer;
+    uint32_t flags;
+    uint32_t numBuffers;
+    uint32_t bufferMask;
+    pthread_mutex_t lock;
+    buffer_handle_t currentBuffer;
+    struct fb_var_screeninfo info;
+    struct fb_fix_screeninfo finfo;
+    float xdpi;
+    float ydpi;
+    float fps;
+    
+    enum {
+        PRIV_USAGE_LOCKED_FOR_POST = 0x80000000
+    };
+};
+
+/*****************************************************************************/
+
+struct private_handle_t : public native_handle
+{
+    enum {
+        PRIV_FLAGS_FRAMEBUFFER = 0x00000001,
+        PRIV_FLAGS_USES_PMEM   = 0x00000002
+    };
+
+    int     fd;
+    int     magic;
+    int     base;
+    int     flags;
+    int     size;
+
+    static const int sNumInts = 5;
+    static const int sNumFds = 1;
+    static const int sMagic = 0x3141592;
+
+    private_handle_t(int fd, int size, int flags) :
+        fd(fd), magic(sMagic), base(0), flags(flags), size(size) {
+        version = sizeof(native_handle);
+        numInts = sNumInts;
+        numFds = sNumFds;
+    }
+
+    ~private_handle_t() {
+        magic = 0;
+    }
+
+    bool usesPhysicallyContiguousMemory() {
+        return (flags & PRIV_FLAGS_USES_PMEM) != 0;
+    }
+
+    static int validate(const native_handle* h) {
+        if (!h || h->version != sizeof(native_handle) ||
+                h->numInts!=sNumInts || h->numFds!=sNumFds) {
+            return -EINVAL;
+        }
+        const private_handle_t* hnd = (const private_handle_t*)h;
+        if (hnd->magic != sMagic)
+            return -EINVAL;
+        return 0;
+    }
+
+    static private_handle_t* dynamicCast(const native_handle* in) {
+        if (validate(in) == 0) {
+            return (private_handle_t*) in;
+        }
+        return NULL;
+    }
+};
+
+/*****************************************************************************/
+
+template<typename T>
+struct growable_sorted_array_t {
+    int size;
+    int count;
+    T* data;
+
+    growable_sorted_array_t() : size(0), count(0), data(0) {
+    }
+
+    growable_sorted_array_t(int initialSize)
+        : size(initialSize), count(0), data(0)
+    {
+        data = new T[initialSize];
+    }
+
+    ~growable_sorted_array_t() {
+        delete[] data;
+    }
+
+    /** Returns true if we found an exact match.
+     * Argument index is set to the the first index >= key in place.
+     * Index will be in range 0..count inclusive.
+     *
+     */
+    bool find(const T& key, int& index) {
+        return binarySearch(0, count-1, key, index);
+    }
+
+    T* at(int index){
+        if (index >= 0  && index < count) {
+            return data + index;
+        }
+        return 0;
+    }
+
+    void insert(int index, const T& item) {
+        if (index >= 0 && index <= count) {
+            if (count + 1 > size) {
+                int newSize = size * 2;
+                if (newSize < count + 1) {
+                    newSize = count + 1;
+                }
+                T* newData = new T[newSize];
+                if (size > 0) {
+                    memcpy(newData, data, sizeof(T) * count);
+                }
+                data = newData;
+                size = newSize;
+            }
+            int toMove = count - index;
+            if (toMove > 0) {
+                memmove(data + index + 1, data + index, sizeof(T) * toMove);
+            }
+            count++;
+            data[index] = item;
+        }
+    }
+
+    void remove(int index) {
+        if (index >= 0 && index < count) {
+            int toMove = (count - 1) - index;
+            if (toMove > 0) {
+                memmove(data + index, data + index + 1, sizeof(T) * toMove);
+            }
+            count--;
+        }
+    }
+
+    /** Return the first index >= key. May be in range first..last+1. */
+    int binarySearch(int first, int last, const T& key, int& index)
+    {
+        while (first <= last) {
+            int mid = (first + last) / 2;
+            int cmp = compare(key, data[mid]);
+            if (cmp > 0) {
+                first = mid + 1;
+            } else if (cmp < 0) {
+                last = mid - 1;
+            } else {
+                index = mid;
+                return true;
+            }
+        }
+        index = first;
+        return false;
+    }
+};
+
+
+#endif /* GRALLOC_PRIV_H_ */