YaGL: Implemented glGetVertexAttrib in order to support glDrawArrays and glDrawElemen...

YaGL: Removed unnecessary memory map/unmap

diff --git a/hw/yagl_apis/gles/yagl_gles_array.c b/hw/yagl_apis/gles/yagl_gles_array.c
index 888dfee..c6cfb0e 100644 (file)
--- a/hw/yagl_apis/gles/yagl_gles_array.c
+++ b/hw/yagl_apis/gles/yagl_gles_array.c
@@ -37,6 +37,7 @@ static void yagl_gles_array_reset(struct yagl_gles_array *array)
     if (array->vbo) {
         yagl_gles_buffer_release(array->vbo);
         array->vbo = NULL;
+        array->vbo_local_name = 0;
         array->offset = 0;
     } else {
         array->target_data = 0;
@@ -63,6 +64,7 @@ void yagl_gles_array_cleanup(struct yagl_gles_array *array)
     if (array->vbo) {
         yagl_sharegroup_reap_object(array->ctx->base.sg, &array->vbo->base);
         array->vbo = NULL;
+        array->vbo_local_name = 0;
         array->offset = 0;
     } else {
         array->target_data = 0;
@@ -110,6 +112,7 @@ bool yagl_gles_array_update_vbo(struct yagl_gles_array *array,
                                 GLboolean normalized,
                                 GLsizei stride,
                                 struct yagl_gles_buffer *vbo,
+                                yagl_object_name vbo_local_name,
                                 GLint offset)
 {
     if (!yagl_get_el_size(type, &array->el_size)) {
@@ -130,6 +133,7 @@ bool yagl_gles_array_update_vbo(struct yagl_gles_array *array,
     }
 
     array->vbo = vbo;
+    array->vbo_local_name = vbo_local_name;
     array->offset = offset;
 
     return true;

diff --git a/hw/yagl_apis/gles/yagl_gles_array.h b/hw/yagl_apis/gles/yagl_gles_array.h
index 016e7c2..75249ec 100644 (file)
--- a/hw/yagl_apis/gles/yagl_gles_array.h
+++ b/hw/yagl_apis/gles/yagl_gles_array.h
@@ -50,6 +50,7 @@ struct yagl_gles_array
     bool enabled;
 
     struct yagl_gles_buffer *vbo;
+    yagl_object_name vbo_local_name;
 
     union
     {
@@ -97,6 +98,7 @@ bool yagl_gles_array_update_vbo(struct yagl_gles_array *array,
                                 GLboolean normalized,
                                 GLsizei stride,
                                 struct yagl_gles_buffer *vbo,
+                                yagl_object_name vbo_local_name,
                                 GLint offset);
 
 /*

diff --git a/hw/yagl_apis/gles2/yagl_gles2_validate.c b/hw/yagl_apis/gles2/yagl_gles2_validate.c
index 7ad4ea1..8dc222c 100644 (file)
--- a/hw/yagl_apis/gles2/yagl_gles2_validate.c
+++ b/hw/yagl_apis/gles2/yagl_gles2_validate.c
@@ -1,2 +1,17 @@
 #include <GLES2/gl2.h>
 #include "yagl_gles2_validate.h"
+
+bool yagl_gles2_get_array_param_count(GLenum pname, int *count)
+{
+    switch (pname) {
+    case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: *count = 1; break;
+    case GL_VERTEX_ATTRIB_ARRAY_ENABLED: *count = 1; break;
+    case GL_VERTEX_ATTRIB_ARRAY_SIZE: *count = 1; break;
+    case GL_VERTEX_ATTRIB_ARRAY_STRIDE: *count = 1; break;
+    case GL_VERTEX_ATTRIB_ARRAY_TYPE: *count = 1; break;
+    case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED: *count = 1; break;
+    case GL_CURRENT_VERTEX_ATTRIB: *count = 4; break;
+    default: return false;
+    }
+    return true;
+}

diff --git a/hw/yagl_apis/gles2/yagl_gles2_validate.h b/hw/yagl_apis/gles2/yagl_gles2_validate.h
index ac79672..8a26b3a 100644 (file)
--- a/hw/yagl_apis/gles2/yagl_gles2_validate.h
+++ b/hw/yagl_apis/gles2/yagl_gles2_validate.h
@@ -3,4 +3,6 @@
 
 #include "yagl_types.h"
 
+bool yagl_gles2_get_array_param_count(GLenum pname, int *count);
+
 #endif

diff --git a/hw/yagl_apis/gles2/yagl_host_gles2_calls.c b/hw/yagl_apis/gles2/yagl_host_gles2_calls.c
index 2c1cad1..77766ce 100644 (file)
--- a/hw/yagl_apis/gles2/yagl_host_gles2_calls.c
+++ b/hw/yagl_apis/gles2/yagl_host_gles2_calls.c
@@ -11,6 +11,7 @@
 #include "yagl_gles2_context.h"
 #include "yagl_gles2_shader.h"
 #include "yagl_gles2_program.h"
+#include "yagl_gles2_validate.h"
 #include "yagl_egl_interface.h"
 #include "yagl_tls.h"
 #include "yagl_log.h"
@@ -1105,9 +1106,62 @@ void yagl_host_glGetVertexAttribfv(GLuint index,
 
 void yagl_host_glGetVertexAttribiv(GLuint index,
     GLenum pname,
-    target_ulong /* GLint* */ params)
+    target_ulong /* GLint* */ params_)
 {
-    YAGL_UNIMPLEMENTED(glGetVertexAttribiv);
+    struct yagl_gles_array *array = NULL;
+    int i, count = 0;
+    GLint *params = NULL;
+
+    YAGL_GET_CTX(glGetVertexAttribiv);
+
+    array = yagl_gles_context_get_array(&ctx->base, index);
+
+    if (!array) {
+        YAGL_SET_ERR(GL_INVALID_VALUE);
+        goto out;
+    }
+
+    if (!yagl_gles2_get_array_param_count(pname, &count)) {
+        YAGL_SET_ERR(GL_INVALID_ENUM);
+        goto out;
+    }
+
+    params = g_malloc0(count * sizeof(*params));
+
+    switch (pname) {
+    case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:
+        params[0] = array->vbo_local_name;
+        break;
+    case GL_VERTEX_ATTRIB_ARRAY_ENABLED:
+        params[0] = array->enabled;
+        break;
+    case GL_VERTEX_ATTRIB_ARRAY_SIZE:
+        params[0] = array->size;
+        break;
+    case GL_VERTEX_ATTRIB_ARRAY_STRIDE:
+        params[0] = array->stride;
+        break;
+    case GL_VERTEX_ATTRIB_ARRAY_TYPE:
+        params[0] = array->type;
+        break;
+    case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED:
+        params[0] = array->normalized;
+        break;
+    default:
+        ctx->driver_ps->GetVertexAttribiv(ctx->driver_ps, index, pname, params);
+        break;
+    }
+
+    if (params_) {
+        for (i = 0; i < count; ++i) {
+            yagl_mem_put_GLint(gles2_api_ts->ts,
+                               params_ + (i * sizeof(*params)),
+                               params[i]);
+        }
+    }
+
+out:
+    g_free(params);
 }
 
 void yagl_host_glGetVertexAttribPointerv(GLuint index,
@@ -1834,6 +1888,7 @@ void yagl_host_glVertexAttribPointer(GLuint indx,
                                         normalized,
                                         stride,
                                         ctx->base.vbo,
+                                        ctx->base.vbo_local_name,
                                         ptr)) {
             YAGL_SET_ERR(GL_INVALID_VALUE);
         }

diff --git a/hw/yagl_apis/gles2/yagl_host_gles2_calls.h b/hw/yagl_apis/gles2/yagl_host_gles2_calls.h
index 033831f..f557f10 100644 (file)
--- a/hw/yagl_apis/gles2/yagl_host_gles2_calls.h
+++ b/hw/yagl_apis/gles2/yagl_host_gles2_calls.h
@@ -119,7 +119,7 @@ void yagl_host_glGetVertexAttribfv(GLuint index,
     target_ulong /* GLfloat* */ params);
 void yagl_host_glGetVertexAttribiv(GLuint index,
     GLenum pname,
-    target_ulong /* GLint* */ params);
+    target_ulong /* GLint* */ params_);
 void yagl_host_glGetVertexAttribPointerv(GLuint index,
     GLenum pname,
     target_ulong /* GLvoid** */ pointer);

diff --git a/hw/yagl_device.c b/hw/yagl_device.c
index e46fee6..6ab3476 100644 (file)
--- a/hw/yagl_device.c
+++ b/hw/yagl_device.c
@@ -20,7 +20,7 @@
 
 struct yagl_user
 {
-    target_phys_addr_t buff_pa;
+    uint8_t *buff;
     yagl_pid process_id;
     yagl_tid thread_id;
 };
@@ -46,7 +46,7 @@ static void yagl_device_operate(YaGLState *s,
 {
     yagl_pid target_pid;
     yagl_tid target_tid;
-    target_phys_addr_t buff_len = YAGL_BUFF_SIZE;
+    target_phys_addr_t buff_len = YAGL_MARSHAL_SIZE;
     uint8_t *buff = NULL, *tmp = NULL;
 
     YAGL_LOG_FUNC_ENTER_NPT(yagl_device_operate,
@@ -54,12 +54,12 @@ static void yagl_device_operate(YaGLState *s,
                             user_index,
                             (uint32_t)buff_pa);
 
-    if (buff_pa && s->users[user_index].buff_pa) {
+    if (buff_pa && s->users[user_index].buff) {
         YAGL_LOG_CRITICAL("user %d is already activated", user_index);
         goto out;
     }
 
-    if (!buff_pa && !s->users[user_index].buff_pa) {
+    if (!buff_pa && !s->users[user_index].buff) {
         YAGL_LOG_CRITICAL("user %d is not activated", user_index);
         goto out;
     }
@@ -71,7 +71,7 @@ static void yagl_device_operate(YaGLState *s,
 
         buff = cpu_physical_memory_map(buff_pa, &buff_len, false);
 
-        if (!buff || (buff_len != YAGL_BUFF_SIZE)) {
+        if (!buff || (buff_len != YAGL_MARSHAL_SIZE)) {
             YAGL_LOG_CRITICAL("cpu_physical_memory_map(read) failed for user %d, buff_ptr = 0x%X",
                               user_index,
                               (uint32_t)buff_pa);
@@ -98,26 +98,15 @@ static void yagl_device_operate(YaGLState *s,
                                       target_tid,
                                       buff,
                                       s->in_buff)) {
-            cpu_physical_memory_unmap(buff,
-                                      YAGL_BUFF_SIZE,
-                                      0,
-                                      YAGL_BUFF_SIZE);
-
-            buff = cpu_physical_memory_map(buff_pa, &buff_len, true);
-
-            if (!buff || (buff_len != YAGL_BUFF_SIZE)) {
-                YAGL_LOG_CRITICAL("cpu_physical_memory_map(write) failed for user %d, buff_ptr = 0x%X",
-                                  user_index,
-                                  (uint32_t)buff_pa);
-                goto out;
-            }
 
             memcpy(buff, s->in_buff, YAGL_MARSHAL_MAX_RESPONSE);
 
-            s->users[user_index].buff_pa = buff_pa;
+            s->users[user_index].buff = buff;
             s->users[user_index].process_id = target_pid;
             s->users[user_index].thread_id = target_tid;
 
+            buff = NULL;
+
             YAGL_LOG_INFO("user %d activated", user_index);
         }
     } else {
@@ -129,6 +118,11 @@ static void yagl_device_operate(YaGLState *s,
                                   s->users[user_index].process_id,
                                   s->users[user_index].thread_id);
 
+        cpu_physical_memory_unmap(s->users[user_index].buff,
+                                  YAGL_MARSHAL_SIZE,
+                                  0,
+                                  YAGL_MARSHAL_SIZE);
+
         memset(&s->users[user_index], 0, sizeof(s->users[user_index]));
 
         YAGL_LOG_INFO("user %d deactivated", user_index);
@@ -137,9 +131,9 @@ static void yagl_device_operate(YaGLState *s,
 out:
     if (buff) {
         cpu_physical_memory_unmap(buff,
-                                  YAGL_BUFF_SIZE,
+                                  YAGL_MARSHAL_SIZE,
                                   0,
-                                  YAGL_BUFF_SIZE);
+                                  YAGL_MARSHAL_SIZE);
     }
 
     YAGL_LOG_FUNC_EXIT(NULL);
@@ -147,43 +141,22 @@ out:
 
 static void yagl_device_trigger(YaGLState *s, int user_index)
 {
-    target_phys_addr_t buff_len = YAGL_BUFF_SIZE;
-    uint8_t *buff = NULL;
-
     YAGL_LOG_FUNC_ENTER_NPT(yagl_device_trigger, "%d", user_index);
 
-    if (!s->users[user_index].buff_pa) {
+    if (!s->users[user_index].buff) {
         YAGL_LOG_CRITICAL("user %d not activated", user_index);
         goto out;
     }
 
-    buff = cpu_physical_memory_map(s->users[user_index].buff_pa,
-                                   &buff_len,
-                                   false);
-
-    if (!buff || (buff_len != YAGL_BUFF_SIZE)) {
-        YAGL_LOG_CRITICAL("cpu_physical_memory_map(read) failed for user %d, buff_ptr = 0x%X",
-                          user_index,
-                          (uint32_t)s->users[user_index].buff_pa);
-        goto out;
-    }
-
     yagl_server_dispatch(s->ss,
                          s->users[user_index].process_id,
                          s->users[user_index].thread_id,
-                         buff,
+                         s->users[user_index].buff,
                          s->in_buff);
 
-    memcpy(buff, s->in_buff, YAGL_MARSHAL_MAX_RESPONSE);
+    memcpy(s->users[user_index].buff, s->in_buff, YAGL_MARSHAL_MAX_RESPONSE);
 
 out:
-    if (buff) {
-        cpu_physical_memory_unmap(buff,
-                                  YAGL_BUFF_SIZE,
-                                  0,
-                                  YAGL_BUFF_SIZE);
-    }
-
     YAGL_LOG_FUNC_EXIT(NULL);
 }
 

diff --git a/hw/yagl_marshal.h b/hw/yagl_marshal.h
index eb41f73..0088fc4 100644 (file)
--- a/hw/yagl_marshal.h
+++ b/hw/yagl_marshal.h
@@ -20,9 +20,9 @@
 #define YAGL_MARSHAL_MAX_RESPONSE (8 * 2)
 
 /*
- * Max batch buffer size.
+ * Max marshal buffer size.
  */
-#define YAGL_BUFF_SIZE 0x1000
+#define YAGL_MARSHAL_SIZE 0x1000
 
 static __inline int yagl_marshal_skip(uint8_t** buff)
 {

diff --git a/hw/yagl_thread.c b/hw/yagl_thread.c
index 2458474..4b7adab 100644 (file)
--- a/hw/yagl_thread.c
+++ b/hw/yagl_thread.c
@@ -66,7 +66,7 @@ static void *yagl_thread_func(void* arg)
             struct yagl_api_ps *api_ps;
             yagl_api_func func;
 
-            if (current_buff >= (ts->current_out_buff + YAGL_BUFF_SIZE)) {
+            if (current_buff >= (ts->current_out_buff + YAGL_MARSHAL_SIZE)) {
                 YAGL_LOG_CRITICAL("batch passes the end of buffer, protocol error");
 
                 ret = false;

diff --git a/hw/yagl_version.h b/hw/yagl_version.h
index 11331ff..5832750 100644 (file)
--- a/hw/yagl_version.h
+++ b/hw/yagl_version.h
@@ -6,6 +6,6 @@
 /*
  * Whenever protocol changes be sure to bump this.
  */
-#define YAGL_VERSION 3
+#define YAGL_VERSION 4
 
 #endif