diff --git a/hw/misc/Makefile.objs b/hw/misc/Makefile.objs
index f97ecb6..8fcf46d 100644
--- a/hw/misc/Makefile.objs
+++ b/hw/misc/Makefile.objs
@@ -16,6 +16,8 @@
 
 obj-$(CONFIG_ANDROID_PIPE) += android_pipe.o
 obj-$(CONFIG_ANDROID_PIPE) += android_pipe_test.o
+obj-$(CONFIG_ANDROID_PIPE) += android_net_pipe.o
+obj-$(CONFIG_ANDROID_PIPE) += android_opengles.o
 obj-$(CONFIG_ANDROID_PIPE) += android_adb_dbg.o
 obj-$(CONFIG_ANDROID_PIPE) += android_adb.o
 
diff --git a/hw/misc/android_net_pipe.c b/hw/misc/android_net_pipe.c
new file mode 100644
index 0000000..90d1364
--- /dev/null
+++ b/hw/misc/android_net_pipe.c
@@ -0,0 +1,489 @@
+/* Copyright (C) 2014 The Android Open Source Project
+**
+** This software is licensed under the terms of the GNU General Public
+** License version 2, as published by the Free Software Foundation, and
+** may be copied, distributed, and modified under those terms.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** Description
+**
+** Implementation of 'tcp' and 'unix' Android pipes. These can be used
+** to connect a guest process directly with a host TCP or Unix socket.
+**
+** For TCP, connections are limited to localhost (127.0.0.1) ports for
+** security reasons (doing otherwise might allow any application to
+** sneakily connect to the Internet when running under emulation).
+**
+** This is also used by the 'opengles' Android pipe service to send
+** wire protocol data to the GPU emulation libraries.
+*/
+
+#include "qemu/main-loop.h"
+#include "qemu/sockets.h"
+#include "hw/misc/android_pipe.h"
+#include "hw/misc/android_opengles.h"
+
+#include <errno.h>
+//#include <sys/select.h>
+
+/* Set to 1 or 2 for debug traces */
+#define DEBUG 1
+
+#if DEBUG >= 1
+#  define D(...)   printf(__VA_ARGS__), printf("\n")
+#else
+#  define D(...)   ((void)0)
+#endif
+
+#if DEBUG >= 2
+#  define DD(...)                       printf(__VA_ARGS__), printf("\n")
+#  define DDASSERT(cond)                _ANDROID_ASSERT(cond, "Assertion failure: ", #cond)
+#  define DDASSERT_INT_OP(cond,val,op)  _ANDROID_ASSERT_INT_OP(cond,val,op)
+#else
+#  define DD(...)                       ((void)0)
+#  define DDASSERT(cond)                ((void)0)
+#  define DDASSERT_INT_OP(cond,val,op)  ((void)0)
+#endif
+
+#define DDASSERT_INT_LT(cond,val)  DDASSERT_INT_OP(cond,val,<)
+#define DDASSERT_INT_LTE(cond,val)  DDASSERT_INT_OP(cond,val,<=)
+#define DDASSERT_INT_GT(cond,val)  DDASSERT_INT_OP(cond,val,>)
+#define DDASSERT_INT_GTE(cond,val)  DDASSERT_INT_OP(cond,val,>=)
+#define DDASSERT_INT_EQ(cond,val)  DDASSERT_INT_OP(cond,val,==)
+#define DDASSERT_INT_NEQ(cond,val)  DDASSERT_INT_OP(cond,val,!=)
+
+enum {
+    STATE_INIT,
+    STATE_CONNECTING,
+    STATE_CONNECTED,
+    STATE_CLOSING_GUEST,
+    STATE_CLOSING_SOCKET
+};
+
+typedef struct {
+    void *hwpipe;
+    int state;
+    int wakeWanted;
+    int wakeActual;
+    int fd;
+} NetPipe;
+
+/* Free a network pipe */
+static void net_pipe_free(NetPipe *pipe)
+{
+    /* Close the socket */
+    int fd = pipe->fd;
+    if (fd >= 0) {
+        qemu_set_fd_handler(fd, NULL, NULL, NULL);
+        closesocket(fd);
+        pipe->fd = -1;
+    }
+    g_free(pipe);
+}
+
+static void net_pipe_read_handler(void* opaque);
+static void net_pipe_write_handler(void* opaque);
+
+static void net_pipe_reset_state(NetPipe *pipe)
+{
+    IOHandler *read_handler = NULL;
+    IOHandler *write_handler = NULL;
+
+    if ((pipe->wakeWanted & PIPE_WAKE_WRITE) != 0) {
+        write_handler = net_pipe_write_handler;
+    }
+
+    if (pipe->state == STATE_CONNECTED &&
+        (pipe->wakeWanted & PIPE_WAKE_READ) != 0) {
+       read_handler = net_pipe_read_handler;
+    }
+    qemu_set_fd_handler(pipe->fd, read_handler, write_handler, pipe);
+}
+
+static void net_pipe_close_from_socket(void *opaque)
+{
+    NetPipe *pipe = opaque;
+
+    /* If the guest already ordered the pipe to be closed,
+     * delete immediately */
+    if (pipe->state == STATE_CLOSING_GUEST) {
+        net_pipe_free(pipe);
+        return;
+    }
+
+    /* Force the closure of the pipe channel - if a guest is blocked
+     * waiting for a wake signal, it will receive an error. */
+    if (pipe->hwpipe != NULL) {
+        android_pipe_close(pipe->hwpipe);
+        pipe->hwpipe = NULL;
+    }
+
+    pipe->state = STATE_CLOSING_SOCKET;
+    net_pipe_reset_state(pipe);
+}
+
+/* Called when data arrives on the pipe's socket. */
+static void net_pipe_read_handler(void* opaque)
+{
+    NetPipe *pipe = opaque;
+
+    pipe->wakeActual |= PIPE_WAKE_READ;
+    if ((pipe->wakeWanted & PIPE_WAKE_READ) != 0) {
+        android_pipe_wake(pipe->hwpipe, pipe->wakeActual);
+        pipe->wakeWanted &= ~PIPE_WAKE_READ;
+    }
+    net_pipe_reset_state(pipe);
+}
+
+/* Called when the pipe's file socket becomes writable. */
+static void net_pipe_write_handler(void* opaque)
+{
+    NetPipe *pipe = opaque;
+
+    pipe->wakeActual |= PIPE_WAKE_WRITE;
+    if ((pipe->wakeWanted & PIPE_WAKE_WRITE) != 0) {
+        android_pipe_wake(pipe->hwpipe, pipe->wakeActual);
+        pipe->wakeWanted &= ~PIPE_WAKE_WRITE;
+    }
+    net_pipe_reset_state(pipe);
+}
+
+static void net_pipe_close_from_guest(void *opaque)
+{
+    NetPipe *pipe = opaque;
+    net_pipe_free(pipe);
+}
+
+static int net_pipe_ready_send(NetPipe *pipe)
+{
+    if (pipe->state == STATE_CONNECTED) {
+        return 0;
+    } else if (pipe->state == STATE_CONNECTING) {
+        return PIPE_ERROR_AGAIN;
+    } else if (pipe->hwpipe == NULL) {
+        return PIPE_ERROR_INVAL;
+    } else {
+        return PIPE_ERROR_IO;
+    }
+}
+
+static int net_pipe_send_buffers(void* opaque,
+                                 const AndroidPipeBuffer *buffers,
+                                 int num_buffers)
+{
+    NetPipe *pipe = opaque;
+
+    int ret = net_pipe_ready_send(pipe);
+    if (ret != 0) {
+        return ret;
+    }
+
+    const AndroidPipeBuffer* buff = buffers;
+    const AndroidPipeBuffer* buff_end = buff + num_buffers;
+    int count = 0;
+    for (; buff < buff_end; ++buff) {
+        count += buff->size;
+    }
+
+    buff = buffers;
+
+    int buff_start = 0;
+    ret = 0;
+    while (count > 0) {
+        int avail = buff->size - buff_start;
+        ssize_t len = send(pipe->fd, (const void*)(buff->data + buff_start), avail, 0);
+
+        if (len > 0) {
+            /* the write succeeded */
+            buff_start += len;
+            if (buff_start >= buff->size) {
+                buff++;
+                buff_start = 0;
+            }
+            count -= (int)len;
+            ret += (int)len;
+            continue;
+        }
+        if (len == 0) {
+            /* reached the end of stream? */
+            if (ret == 0) {
+                ret = PIPE_ERROR_IO;
+            }
+            break;
+        }
+        if (ret > 0) {
+            break;
+        }
+        if (errno == EAGAIN || errno == EWOULDBLOCK) {
+            ret = PIPE_ERROR_AGAIN;
+        } else {
+            ret = PIPE_ERROR_IO;
+        }
+        break;
+    }
+    return ret;
+}
+
+static int net_pipe_recv_buffers(void *opaque,
+                                 AndroidPipeBuffer *buffers,
+                                 int num_buffers)
+{
+    NetPipe *pipe = opaque;
+
+    AndroidPipeBuffer* buff = buffers;
+    AndroidPipeBuffer* buff_end = buff + num_buffers;
+
+    int count = 0;
+    for (; buff < buff_end; ++buff) {
+        count += buff->size;
+    }
+
+    buff = buffers;
+
+    int ret = 0;
+    int buff_start = 0;
+    while (count > 0) {
+        int avail = buff->size - buff_start;
+        ssize_t len = recv(pipe->fd, (void*)(buff->data + buff_start), avail, 0);
+
+        if (len > 0) {
+            /* the read succeeded. */
+            buff_start += len;
+            if (buff_start >= buff->size) {
+                buff++;
+                buff_start = 0;
+            }
+            count -= (int) len;
+            ret += (int) len;
+            continue;
+        }
+
+        if (len == 0) {
+            /* reached the end of stream? */
+            if (ret == 0)
+                ret = PIPE_ERROR_IO;
+            break;
+        }
+
+        if (ret > 0) {
+            /* if data was already read, just return it. */
+            break;
+        }
+
+        /* need to return an appropriate error code. */
+        if (errno == EAGAIN || errno == EWOULDBLOCK) {
+            ret = PIPE_ERROR_AGAIN;
+        } else {
+            ret = PIPE_ERROR_IO;
+        }
+        break;
+    }
+    return ret;
+}
+
+static unsigned net_pipe_poll(void *opaque)
+{
+    NetPipe *pipe = opaque;
+#if 1
+    return pipe->wakeActual;
+#else
+    unsigned result = 0;
+
+    do {
+        fd_set read_fds, write_fds;
+        struct timeval tv = {0, 0};
+
+        FD_ZERO(&read_fds);
+        FD_ZERO(&write_fds);
+        FD_SET(fd, &read_fds);
+        FD_SET(fd, &write_fds);
+        ret = select(fd + 1, &read_fds, &write_fds, NULL, &tv);
+    } while (ret < 0 && errno == EINTR);
+
+    if (ret == 1) {
+        if (FD_ISSET(fd, &read_fds)) {
+            result |= PIPE_WAKE_READ;
+        }
+        if (FD_ISSET(fd, &write_fds)) {
+            result |= PIPE_WAKE_WRITE;
+        }
+    }
+#endif
+    return 0;
+}
+
+static void net_pipe_wake_on(void *opaque, int flags)
+{
+    NetPipe *pipe = opaque;
+
+    DD("%s: flags=%d", __FUNCTION__, flags);
+
+    pipe->wakeWanted |= flags;
+    pipe->wakeActual &= ~flags;
+    net_pipe_reset_state(pipe);
+}
+
+/* Called when the pipe finished connecting to its target. |fd| will be -1
+ * to indicate that the connection failed. */
+static void net_pipe_connect_handler(int fd, void* opaque)
+{
+    NetPipe *pipe = opaque;
+
+    if (fd < 0) {
+        net_pipe_close_from_socket(pipe);
+        return;
+    }
+
+    pipe->state = STATE_CONNECTED;
+    net_pipe_reset_state(pipe);
+}
+
+static void *net_pipe_init_from(void *hwpipe,
+                                const char* args,
+                                bool is_unix)
+{
+    if (args == NULL || args[0] == '\0') {
+        D("%s: Missing address!", __FUNCTION__);
+        return NULL;
+    }
+
+    NetPipe *pipe = (NetPipe *)g_new0(NetPipe, 1);
+    pipe->hwpipe = hwpipe;
+    pipe->state = STATE_CONNECTING;
+
+    Error *err = NULL;
+
+    if (is_unix) {
+        D("%s: Unix path is '%s'", __FUNCTION__, args);
+        pipe->fd = unix_nonblocking_connect(args,
+                                            net_pipe_connect_handler,
+                                            pipe,
+                                            &err);
+        if (pipe->fd < 0) {
+            D("%s: Could not connect pipe to %s: %s\n",
+            __FUNCTION__, args, error_get_pretty(err));
+        }
+    } else {
+        D("%s: TCP port is '%s'", __FUNCTION__, args);
+
+        char address[64];
+        snprintf(address, sizeof(address), "127.0.0.1:%s", args);
+
+        pipe->fd = inet_nonblocking_connect(address,
+                                            net_pipe_connect_handler,
+                                            pipe,
+                                            &err);
+        if (pipe->fd < 0) {
+            D("%s: Could not connect pipe to %s: %s\n",
+            __FUNCTION__, address, error_get_pretty(err));
+        }
+    }
+
+    if (pipe->fd < 0) {
+        error_free(err);
+        g_free(pipe);
+        return NULL;
+    }
+
+    return pipe;
+}
+
+static void *net_pipe_init_tcp(void *hwpipe, void *opaque, const char *args)
+{
+    return net_pipe_init_from(hwpipe, args, false);
+}
+
+#ifndef _WIN32
+static void *net_pipe_init_unix(void *hwpipe, void *opaque, const char *args)
+{
+    return net_pipe_init_from(hwpipe, args, true);
+}
+#endif
+
+static const AndroidPipeFuncs net_pipe_tcp_funcs = {
+    net_pipe_init_tcp,
+    net_pipe_close_from_guest,
+    net_pipe_send_buffers,
+    net_pipe_recv_buffers,
+    net_pipe_poll,
+    net_pipe_wake_on,
+    NULL,  /* we can't save these */
+    NULL,  /* we can't load these */
+};
+
+#ifndef _WIN32
+static const AndroidPipeFuncs  net_pipe_unix_funcs = {
+    net_pipe_init_unix,
+    net_pipe_close_from_guest,
+    net_pipe_send_buffers,
+    net_pipe_recv_buffers,
+    net_pipe_poll,
+    net_pipe_wake_on,
+    NULL,  /* we can't save these */
+    NULL,  /* we can't load these */
+};
+#endif
+
+static void *opengles_pipe_init(void *hwpipe,
+                                void *opaque,
+                                const char *args)
+{
+    char server_addr[PATH_MAX];
+    android_gles_server_path(server_addr, sizeof(server_addr));
+    NetPipe *pipe;
+#ifndef _WIN32
+    // Use a Unix pipe on Posix systems.
+    pipe = (NetPipe *)net_pipe_init_unix(hwpipe, opaque, server_addr);
+#else
+    // Use a TCP pipe on Windows.
+    pipe = (NetPipe *)net_pipe_init_tcp(hwpipe, opaque, server_addr);
+#endif
+    if (!pipe) {
+        return NULL;
+    }
+
+    // Disable TCP nagle algorithm to improve through put of small
+    // packets.
+    socket_set_nodelay(pipe->fd);
+
+#ifdef _WIN32
+    // On Windows, adjust buffer sizes.
+    int sndbuf = 128 * 1024;
+    int len = sizeof(sndbuf);
+    if (setsockopt(pipe->fd,
+                    SOL_SOCKET,
+                    SO_SNDBUF,
+                    (char *)&sndbuf,
+                    (int) sizeof(sndbuf)) == SOCKET_ERROR) {
+        D("Failed to set SO_SNDBUF to %d error=0x%x\n",
+            sndbuf, WSAGetLastError());
+    }
+#endif
+    return pipe;
+}
+
+static const AndroidPipeFuncs opengles_pipe_funcs = {
+    opengles_pipe_init,
+    net_pipe_close_from_guest,
+    net_pipe_send_buffers,
+    net_pipe_recv_buffers,
+    net_pipe_poll,
+    net_pipe_wake_on,
+    NULL,  /* we can't save these */
+    NULL,  /* we can't save these */
+};
+
+void
+android_net_pipe_init(void)
+{
+    android_pipe_add_type("tcp", NULL, &net_pipe_tcp_funcs);
+#ifndef _WIN32
+    android_pipe_add_type("unix", NULL, &net_pipe_unix_funcs);
+#endif
+    android_pipe_add_type("opengles", NULL, &opengles_pipe_funcs);
+}
+
diff --git a/hw/misc/android_opengles.c b/hw/misc/android_opengles.c
new file mode 100644
index 0000000..6e12303
--- /dev/null
+++ b/hw/misc/android_opengles.c
@@ -0,0 +1,375 @@
+/*
+ * ARM Android emulator OpenGLES backend
+ *
+ * Copyright (c) 2014 Android Open Source Project
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2 or later, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Handle connections to the 'opengles' pipe from Android guests and route
+ * traffic over this pipe to the GPU emulation libraries.
+ */
+
+#include "hw/misc/android_opengles.h"
+#include "hw/misc/android_pipe.h"
+#include "qemu/compiler.h"
+#include "qemu-common.h"
+
+#include <limits.h>
+
+#ifdef _WIN32
+#include <errno.h>
+#include <windows.h>
+#else
+#include <dlfcn.h>
+#endif
+
+
+// #define DEBUG_OPENGLES
+
+#ifdef DEBUG_OPENGLES
+#define DPRINTF(fmt, ...) \
+do { fprintf(stderr, "adb_debug: " fmt , ## __VA_ARGS__); } while (0)
+#else
+#define DPRINTF(fmt, ...) do {} while(0)
+#endif
+
+// Loading shared libraries and probing their symbols.
+typedef struct DynamicLibrary DynamicLibrary;
+
+static DynamicLibrary* dynamic_library_open(const char* library_name)
+{
+    char path[PATH_MAX];
+
+#ifdef _WIN32
+    static const char kDllExtension[] = ".dll";
+#elif defined(__APPLE__)
+    static const char kDllExtension[] = ".dylib";
+#else
+    static const char kDllExtension[] = ".so";
+#endif
+    if (!strchr(library_name, '.')) {
+        snprintf(path, sizeof path, "%s%s", library_name, kDllExtension);
+    } else {
+        snprintf(path, sizeof path, "%s", library_name);
+    }
+#ifdef _WIN32
+    return (DynamicLibrary*)LoadLibrary(path);
+#else
+    return (DynamicLibrary*)dlopen(path, RTLD_NOW);
+#endif
+}
+
+static void dynamic_library_close(DynamicLibrary* library)
+{
+#ifdef _WIN32
+    if (library) {
+        FreeLibrary((HMODULE)library);
+    }
+#else
+    if (library) {
+        dlclose(library);
+    }
+#endif
+}
+
+static void* dynamic_library_probe(DynamicLibrary* library,
+                                   const char* symbol)
+{
+    if (!library || !symbol || !symbol[0]) {
+        return NULL;
+    }
+#ifdef _WIN32
+    return GetProcAddress((HMODULE)library, symbol);
+#else
+    return dlsym(library, symbol);
+#endif
+}
+
+//
+// Loading the GPU shared libraries
+//
+
+// Name of the GLES rendering library we're going to use.
+#if UINTPTR_MAX == UINT32_MAX
+#define RENDERER_LIB_NAME  "libOpenglRender"
+#elif UINTPTR_MAX == UINT64_MAX
+#define RENDERER_LIB_NAME  "lib64OpenglRender"
+#else
+#error Unknown UINTPTR_MAX
+#endif
+
+// NOTE: The declarations below should be equivalent to those in
+// <libOpenglRender/render_api_platform_types.h>
+#ifdef _WIN32
+typedef HDC FBNativeDisplayType;
+typedef HWND FBNativeWindowType;
+#elif defined(__linux__)
+// Really a Window, which is defined as 32-bit unsigned long on all platforms
+// but we don't want to include the X11 headers here.
+typedef uint32_t FBNativeWindowType;
+#elif defined(__APPLE__)
+typedef void* FBNativeWindowType;
+#else
+#warning "unsupported platform"
+#endif
+
+// List of GPU emulation library functions.
+#define RENDERER_FUNCTIONS_LIST \
+  FUNCTION_(int, initLibrary, (void)) \
+  FUNCTION_(int, setStreamMode, (int mode)) \
+  FUNCTION_(int, initOpenGLRenderer, (int width, int height, char* addr, size_t addrLen)) \
+  FUNCTION_(void, getHardwareStrings, (const char** vendors, const char** renderer, const char** version)) \
+  FUNCTION_(void, setPostCallback, (AndroidGLESOnPostFunc onPost, void* onPostContext)) \
+  FUNCTION_(int, createOpenGLSubwindow, (FBNativeWindowType window, int x, int y, int width, int height, float zRot)) \
+  FUNCTION_(int, destroyOpenGLSubwindow, (void)) \
+  FUNCTION_(void, setOpenGLDisplayRotation, (float zRot)) \
+  FUNCTION_(void, repaintOpenGLDisplay, (void)) \
+  FUNCTION_(int, stopOpenGLRenderer, (void)) \
+
+// Name of static variable that points to symbol |name| in the GPU
+// emulation library.
+#define EMUGL_WRAPPER(name)  emugl_ ## name
+
+// Define the corresponding function pointers as global variables, with
+// an 'emugl_' prefix.
+#define FUNCTION_(ret, name, sig) \
+        static ret (*EMUGL_WRAPPER(name)) sig = NULL;
+RENDERER_FUNCTIONS_LIST
+#undef FUNCTION_
+
+
+// Define a function that initializes the function pointers by looking up
+// the symbols from the shared library.
+static int init_opengles_emulation_functions(DynamicLibrary* library)
+{
+    void *symbol;
+
+#define FUNCTION_(ret, name, sig) \
+    symbol = dynamic_library_probe(library, #name); \
+    if (!symbol) { \
+        DPRINTF("GLES emulation: Could not find required symbol (%s): %s\n", #name); \
+        return -1; \
+    } \
+    EMUGL_WRAPPER(name) = symbol;
+
+RENDERER_FUNCTIONS_LIST
+#undef FUNCTION_
+
+    return 0;
+}
+
+// list of constants to be passed to setStreamMode, which determines how
+// to send/receive wire protocol data to/from the library.
+// DEFAULT -> try to use the best for the current platform.
+// TCP -> use a TCP socket to send the protocol bytes to the library.
+// UNIX -> use a Unix domain socket (faster than TCP, but Unix-only).
+// WIN32_PIPE -> use a Win32 PIPE (unsupported by the library for now!).
+enum {
+    STREAM_MODE_DEFAULT = 0,
+    STREAM_MODE_TCP = 1,
+    STREAM_MODE_UNIX = 2,
+    STREAM_MODE_WIN32_PIPE = 3,
+};
+
+struct AndroidGLES {
+    bool init;
+    DynamicLibrary* renderer_lib;
+    bool renderer_started;
+    char renderer_address[256];
+};
+
+static AndroidGLES sState = {
+    .init = false,
+    .renderer_lib = NULL,
+    .renderer_started = false,
+};
+
+AndroidGLES* android_gles_init(void)
+{
+    AndroidGLES* state = &sState;
+
+    if (state->init) {
+        return state;
+    }
+
+    // Try to load the library.
+    state->renderer_lib = dynamic_library_open(RENDERER_LIB_NAME);
+    if (!state->renderer_lib) {
+        DPRINTF("Could not load GPU emulation library!\n");
+        return NULL;
+    }
+
+    // Resolve all required symbols from it.
+    if (init_opengles_emulation_functions(state->renderer_lib) < 0) {
+        DPRINTF("OpenGLES emulation library mismatch. Bes ure to use the correct version!\n");
+        goto BAD_EXIT;
+    }
+
+    // Call its initialization function.
+    if (!EMUGL_WRAPPER(initLibrary)()) {
+        DPRINTF("OpenGLES initialization failed!\n");
+        goto BAD_EXIT;
+    }
+
+#ifdef _WIN32
+    // NOTE: Win32 PIPE support is still not implemented.
+    EMUGL_WRAPPER(setStreamMode)(STREAM_MODE_TCP);
+#else
+    EMUGL_WRAPPER(setStreamMode)(STREAM_MODE_UNIX);
+#endif
+
+    state->init = true;
+    return state;
+
+BAD_EXIT:
+    DPRINTF("OpenGLES library could not be initialized\n");
+    dynamic_library_close(state->renderer_lib);
+
+    state->renderer_lib = NULL;
+    return NULL;
+}
+
+static void extract_base_string(char* dst, const char* src, size_t dstSize)
+{
+    const char* begin = strchr(src, '(');
+    const char* end = strrchr(src, ')');
+
+    if (!begin || !end) {
+        pstrcpy(dst, dstSize, src);
+        return;
+    }
+    begin += 1;
+
+    // "foo (bar)"
+    //       ^  ^
+    //       b  e
+    //     = 5  8
+    // substring with NUL-terminator is end-begin+1 bytes
+    if (end - begin + 1 > dstSize) {
+        end = begin + dstSize - 1;
+    }
+
+    pstrcpy(dst, end - begin + 1, begin);
+}
+
+void android_gles_get_hardware_strings(char *vendor,
+                                       size_t vendor_buffer_size,
+                                       char *renderer,
+                                       size_t renderer_buffer_size,
+                                       char *version,
+                                       size_t version_buffer_size)
+{
+    const char *vendor_src, *renderer_src, *version_src;
+    AndroidGLES *state = &sState;
+
+    if (!state->renderer_started) {
+        DPRINTF("Can't get OpenGL ES hardware strings when renderer not started");
+        vendor[0] = renderer[0] = version[0] = '\0';
+        return;
+    }
+
+    EMUGL_WRAPPER(getHardwareStrings)(&vendor_src,
+                                      &renderer_src,
+                                      &version_src);
+    if (!vendor_src) vendor_src = "";
+    if (!renderer_src) renderer_src = "";
+    if (!version_src) version_src = "";
+
+    /* Special case for the default ES to GL translators: extract the strings
+     * of the underlying OpenGL implementation. */
+    if (strncmp(vendor_src, "Google", 6) == 0 &&
+            strncmp(renderer_src, "Android Emulator OpenGL ES Translator", 37) == 0) {
+        extract_base_string(vendor, vendor_src, vendor_buffer_size);
+        extract_base_string(renderer, renderer_src, renderer_buffer_size);
+        extract_base_string(version, version_src, version_buffer_size);
+    } else {
+        pstrcpy(vendor, vendor_buffer_size, vendor_src);
+        pstrcpy(renderer, renderer_buffer_size, renderer_src);
+        pstrcpy(version, version_buffer_size, version_src);
+    }
+}
+
+int android_gles_start(AndroidGLES* state, int width, int height)
+{
+    if (!state->renderer_lib) {
+        DPRINTF("Can't start OpenGLES renderer without support libraries\n");
+        return -1;
+    }
+
+    if (state->renderer_started) {
+        // Already started.
+        return 0;
+    }
+
+    if (!EMUGL_WRAPPER(initOpenGLRenderer)(
+            width,
+            height,
+            state->renderer_address,
+            sizeof(state->renderer_address))) {
+        DPRINTF("Can't start OpenGLES renderer !?\n");
+        return -1;
+    }
+
+    state->renderer_started = true;
+    return 0;
+}
+
+void android_gles_set_post_callback(AndroidGLES* state,
+                                    AndroidGLESOnPostFunc on_post,
+                                    void* on_post_context)
+{
+    if (state->renderer_lib) {
+        EMUGL_WRAPPER(setPostCallback)(on_post, on_post_context);
+    }
+}
+
+int android_gles_show_window(AndroidGLES* state,
+                             void* window,
+                             int x,
+                             int y,
+                             int width,
+                             int height,
+                             float rotation)
+{
+    if (state->renderer_started) {
+        int success = EMUGL_WRAPPER(createOpenGLSubwindow)(
+                (FBNativeWindowType)(uintptr_t)window,
+                x,
+                y,
+                width,
+                height,
+                rotation);
+        return success ? 0 : -1;
+    } else {
+        return -1;
+    }
+}
+
+void android_gles_hide_window(AndroidGLES* state)
+{
+    if (state->renderer_started) {
+        EMUGL_WRAPPER(destroyOpenGLSubwindow)();
+    }
+}
+
+void android_gles_redraw_window(AndroidGLES* state) {
+    if (state->renderer_started) {
+        EMUGL_WRAPPER(repaintOpenGLDisplay)();
+    }
+}
+
+void android_gles_server_path(char* buff, size_t buff_size)
+{
+    AndroidGLES *state = &sState;
+    pstrcpy(buff, buff_size, state->renderer_address);
+}
diff --git a/include/hw/misc/android_opengles.h b/include/hw/misc/android_opengles.h
new file mode 100644
index 0000000..5a5b59b
--- /dev/null
+++ b/include/hw/misc/android_opengles.h
@@ -0,0 +1,149 @@
+/*
+ * ARM Android emulator OpenGLES backend
+ *
+ * Copyright (c) 2014 Android Open Source Project
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2 or later, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Handle connections to the 'opengles' pipe from Android guests and route
+ * traffic over this pipe to the GPU emulation libraries.
+ */
+
+ #ifndef _HW_MISC_ANDROID_OPENGLES_H
+ #define _HW_MISC_ANDROID_OPENGLES_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+/* Declarations related to Android-specific GPU emulation support.
+ *
+ * This works as follows:
+ *
+ * - GPU emulation support is implemented by an external shared library
+ *   (e.g. libOpenglRender.so on Linux), which provides a small set of
+ *   well-known entry points.
+ *
+ * - QEMU itself acts as a 'dumb pipe' between the guest system, and
+ *   the GPU emulation library. More specifically:
+ *
+ *     o The guest EGL/GLES system libraries marshall all requests into
+ *       a specific wire protocol stream of bytes. The corresponding data is
+ *       sent directly to QEMU through the "opengles" Android pipe service.
+ *
+ *     o QEMU sends the data directly to the GPU emulation library,
+ *       without trying to process or interpret it. Note that traffic goes
+ *       both ways.
+ *
+ * This design avoids the need for a specific GPU driver in the kernel,
+ * or any knowledge of the wire protocol being used in QEMU itself.
+ *
+ * - The GPU emulation library will display an OpenGL window _on_ _top_ of
+ *   the current window, which will hide the framebuffer completely.
+ *
+ *   To do so, QEMU needs to provide the platform-specific 'id' of the
+ *   current window. See android_gles_show_window() documentation for
+ *   more details.
+ */
+
+/* Opaque data structure modelling the state of GPU emulation support for
+ * Android. */
+typedef struct AndroidGLES AndroidGLES;
+
+/* Initialize the Android GPU emulation support. This function tries to
+ * locate, load and initialize the GPU emulation library, and returns,
+ * on success, a new AndroidGLES instance that can be used to call other
+ * functions below. Return NULL/errno on failure.
+ */
+AndroidGLES* android_gles_init(void);
+
+/* Start GPU emulation support. Returns 0 on success, -1/errno on failure. */
+int android_gles_start(AndroidGLES* state, int width, int height);
+
+/* Retrieve the Vendor/Renderer/Version strings describing the underlying GL
+ * implementation. The call only works while the renderer is started.
+ *
+ * Each string is copied into the corresponding buffer. If the original
+ * string (including NUL terminator) is more than xxBufSize bytes, it will
+ * be truncated. In all cases, including failure, the buffer will be NUL-
+ * terminated when this function returns.
+ */
+void android_gles_get_hardware_strings(char *vendor,
+                                       size_t vendor_buffer_size,
+                                       char *renderer,
+                                       size_t renderer_buffer_size,
+                                       char *version,
+                                       size_t version_buffer_size);
+
+/* Pointer type to a function used to retrieve the content of
+ * GPU framebuffer content. This is used in the Android emulator
+ * to support displaying the framebuffer content to a remote device
+ * for multi-touch support.
+ * |context| is a client-provided value passed to
+ * android_gles_set_post_callback().
+ */
+typedef void (*AndroidGLESOnPostFunc)(void *context,
+                                      int width,
+                                      int height,
+                                      int ydir,
+                                      int format,
+                                      int type,
+                                      unsigned char *pixels);
+
+/* Enable GPU framebuffer retrieval. If |on_post| is not NULL, it will
+ * be called periodically when the framebuffer content changes. Note that
+ * each call can be very expensive, depending on the host GPU.
+ * Set |on_post| to NULL to disable the feature at runtime.
+ */
+void android_gles_set_post_callback(AndroidGLES *gles,
+                                    AndroidGLESOnPostFunc on_post,
+                                    void* on_post_context);
+
+/* Show an OpenGL window on top of the current QEMU UI window, at a
+ * specific location.
+ * |gles| is the current AndroidGLES state.
+ * |window| is a platform-specific identifier for the current UI window
+ * (see note below).
+ * |x|, |y|, |width| and |height| provide the location and size of the
+ * OpenGL window, relative to the current one.
+ * |rotation| is used to provide a rotation angle. Valid values are
+ * 0, 90, 180 and 270.
+ * Returns 0 on success, -1/errno on failure.
+ *
+ * NOTE: The exact type and meaning of |window| depends on the platform:
+ * - On Windows, this is the HWND of the current UI window.
+ * - On Linux, it's the X11 Window identifier (really a uint32_t cast
+ *   to void*).
+ * - On OS X, it's a NSWindow* value.
+ */
+int android_gles_show_window(AndroidGLES *gles,
+                             void *window,
+                             int x,
+                             int y,
+                             int width,
+                             int height,
+                             float rotation);
+
+/* Hide the OpenGL window. */
+void android_gles_hide_window(AndroidGLES *gles);
+
+void android_gles_redraw_window(AndroidGLES *gles);
+
+/* Stop GPU emulation support. */
+void android_gles_stop(AndroidGLES *gles);
+
+/* Write the local GPU server path into buffer |buff| of
+ * |buff_size| bytes. Result is zero-terminated. */
+void android_gles_server_path(char *buff, size_t buff_size);
+
+#endif  /* _HW_MISC_ANDROID_OPENGLES_H */
diff --git a/include/hw/misc/android_pipe.h b/include/hw/misc/android_pipe.h
index 962f2e9..cfba64a 100644
--- a/include/hw/misc/android_pipe.h
+++ b/include/hw/misc/android_pipe.h
@@ -222,6 +222,7 @@
 extern void android_throttle_init(void);
 extern void android_adb_dbg_backend_init(void);
 extern void android_adb_backend_init(void);
+extern void android_net_pipe_init(void);
 
 extern bool adb_server_init(int port);