|
@@ -0,0 +1,2425 @@
|
|
|
+git diff upstream/7.10 and gitorious/7.10
|
|
|
+
|
|
|
+http://gitorious.org/mesa/mesa/commits/7.10
|
|
|
+
|
|
|
+diff --git a/configs/autoconf.in b/configs/autoconf.in
|
|
|
+index e2d70c6..5874955 100644
|
|
|
+--- a/configs/autoconf.in
|
|
|
++++ b/configs/autoconf.in
|
|
|
+@@ -120,7 +120,7 @@ OSMESA_LIB_DEPS = -L$(TOP)/$(LIB_DIR) @OSMESA_MESA_DEPS@ \
|
|
|
+ $(EXTRA_LIB_PATH) @OSMESA_LIB_DEPS@
|
|
|
+ EGL_LIB_DEPS = $(EXTRA_LIB_PATH) @EGL_LIB_DEPS@
|
|
|
+ GLU_LIB_DEPS = -L$(TOP)/$(LIB_DIR) @GLU_MESA_DEPS@ \
|
|
|
+- $(EXTRA_LIB_PATH) @GLU_LIB_DEPS@
|
|
|
++ $(EXTRA_LIB_PATH) @GLU_LIB_DEPS@ -lstdc++
|
|
|
+ GLUT_LIB_DEPS = -L$(TOP)/$(LIB_DIR) @GLUT_MESA_DEPS@ \
|
|
|
+ $(EXTRA_LIB_PATH) @GLUT_LIB_DEPS@
|
|
|
+ GLW_LIB_DEPS = -L$(TOP)/$(LIB_DIR) @GLW_MESA_DEPS@ \
|
|
|
+diff --git a/src/mesa/drivers/dri/glamo/Makefile b/src/mesa/drivers/dri/glamo/Makefile
|
|
|
+new file mode 100644
|
|
|
+index 0000000..e77193d
|
|
|
+--- /dev/null
|
|
|
++++ b/src/mesa/drivers/dri/glamo/Makefile
|
|
|
+@@ -0,0 +1,22 @@
|
|
|
++# src/mesa/drivers/dri/glamo/Makefile
|
|
|
++
|
|
|
++TOP = ../../../../..
|
|
|
++include $(TOP)/configs/current
|
|
|
++
|
|
|
++LIBNAME = glamo_dri.so
|
|
|
++
|
|
|
++DRIVER_SOURCES = \
|
|
|
++ glamo_screen.c glamo_context.c glamo_state.c glamo_fbo.c glamo_tris.c \
|
|
|
++ glamo_cmdq.c glamo_render.c
|
|
|
++
|
|
|
++C_SOURCES = \
|
|
|
++ $(COMMON_SOURCES) \
|
|
|
++ $(DRIVER_SOURCES)
|
|
|
++
|
|
|
++ASM_SOURCES =
|
|
|
++
|
|
|
++DRI_LIB_DEPS += -ldrm_glamo
|
|
|
++
|
|
|
++include ../Makefile.template
|
|
|
++
|
|
|
++symlinks:
|
|
|
+diff --git a/src/mesa/drivers/dri/glamo/glamo_cmdq.c b/src/mesa/drivers/dri/glamo/glamo_cmdq.c
|
|
|
+new file mode 100644
|
|
|
+index 0000000..1334f8e
|
|
|
+--- /dev/null
|
|
|
++++ b/src/mesa/drivers/dri/glamo/glamo_cmdq.c
|
|
|
+@@ -0,0 +1,110 @@
|
|
|
++/*
|
|
|
++ * Command queue submission via DRM
|
|
|
++ *
|
|
|
++ * Copyright 2009 Thomas White <taw@bitwiz.org.uk>
|
|
|
++ *
|
|
|
++ * This program is free software; you can redistribute it and/or
|
|
|
++ * modify it under the terms of the GNU General Public License as
|
|
|
++ * published by the Free Software Foundation; either version 2 of
|
|
|
++ * the License, or (at your option) any later version.
|
|
|
++ *
|
|
|
++ * 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.
|
|
|
++ *
|
|
|
++ * You should have received a copy of the GNU General Public License
|
|
|
++ * along with this program; if not, write to the Free Software
|
|
|
++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
|
|
|
++ * MA 02111-1307 USA
|
|
|
++ */
|
|
|
++
|
|
|
++
|
|
|
++#include <stdint.h>
|
|
|
++#include <stdlib.h>
|
|
|
++#include <drm.h>
|
|
|
++#include <glamo_drm.h>
|
|
|
++#include <glamo_bo.h>
|
|
|
++
|
|
|
++#include "glamo_context.h"
|
|
|
++#include "glamo_cmdq.h"
|
|
|
++
|
|
|
++
|
|
|
++/* Submit the prepared command sequence to the kernel */
|
|
|
++void glamoDRMDispatch(glamoContext *gCtx)
|
|
|
++{
|
|
|
++ drm_glamo_cmd_burst_t burst;
|
|
|
++ int r;
|
|
|
++
|
|
|
++ burst.base = gCtx->cmd_burst_base;
|
|
|
++ burst.data = gCtx->cmdq_drm;
|
|
|
++ burst.bufsz = gCtx->cmdq_drm_used * 2; /* -> bytes */
|
|
|
++ burst.nobjs = gCtx->cmdq_obj_used;
|
|
|
++ burst.objs = gCtx->cmdq_objs;
|
|
|
++ burst.obj_pos = gCtx->cmdq_obj_pos;
|
|
|
++
|
|
|
++ r = drmCommandWrite(gCtx->drm_fd, DRM_GLAMO_CMDBURST,
|
|
|
++ &burst, sizeof(burst));
|
|
|
++ if ( r != 0 ) {
|
|
|
++ fprintf(stderr, "DRM_GLAMO_CMDBURST failed\n");
|
|
|
++ }
|
|
|
++
|
|
|
++ /* Reset counts to zero for the next sequence */
|
|
|
++ gCtx->cmdq_obj_used = 0;
|
|
|
++ gCtx->cmdq_drm_used = 0;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++void glamoDRMAddData(glamoContext *gCtx, uint32_t val, int len)
|
|
|
++{
|
|
|
++ if ( gCtx->cmdq_drm_used+4 > gCtx->cmdq_drm_size ) {
|
|
|
++ fprintf(stderr, "Burst command too large\n");
|
|
|
++ return;
|
|
|
++ }
|
|
|
++
|
|
|
++ /* Record command */
|
|
|
++ if ( len == 2 ) {
|
|
|
++ gCtx->cmdq_drm[gCtx->cmdq_drm_used++] = val & 0xffff;
|
|
|
++ } else if ( len == 4 ) {
|
|
|
++ gCtx->cmdq_drm[gCtx->cmdq_drm_used++] = val & 0x0000ffff;
|
|
|
++ gCtx->cmdq_drm[gCtx->cmdq_drm_used++] = val & 0xffff0000;
|
|
|
++ } else {
|
|
|
++ fprintf(stderr, "Wrong command length!\n");
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++void glamoDRMAddBO(glamoContext *gCtx, struct glamo_bo *bo)
|
|
|
++{
|
|
|
++ if ( gCtx->cmdq_drm_used+4 > gCtx->cmdq_drm_size ) {
|
|
|
++ fprintf(stderr, "Burst command too large\n");
|
|
|
++ return;
|
|
|
++ }
|
|
|
++
|
|
|
++ /* Record object position */
|
|
|
++ gCtx->cmdq_objs[gCtx->cmdq_obj_used] = bo->handle;
|
|
|
++ /* -> bytes */
|
|
|
++ gCtx->cmdq_obj_pos[gCtx->cmdq_obj_used] = gCtx->cmdq_drm_used * 2;
|
|
|
++ gCtx->cmdq_obj_used++;
|
|
|
++
|
|
|
++ /* Record command */
|
|
|
++ gCtx->cmdq_drm[gCtx->cmdq_drm_used++] = 0x0000;
|
|
|
++ gCtx->cmdq_drm[gCtx->cmdq_drm_used++] = 0x0000;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++void glamoDRMStartBurst(glamoContext *gCtx, uint16_t base)
|
|
|
++{
|
|
|
++ gCtx->cmd_burst_base = base;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++void glamoInitCmdqCache(glamoContext *gCtx)
|
|
|
++{
|
|
|
++ gCtx->cmdq_objs = malloc(1024);
|
|
|
++ gCtx->cmdq_obj_pos = malloc(1024);
|
|
|
++ gCtx->cmdq_obj_used = 0;
|
|
|
++ gCtx->cmdq_drm_used = 0;
|
|
|
++ gCtx->cmdq_drm_size = 4 * 1024;
|
|
|
++ gCtx->cmdq_drm = malloc(gCtx->cmdq_drm_size);
|
|
|
++}
|
|
|
+diff --git a/src/mesa/drivers/dri/glamo/glamo_cmdq.h b/src/mesa/drivers/dri/glamo/glamo_cmdq.h
|
|
|
+new file mode 100644
|
|
|
+index 0000000..7420d7b
|
|
|
+--- /dev/null
|
|
|
++++ b/src/mesa/drivers/dri/glamo/glamo_cmdq.h
|
|
|
+@@ -0,0 +1,33 @@
|
|
|
++/*
|
|
|
++ * Command queue submission via DRM
|
|
|
++ *
|
|
|
++ * Copyright 2009 Thomas White <taw@bitwiz.org.uk>
|
|
|
++ *
|
|
|
++ * This program is free software; you can redistribute it and/or
|
|
|
++ * modify it under the terms of the GNU General Public License as
|
|
|
++ * published by the Free Software Foundation; either version 2 of
|
|
|
++ * the License, or (at your option) any later version.
|
|
|
++ *
|
|
|
++ * 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.
|
|
|
++ *
|
|
|
++ * You should have received a copy of the GNU General Public License
|
|
|
++ * along with this program; if not, write to the Free Software
|
|
|
++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
|
|
|
++ * MA 02111-1307 USA
|
|
|
++ */
|
|
|
++
|
|
|
++
|
|
|
++#include <stdint.h>
|
|
|
++#include <glamo_bo.h>
|
|
|
++
|
|
|
++#include "glamo_context.h"
|
|
|
++
|
|
|
++
|
|
|
++extern void glamoDRMDispatch(glamoContext *gCtx);
|
|
|
++extern void glamoDRMAddBO(glamoContext *gCtx, struct glamo_bo *bo);
|
|
|
++extern void glamoDRMAddData(glamoContext *gCtx, uint32_t val, int len);
|
|
|
++extern void glamoDRMStartBurst(glamoContext *gCtx, uint16_t base);
|
|
|
++extern void glamoInitCmdqCache(glamoContext *gCtx);
|
|
|
+diff --git a/src/mesa/drivers/dri/glamo/glamo_context.c b/src/mesa/drivers/dri/glamo/glamo_context.c
|
|
|
+new file mode 100644
|
|
|
+index 0000000..39eb4e7
|
|
|
+--- /dev/null
|
|
|
++++ b/src/mesa/drivers/dri/glamo/glamo_context.c
|
|
|
+@@ -0,0 +1,360 @@
|
|
|
++/*
|
|
|
++ * Direct Rendering Support for SMedia Glamo 336x/337x
|
|
|
++ *
|
|
|
++ * (c) 2009 Thomas White <taw@bitwiz.org.uk>
|
|
|
++ * Roughly based on sis_context.c (c) 2003 Eric Anholt
|
|
|
++ * and radeon_common_context.c
|
|
|
++ *
|
|
|
++ * Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
++ * copy of this software and associated documentation files (the "Software"),
|
|
|
++ * to deal in the Software without restriction, including without limitation
|
|
|
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
++ * and/or sell copies of the Software, and to permit persons to whom the
|
|
|
++ * Software is furnished to do so, subject to the following conditions:
|
|
|
++ *
|
|
|
++ * The above copyright notice and this permission notice shall be included
|
|
|
++ * in all copies or substantial portions of the Software.
|
|
|
++ *
|
|
|
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
|
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
++ * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
|
|
++ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
|
++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
++ */
|
|
|
++
|
|
|
++
|
|
|
++#include "dri_util.h"
|
|
|
++#include "drirenderbuffer.h"
|
|
|
++#include "utils.h"
|
|
|
++
|
|
|
++#include "swrast/swrast.h"
|
|
|
++#include "swrast_setup/swrast_setup.h"
|
|
|
++#include "drivers/common/driverfuncs.h"
|
|
|
++#include "vbo/vbo.h"
|
|
|
++#include "tnl/tnl.h"
|
|
|
++#include "tnl/t_pipeline.h"
|
|
|
++#include "main/state.h"
|
|
|
++
|
|
|
++#include "glamo_context.h"
|
|
|
++#include "glamo_screen.h"
|
|
|
++#include "glamo_state.h"
|
|
|
++#include "glamo_fbo.h"
|
|
|
++#include "glamo_tris.h"
|
|
|
++#include "glamo_render.h"
|
|
|
++#include "glamo_cmdq.h"
|
|
|
++
|
|
|
++#include <glamo_bo.h>
|
|
|
++#include <glamo_bo_gem.h>
|
|
|
++#include <glamo_drm.h>
|
|
|
++
|
|
|
++
|
|
|
++#define DRIVER_DATE "20090913"
|
|
|
++
|
|
|
++
|
|
|
++static inline struct glamo_renderbuffer *glamo_get_renderbuffer(
|
|
|
++ struct gl_framebuffer *fb,
|
|
|
++ int att_index)
|
|
|
++{
|
|
|
++ if ( att_index >= 0 ) {
|
|
|
++ struct glamo_renderbuffer *gr;
|
|
|
++ gr = glamo_renderbuffer(fb->Attachment[att_index].Renderbuffer);
|
|
|
++ return gr;
|
|
|
++ } else {
|
|
|
++ return NULL;
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static const GLubyte *glamoGetString(struct gl_context *ctx, GLenum name)
|
|
|
++{
|
|
|
++ static char buffer[128];
|
|
|
++
|
|
|
++ switch (name) {
|
|
|
++ case GL_VENDOR:
|
|
|
++ return (GLubyte *)"Thomas White";
|
|
|
++ case GL_RENDERER: {
|
|
|
++ driGetRendererString(buffer, "Glamo", DRIVER_DATE, 0);
|
|
|
++ return (GLubyte *) buffer;
|
|
|
++ }
|
|
|
++ default:
|
|
|
++ return 0;
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/* Called when Mesa needs to know the size of the framebuffer */
|
|
|
++static void glamoBufferSize(struct gl_framebuffer *buffer,
|
|
|
++ GLuint *width, GLuint *height)
|
|
|
++{
|
|
|
++ GET_CURRENT_CONTEXT(ctx);
|
|
|
++ glamoContextPtr glamo = GLAMO_CONTEXT(ctx);
|
|
|
++
|
|
|
++ *width = glamo->driDrawable->w;
|
|
|
++ *height = glamo->driDrawable->h;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++GLboolean glamoCreateContext(const struct gl_config *glVisual,
|
|
|
++ __DRIcontext *driContextPriv,
|
|
|
++ void *sharedContextPrivate)
|
|
|
++{
|
|
|
++ struct gl_context *ctx, *shareCtx;
|
|
|
++ __DRIscreen *sPriv = driContextPriv->driScreenPriv;
|
|
|
++ glamoContextPtr context;
|
|
|
++ glamoScreenPtr glamoScreen;
|
|
|
++ struct dd_function_table functions;
|
|
|
++
|
|
|
++ context = (glamoContextPtr)CALLOC(sizeof(*context));
|
|
|
++ if ( context == NULL ) return GL_FALSE;
|
|
|
++
|
|
|
++ _mesa_init_driver_functions(&functions);
|
|
|
++
|
|
|
++ /* Allocate the Mesa context */
|
|
|
++ if ( sharedContextPrivate )
|
|
|
++ shareCtx = ((glamoContextPtr)sharedContextPrivate)->glCtx;
|
|
|
++ else
|
|
|
++ shareCtx = NULL;
|
|
|
++ context->glCtx = _mesa_create_context(glVisual, shareCtx,
|
|
|
++ &functions, (void *)context);
|
|
|
++ if ( context->glCtx == NULL ) {
|
|
|
++ FREE(context);
|
|
|
++ return GL_FALSE;
|
|
|
++ }
|
|
|
++ driContextPriv->driverPrivate = context;
|
|
|
++ ctx = context->glCtx;
|
|
|
++
|
|
|
++ glamoScreen = context->glamoScreen = (glamoScreenPtr)sPriv->private;
|
|
|
++
|
|
|
++ ctx->Driver.GetString = glamoGetString;
|
|
|
++ ctx->Driver.GetBufferSize = glamoBufferSize;
|
|
|
++
|
|
|
++ context->driContext = driContextPriv;
|
|
|
++ context->driScreen = sPriv;
|
|
|
++ context->driDrawable = NULL;
|
|
|
++ context->drm_fd = sPriv->fd;
|
|
|
++
|
|
|
++ /* Initialize the software rasterizer and helper modules. */
|
|
|
++ _swrast_CreateContext(ctx);
|
|
|
++ _vbo_CreateContext(ctx);
|
|
|
++ _tnl_CreateContext(ctx);
|
|
|
++ _swsetup_CreateContext(ctx);
|
|
|
++
|
|
|
++ /* Install our pipeline (see glamo_render.c) */
|
|
|
++ _tnl_install_pipeline(ctx, glamo_pipeline);
|
|
|
++
|
|
|
++ _swrast_allow_pixel_fog(ctx, GL_TRUE);
|
|
|
++ _swrast_allow_vertex_fog(ctx, GL_FALSE);
|
|
|
++ _tnl_allow_pixel_fog(ctx, GL_TRUE);
|
|
|
++ _tnl_allow_vertex_fog(ctx, GL_FALSE);
|
|
|
++
|
|
|
++ glamoInitCmdqCache(context);
|
|
|
++ glamoInitStateFuncs(ctx);
|
|
|
++ glamoInitTriFuncs(ctx);
|
|
|
++
|
|
|
++ return GL_TRUE;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++void glamoDestroyContext(__DRIcontext *driContextPriv)
|
|
|
++{
|
|
|
++ glamoContextPtr context;
|
|
|
++
|
|
|
++ context = (glamoContextPtr)driContextPriv->driverPrivate;
|
|
|
++ assert(context != NULL);
|
|
|
++
|
|
|
++ if ( context != NULL ) {
|
|
|
++
|
|
|
++ _swsetup_DestroyContext(context->glCtx);
|
|
|
++ _tnl_DestroyContext(context->glCtx);
|
|
|
++ _vbo_DestroyContext(context->glCtx);
|
|
|
++ _swrast_DestroyContext(context->glCtx);
|
|
|
++
|
|
|
++ _mesa_destroy_context(context->glCtx);
|
|
|
++
|
|
|
++ }
|
|
|
++
|
|
|
++ FREE(context);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++void glamo_update_renderbuffers(__DRIcontext *context,
|
|
|
++ __DRIdrawable *drawable)
|
|
|
++{
|
|
|
++ unsigned int attachments[10];
|
|
|
++ __DRIbuffer *buffers;
|
|
|
++ __DRIscreen *screen;
|
|
|
++ int i, count;
|
|
|
++ struct glamo_framebuffer *draw;
|
|
|
++ glamoContextPtr glamo;
|
|
|
++ struct glamo_bo *bo;
|
|
|
++
|
|
|
++ draw = drawable->driverPrivate;
|
|
|
++ screen = context->driScreenPriv;
|
|
|
++ glamo = (glamoContextPtr)context->driverPrivate;
|
|
|
++ i = 0;
|
|
|
++ if ( draw->color_rb[0] ) {
|
|
|
++ attachments[i++] = __DRI_BUFFER_FRONT_LEFT;
|
|
|
++ }
|
|
|
++ if ( draw->color_rb[1] ) {
|
|
|
++ attachments[i++] = __DRI_BUFFER_BACK_LEFT;
|
|
|
++ }
|
|
|
++
|
|
|
++ buffers = screen->dri2.loader->getBuffers(drawable,
|
|
|
++ &drawable->w,
|
|
|
++ &drawable->h,
|
|
|
++ attachments, i,
|
|
|
++ &count,
|
|
|
++ drawable->loaderPrivate);
|
|
|
++ if ( buffers == NULL ) return;
|
|
|
++
|
|
|
++ /* Set one cliprect to cover the whole drawable */
|
|
|
++ drawable->x = 0;
|
|
|
++ drawable->y = 0;
|
|
|
++ drawable->backX = 0;
|
|
|
++ drawable->backY = 0;
|
|
|
++ drawable->numClipRects = 1;
|
|
|
++ drawable->pClipRects[0].x1 = 0;
|
|
|
++ drawable->pClipRects[0].y1 = 0;
|
|
|
++ drawable->pClipRects[0].x2 = drawable->w;
|
|
|
++ drawable->pClipRects[0].y2 = drawable->h;
|
|
|
++ drawable->numBackClipRects = 1;
|
|
|
++ drawable->pBackClipRects[0].x1 = 0;
|
|
|
++ drawable->pBackClipRects[0].y1 = 0;
|
|
|
++ drawable->pBackClipRects[0].x2 = drawable->w;
|
|
|
++ drawable->pBackClipRects[0].y2 = drawable->h;
|
|
|
++
|
|
|
++ /* For each attachment */
|
|
|
++ for ( i=0; i<count; i++ ) {
|
|
|
++
|
|
|
++ struct glamo_renderbuffer *grb;
|
|
|
++
|
|
|
++ switch ( buffers[i].attachment ) {
|
|
|
++ case __DRI_BUFFER_FRONT_LEFT:
|
|
|
++ grb = draw->color_rb[0];
|
|
|
++ break;
|
|
|
++ case __DRI_BUFFER_BACK_LEFT:
|
|
|
++ grb = draw->color_rb[1];
|
|
|
++ break;
|
|
|
++ case __DRI_BUFFER_DEPTH:
|
|
|
++ grb = glamo_get_renderbuffer(&draw->base, BUFFER_DEPTH);
|
|
|
++ break;
|
|
|
++ case __DRI_BUFFER_STENCIL:
|
|
|
++ grb = glamo_get_renderbuffer(&draw->base,
|
|
|
++ BUFFER_STENCIL);
|
|
|
++ break;
|
|
|
++ case __DRI_BUFFER_FAKE_FRONT_LEFT:
|
|
|
++ grb = draw->color_rb[0];
|
|
|
++ break;
|
|
|
++ case __DRI_BUFFER_ACCUM:
|
|
|
++ default:
|
|
|
++ fprintf(stderr,
|
|
|
++ "Unhandled buffer attach event,"
|
|
|
++ " attachment type %d\n", buffers[i].attachment);
|
|
|
++ return;
|
|
|
++ }
|
|
|
++
|
|
|
++ if ( grb == NULL ) {
|
|
|
++ /* Don't know how to handle this type of buffer */
|
|
|
++ continue;
|
|
|
++ }
|
|
|
++
|
|
|
++ if ( grb->bo ) {
|
|
|
++ uint32_t name = glamo_gem_get_name(grb->bo);
|
|
|
++ if ( name == buffers[i].name ) {
|
|
|
++ /* Buffer already attached. No action needed */
|
|
|
++ continue;
|
|
|
++ }
|
|
|
++ }
|
|
|
++
|
|
|
++ grb->cpp = buffers[i].cpp;
|
|
|
++ grb->pitch = buffers[i].pitch;
|
|
|
++ grb->width = drawable->w;
|
|
|
++ grb->height = drawable->h;
|
|
|
++
|
|
|
++ bo = glamo_bo_open(glamo->glamoScreen->bom, buffers[i].name,
|
|
|
++ 0, 0, GLAMO_GEM_DOMAIN_VRAM,
|
|
|
++ buffers[i].flags);
|
|
|
++ if ( bo == NULL ) {
|
|
|
++ fprintf(stderr, "Failed to attach buffer %d\n",
|
|
|
++ buffers[i].name);
|
|
|
++ }
|
|
|
++
|
|
|
++ glamo_renderbuffer_set_bo(grb, bo);
|
|
|
++ glamo_bo_unref(bo);
|
|
|
++
|
|
|
++ }
|
|
|
++
|
|
|
++ driUpdateFramebufferSize(glamo->glCtx, drawable);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++GLboolean glamoMakeCurrent(__DRIcontext *driContextPriv,
|
|
|
++ __DRIdrawable *driDrawPriv,
|
|
|
++ __DRIdrawable *driReadPriv)
|
|
|
++{
|
|
|
++ struct glamo_framebuffer *draw_fb;
|
|
|
++ struct gl_framebuffer *read_fb;
|
|
|
++ glamoContextPtr glamo;
|
|
|
++
|
|
|
++ if ( driContextPriv == NULL ) {
|
|
|
++ _mesa_make_current(NULL, NULL, NULL);
|
|
|
++ return GL_TRUE;
|
|
|
++ }
|
|
|
++
|
|
|
++ /* The Glamo context we're switching to */
|
|
|
++ glamo = (glamoContextPtr)driContextPriv->driverPrivate;
|
|
|
++
|
|
|
++ glamo->driDrawable = driDrawPriv;
|
|
|
++
|
|
|
++ /* These two will probably be the same */
|
|
|
++ draw_fb = (struct glamo_framebuffer *)driDrawPriv->driverPrivate;
|
|
|
++ read_fb = (struct gl_framebuffer *)driReadPriv->driverPrivate;
|
|
|
++
|
|
|
++ glamo_update_renderbuffers(driContextPriv, driDrawPriv);
|
|
|
++ if (driDrawPriv != driReadPriv)
|
|
|
++ glamo_update_renderbuffers(driContextPriv, driReadPriv);
|
|
|
++
|
|
|
++ _mesa_make_current(glamo->glCtx, &draw_fb->base, read_fb);
|
|
|
++ _mesa_update_state(glamo->glCtx);
|
|
|
++
|
|
|
++ return GL_TRUE;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++GLboolean glamoUnbindContext(__DRIcontext *driContextPriv)
|
|
|
++{
|
|
|
++ return GL_TRUE;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/* Convert IEEE754 32-bit float to Glamo's signed 24-bit float */
|
|
|
++uint32_t float7s16(GLfloat in)
|
|
|
++{
|
|
|
++ uint32_t a, b;
|
|
|
++ uint32_t sign, expo, mant; /* Sign, exponent, significand */
|
|
|
++
|
|
|
++ a = *(uint32_t *)∈
|
|
|
++
|
|
|
++ /* This is bad */
|
|
|
++ if ( a & 0x40000000 ) {
|
|
|
++ printf(stderr, "Warning: Exponent won't fit into 7 bits\n");
|
|
|
++ }
|
|
|
++
|
|
|
++ /* This hopefully isn't a big problem */
|
|
|
++ if ( a & 0x0000007f ) {
|
|
|
++ printf(stderr, "Warning: Precision lost in FP conversion\n");
|
|
|
++ }
|
|
|
++
|
|
|
++ /* Separate out the right bits */
|
|
|
++ mant = a & 0x007fff80; /* Bits 7-22 (bits 0-6 are lost) */
|
|
|
++ expo = a & 0x3f800000; /* Bits 23-29 (bit 30 is lost) */
|
|
|
++ sign = a & 0x80000000; /* Bit 31 */
|
|
|
++
|
|
|
++ /* Shift and recombine */
|
|
|
++ b = sign >> 8; /* Fills bit 23 */
|
|
|
++ b |= expo >> 7; /* Fills bits 16-22 */
|
|
|
++ b |= mant >> 7; /* Fills bits 0-15 */
|
|
|
++
|
|
|
++ return b;
|
|
|
++}
|
|
|
+diff --git a/src/mesa/drivers/dri/glamo/glamo_context.h b/src/mesa/drivers/dri/glamo/glamo_context.h
|
|
|
+new file mode 100644
|
|
|
+index 0000000..8de3946
|
|
|
+--- /dev/null
|
|
|
++++ b/src/mesa/drivers/dri/glamo/glamo_context.h
|
|
|
+@@ -0,0 +1,106 @@
|
|
|
++/*
|
|
|
++ * Direct Rendering Support for SMedia Glamo 336x/337x
|
|
|
++ *
|
|
|
++ * (c) 2009 Thomas White <taw@bitwiz.org.uk>
|
|
|
++ * Roughly based on sis_context.h (c) 2003 Eric Anholt
|
|
|
++ *
|
|
|
++ * Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
++ * copy of this software and associated documentation files (the "Software"),
|
|
|
++ * to deal in the Software without restriction, including without limitation
|
|
|
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
++ * and/or sell copies of the Software, and to permit persons to whom the
|
|
|
++ * Software is furnished to do so, subject to the following conditions:
|
|
|
++ *
|
|
|
++ * The above copyright notice and this permission notice shall be included
|
|
|
++ * in all copies or substantial portions of the Software.
|
|
|
++ *
|
|
|
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
|
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
++ * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
|
|
++ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
|
++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
++ */
|
|
|
++
|
|
|
++#ifndef __GLAMO_CONTEXT_H
|
|
|
++#define __GLAMO_CONTEXT_H
|
|
|
++
|
|
|
++
|
|
|
++#include "dri_util.h"
|
|
|
++#include "utils.h"
|
|
|
++#include "tnl/t_vertex.h"
|
|
|
++
|
|
|
++#include "glamo_screen.h"
|
|
|
++
|
|
|
++
|
|
|
++typedef struct glamo_context glamoContext;
|
|
|
++typedef struct glamo_context *glamoContextPtr;
|
|
|
++
|
|
|
++struct glamo_context {
|
|
|
++
|
|
|
++ struct gl_context *glCtx; /* Must be first in this structure */
|
|
|
++
|
|
|
++ int drm_fd; /* DRM fd */
|
|
|
++
|
|
|
++ __DRIcontext *driContext; /* DRI context */
|
|
|
++ __DRIscreen *driScreen; /* DRI screen */
|
|
|
++ __DRIdrawable *driDrawable; /* DRI drawable bound to this ctx */
|
|
|
++
|
|
|
++ glamoScreenPtr glamoScreen; /* Screen private DRI data */
|
|
|
++
|
|
|
++ driOptionCache optionCache;
|
|
|
++
|
|
|
++ uint16_t *cmdq_drm; /* Command queue cache */
|
|
|
++ uint16_t cmd_burst_base;
|
|
|
++ int cmdq_drm_used;
|
|
|
++ int cmdq_drm_size;
|
|
|
++ int cmdq_obj_used;
|
|
|
++ uint32_t *cmdq_objs;
|
|
|
++ unsigned int *cmdq_obj_pos;
|
|
|
++
|
|
|
++ /* Information about the current primitive */
|
|
|
++ struct {
|
|
|
++ GLuint id;
|
|
|
++ uint32_t primitive; /* Current hardware primitive type */
|
|
|
++ struct glamo_bo *vb_bo;
|
|
|
++ uint8_t *vb;
|
|
|
++ unsigned int start_offset; /* Byte offset of start */
|
|
|
++ unsigned int current_offset; /* Byte offset of next vertex */
|
|
|
++ unsigned int count; /* Number of vertices */
|
|
|
++ } prim;
|
|
|
++
|
|
|
++ /* Current vertex format and attributes */
|
|
|
++ int vertex_size;
|
|
|
++ struct tnl_attr_map vertex_attrs[VERT_ATTRIB_MAX];
|
|
|
++
|
|
|
++ /* State */
|
|
|
++ GLuint new_state; /* State which must be updated */
|
|
|
++ uint16_t col_clear;
|
|
|
++
|
|
|
++};
|
|
|
++
|
|
|
++#define GLAMO_CONTEXT(ctx) ((glamoContextPtr)(ctx->DriverCtx))
|
|
|
++
|
|
|
++#define TAG(x) glamo##x
|
|
|
++#include "tnl_dd/t_dd_vertex.h"
|
|
|
++#undef TAG
|
|
|
++
|
|
|
++extern GLboolean glamoCreateContext(const struct gl_config *glVis,
|
|
|
++ __DRIcontext *driContextPriv,
|
|
|
++ void *sharedContextPrivate);
|
|
|
++extern void glamoDestroyContext(__DRIcontext *dcp);
|
|
|
++extern GLboolean glamoMakeCurrent(__DRIcontext *driContextPriv,
|
|
|
++ __DRIdrawable *driDrawPriv,
|
|
|
++ __DRIdrawable *driReadPriv);
|
|
|
++extern GLboolean glamoUnbindContext(__DRIcontext *driContextPriv);
|
|
|
++extern void glamo_update_renderbuffers(__DRIcontext *context,
|
|
|
++ __DRIdrawable *drawable);
|
|
|
++
|
|
|
++#define GLAMO_PACKCOLOR565(r, g, b) \
|
|
|
++ ((((r) & 0xf8) << 8) \
|
|
|
++ | (((g) & 0xfc) << 3) \
|
|
|
++ | (((b) & 0xf8) >> 3))
|
|
|
++
|
|
|
++extern uint32_t float7s16(GLfloat in);
|
|
|
++
|
|
|
++#endif /* __GLAMO_CONTEXT_H */
|
|
|
+diff --git a/src/mesa/drivers/dri/glamo/glamo_fbo.c b/src/mesa/drivers/dri/glamo/glamo_fbo.c
|
|
|
+new file mode 100644
|
|
|
+index 0000000..e25ca31
|
|
|
+--- /dev/null
|
|
|
++++ b/src/mesa/drivers/dri/glamo/glamo_fbo.c
|
|
|
+@@ -0,0 +1,130 @@
|
|
|
++/*
|
|
|
++ * Direct Rendering Support for SMedia Glamo 336x/337x
|
|
|
++ *
|
|
|
++ * (c) 2009 Thomas White <taw@bitwiz.org.uk>
|
|
|
++ * Roughly based on radeon_fbo.c (c) 2008 Red Hat Inc
|
|
|
++ *
|
|
|
++ * Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
++ * copy of this software and associated documentation files (the "Software"),
|
|
|
++ * to deal in the Software without restriction, including without limitation
|
|
|
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
++ * and/or sell copies of the Software, and to permit persons to whom the
|
|
|
++ * Software is furnished to do so, subject to the following conditions:
|
|
|
++ *
|
|
|
++ * The above copyright notice and this permission notice shall be included
|
|
|
++ * in all copies or substantial portions of the Software.
|
|
|
++ *
|
|
|
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
|
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
++ * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
|
|
++ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
|
++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
++ */
|
|
|
++
|
|
|
++
|
|
|
++#include "main/imports.h"
|
|
|
++#include "main/macros.h"
|
|
|
++#include "main/mtypes.h"
|
|
|
++#include "main/formats.h"
|
|
|
++#include "main/fbobject.h"
|
|
|
++#include "main/framebuffer.h"
|
|
|
++#include "main/renderbuffer.h"
|
|
|
++#include "main/context.h"
|
|
|
++#include "dri_util.h"
|
|
|
++
|
|
|
++/* This comes from libdrm_glamo */
|
|
|
++#include <glamo_bo.h>
|
|
|
++
|
|
|
++#include "glamo_fbo.h"
|
|
|
++
|
|
|
++
|
|
|
++static void glamo_delete_renderbuffer(struct gl_renderbuffer *rb)
|
|
|
++{
|
|
|
++ struct glamo_renderbuffer *grb = glamo_renderbuffer(rb);
|
|
|
++
|
|
|
++ ASSERT(grb);
|
|
|
++
|
|
|
++ if ( grb && grb->bo ) {
|
|
|
++ glamo_bo_unref(grb->bo);
|
|
|
++ }
|
|
|
++ free(grb);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void *glamo_get_pointer(struct gl_context *ctx, struct gl_renderbuffer *rb,
|
|
|
++ GLint x, GLint y)
|
|
|
++{
|
|
|
++ return NULL; /* Can't be directly addressed */
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/* Called for each hardware renderbuffer when a _window_ is resized.
|
|
|
++ * Just update fields.
|
|
|
++ * Not used for user-created renderbuffers!
|
|
|
++ */
|
|
|
++static GLboolean glamo_alloc_window_storage(struct gl_context *ctx,
|
|
|
++ struct gl_renderbuffer *rb,
|
|
|
++ GLenum internalFormat,
|
|
|
++ GLuint width, GLuint height)
|
|
|
++{
|
|
|
++ ASSERT(rb->Name == 0);
|
|
|
++ rb->Width = width;
|
|
|
++ rb->Height = height;
|
|
|
++ rb->Format = internalFormat;
|
|
|
++ return GL_TRUE;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/* Create a buffer, such as a colour or depth buffer */
|
|
|
++struct glamo_renderbuffer *glamo_create_renderbuffer(GLenum format,
|
|
|
++ __DRIdrawable *driDrawPriv)
|
|
|
++{
|
|
|
++ struct glamo_renderbuffer *grb;
|
|
|
++
|
|
|
++ grb = CALLOC_STRUCT(glamo_renderbuffer);
|
|
|
++ if ( !grb ) return NULL;
|
|
|
++
|
|
|
++ _mesa_init_renderbuffer(&grb->base, 0);
|
|
|
++ grb->base.ClassID = GLAMO_RB_CLASS;
|
|
|
++
|
|
|
++ switch (format) {
|
|
|
++ case GL_RGB5:
|
|
|
++ grb->base.Format = MESA_FORMAT_RGB565;
|
|
|
++ grb->base._BaseFormat = GL_RGB;
|
|
|
++
|
|
|
++ grb->base.DataType = GL_UNSIGNED_BYTE;
|
|
|
++ break;
|
|
|
++ case GL_DEPTH_COMPONENT16:
|
|
|
++ grb->base.DataType = GL_UNSIGNED_SHORT;
|
|
|
++ grb->base._BaseFormat = GL_DEPTH_COMPONENT;
|
|
|
++ break;
|
|
|
++ default:
|
|
|
++ fprintf(stderr, "%s: Unknown format 0x%04x\n", __FUNCTION__, format);
|
|
|
++ _mesa_delete_renderbuffer(&grb->base);
|
|
|
++ return NULL;
|
|
|
++ }
|
|
|
++
|
|
|
++ grb->dPriv = driDrawPriv;
|
|
|
++ grb->base.InternalFormat = format;
|
|
|
++
|
|
|
++ grb->base.Delete = glamo_delete_renderbuffer;
|
|
|
++ grb->base.AllocStorage = glamo_alloc_window_storage;
|
|
|
++ grb->base.GetPointer = glamo_get_pointer;
|
|
|
++
|
|
|
++ return grb;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++void glamo_renderbuffer_set_bo(struct glamo_renderbuffer *grb,
|
|
|
++ struct glamo_bo *bo)
|
|
|
++{
|
|
|
++ struct glamo_bo *old;
|
|
|
++ old = grb->bo;
|
|
|
++ grb->bo = bo;
|
|
|
++ glamo_bo_ref(bo);
|
|
|
++ if ( old ) glamo_bo_unref(old);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/* kate: space-indent on; indent-width 3; mixedindent off; indent-mode cstyle; */
|
|
|
+diff --git a/src/mesa/drivers/dri/glamo/glamo_fbo.h b/src/mesa/drivers/dri/glamo/glamo_fbo.h
|
|
|
+new file mode 100644
|
|
|
+index 0000000..48210dd
|
|
|
+--- /dev/null
|
|
|
++++ b/src/mesa/drivers/dri/glamo/glamo_fbo.h
|
|
|
+@@ -0,0 +1,77 @@
|
|
|
++/*
|
|
|
++ * Direct Rendering Support for SMedia Glamo 336x/337x
|
|
|
++ *
|
|
|
++ * (c) 2009 Thomas White <taw@bitwiz.org.uk>
|
|
|
++ *
|
|
|
++ * Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
++ * copy of this software and associated documentation files (the "Software"),
|
|
|
++ * to deal in the Software without restriction, including without limitation
|
|
|
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
++ * and/or sell copies of the Software, and to permit persons to whom the
|
|
|
++ * Software is furnished to do so, subject to the following conditions:
|
|
|
++ *
|
|
|
++ * The above copyright notice and this permission notice shall be included
|
|
|
++ * in all copies or substantial portions of the Software.
|
|
|
++ *
|
|
|
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
|
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
++ * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
|
|
++ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
|
++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
++ */
|
|
|
++
|
|
|
++#ifndef __GLAMO_FBO_H
|
|
|
++#define __GLAMO_FBO_H
|
|
|
++
|
|
|
++
|
|
|
++#include "main/mtypes.h"
|
|
|
++#include "dri_util.h"
|
|
|
++
|
|
|
++
|
|
|
++/* This is just a marker so we can tell a Glamo renderbuffer from a Mesa one */
|
|
|
++#define GLAMO_RB_CLASS (0xdeadbeef)
|
|
|
++
|
|
|
++
|
|
|
++struct glamo_renderbuffer
|
|
|
++{
|
|
|
++ struct gl_renderbuffer base; /* Must be first */
|
|
|
++ struct glamo_bo *bo;
|
|
|
++ unsigned int cpp;
|
|
|
++ unsigned int pitch;
|
|
|
++ unsigned int width;
|
|
|
++ unsigned int height;
|
|
|
++
|
|
|
++ __DRIdrawable *dPriv;
|
|
|
++};
|
|
|
++
|
|
|
++
|
|
|
++struct glamo_framebuffer
|
|
|
++{
|
|
|
++ struct gl_framebuffer base;
|
|
|
++ struct glamo_renderbuffer *color_rb[2];
|
|
|
++};
|
|
|
++
|
|
|
++
|
|
|
++/* This is just a small wrapper function to return NULL if the gl_renderbuffer
|
|
|
++ * is not a glamo_renderbuffer */
|
|
|
++static inline struct glamo_renderbuffer
|
|
|
++ *glamo_renderbuffer(struct gl_renderbuffer *rb)
|
|
|
++{
|
|
|
++ struct glamo_renderbuffer *grb = (struct glamo_renderbuffer *)rb;
|
|
|
++ if ( grb && grb->base.ClassID == GLAMO_RB_CLASS )
|
|
|
++ return grb;
|
|
|
++ else
|
|
|
++ return NULL;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++extern struct glamo_renderbuffer *glamo_create_renderbuffer(GLenum format,
|
|
|
++ __DRIdrawable *driDrawPriv);
|
|
|
++
|
|
|
++extern void glamo_renderbuffer_set_bo(struct glamo_renderbuffer *grb,
|
|
|
++ struct glamo_bo *bo);
|
|
|
++
|
|
|
++#endif /* __GLAMO_FBO_H */
|
|
|
++
|
|
|
++/* kate: space-indent on; indent-width 3; mixedindent off; indent-mode cstyle; */
|
|
|
+diff --git a/src/mesa/drivers/dri/glamo/glamo_regs.h b/src/mesa/drivers/dri/glamo/glamo_regs.h
|
|
|
+new file mode 100644
|
|
|
+index 0000000..02b2294
|
|
|
+--- /dev/null
|
|
|
++++ b/src/mesa/drivers/dri/glamo/glamo_regs.h
|
|
|
+@@ -0,0 +1,174 @@
|
|
|
++#ifndef _GLAMO_REGS_H
|
|
|
++#define _GLAMO_REGS_H
|
|
|
++
|
|
|
++/* Smedia Glamo 336x/337x driver
|
|
|
++ *
|
|
|
++ * (C) 2007 by OpenMoko, Inc.
|
|
|
++ * Author: Harald Welte <laforge@openmoko.org>
|
|
|
++ * All rights reserved.
|
|
|
++ *
|
|
|
++ * Modified for Glamo Mesa driver by Thomas White <taw@bitwiz.org.uk>
|
|
|
++ *
|
|
|
++ * This program is free software; you can redistribute it and/or
|
|
|
++ * modify it under the terms of the GNU General Public License as
|
|
|
++ * published by the Free Software Foundation; either version 2 of
|
|
|
++ * the License, or (at your option) any later version.
|
|
|
++ *
|
|
|
++ * 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.
|
|
|
++ *
|
|
|
++ * You should have received a copy of the GNU General Public License
|
|
|
++ * along with this program; if not, write to the Free Software
|
|
|
++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
|
|
|
++ * MA 02111-1307 USA
|
|
|
++ */
|
|
|
++
|
|
|
++enum glamo_regster_offsets {
|
|
|
++ GLAMO_REGOFS_GENERIC = 0x0000,
|
|
|
++ GLAMO_REGOFS_HOSTBUS = 0x0200,
|
|
|
++ GLAMO_REGOFS_MEMORY = 0x0300,
|
|
|
++ GLAMO_REGOFS_VIDCAP = 0x0400,
|
|
|
++ GLAMO_REGOFS_ISP = 0x0500,
|
|
|
++ GLAMO_REGOFS_JPEG = 0x0800,
|
|
|
++ GLAMO_REGOFS_MPEG = 0x0c00,
|
|
|
++ GLAMO_REGOFS_LCD = 0x1100,
|
|
|
++ GLAMO_REGOFS_MMC = 0x1400,
|
|
|
++ GLAMO_REGOFS_MPROC0 = 0x1500,
|
|
|
++ GLAMO_REGOFS_MPROC1 = 0x1580,
|
|
|
++ GLAMO_REGOFS_CMDQUEUE = 0x1600,
|
|
|
++ GLAMO_REGOFS_RISC = 0x1680,
|
|
|
++ GLAMO_REGOFS_2D = 0x1700,
|
|
|
++ GLAMO_REGOFS_3D = 0x1b00,
|
|
|
++};
|
|
|
++
|
|
|
++
|
|
|
++#define REG_MPEG(x) (GLAMO_REGOFS_MPEG+(x))
|
|
|
++
|
|
|
++enum glamo_register_mpeg {
|
|
|
++ //
|
|
|
++ GLAMO_REG_MPEG_DC_ADDRL = REG_MPEG(0x3c),
|
|
|
++ GLAMO_REG_MPEG_DC_ADDRH = REG_MPEG(0x3e),
|
|
|
++ GLAMO_REG_MPEG_AC_ADDRL = REG_MPEG(0x40),
|
|
|
++ GLAMO_REG_MPEG_AC_ADDRH = REG_MPEG(0x42),
|
|
|
++ //
|
|
|
++ GLAMO_REG_MPEG_SAFE_1 = REG_MPEG(0x60),
|
|
|
++ GLAMO_REG_MPEG_SAFE_2 = REG_MPEG(0x62),
|
|
|
++ GLAMO_REG_MPEG_SAFE_3 = REG_MPEG(0x64),
|
|
|
++ //
|
|
|
++ GLAMO_REG_MPEG_DEC_OUT0_Y_ADDRL = REG_MPEG(0x6e),
|
|
|
++ GLAMO_REG_MPEG_DEC_OUT0_Y_ADDRH = REG_MPEG(0x70),
|
|
|
++ GLAMO_REG_MPEG_DEC_OUT0_U_ADDRL = REG_MPEG(0x72),
|
|
|
++ GLAMO_REG_MPEG_DEC_OUT0_U_ADDRH = REG_MPEG(0x74),
|
|
|
++ GLAMO_REG_MPEG_DEC_OUT0_V_ADDRL = REG_MPEG(0x76),
|
|
|
++ GLAMO_REG_MPEG_DEC_OUT0_V_ADDRH = REG_MPEG(0x78),
|
|
|
++ GLAMO_REG_MPEG_DEC_OUT1_Y_ADDRL = REG_MPEG(0x7a),
|
|
|
++ GLAMO_REG_MPEG_DEC_OUT1_Y_ADDRH = REG_MPEG(0x7c),
|
|
|
++ GLAMO_REG_MPEG_DEC_OUT1_U_ADDRL = REG_MPEG(0x7e),
|
|
|
++ GLAMO_REG_MPEG_DEC_OUT1_U_ADDRH = REG_MPEG(0x80),
|
|
|
++ GLAMO_REG_MPEG_DEC_OUT1_V_ADDRL = REG_MPEG(0x82),
|
|
|
++ GLAMO_REG_MPEG_DEC_OUT1_V_ADDRH = REG_MPEG(0x84),
|
|
|
++ GLAMO_REG_MPEG_DEC_OUT2_Y_ADDRL = REG_MPEG(0x86),
|
|
|
++ GLAMO_REG_MPEG_DEC_OUT2_Y_ADDRH = REG_MPEG(0x88),
|
|
|
++ GLAMO_REG_MPEG_DEC_OUT2_U_ADDRL = REG_MPEG(0x8a),
|
|
|
++ GLAMO_REG_MPEG_DEC_OUT2_U_ADDRH = REG_MPEG(0x8c),
|
|
|
++ GLAMO_REG_MPEG_DEC_OUT2_V_ADDRL = REG_MPEG(0x8e),
|
|
|
++ GLAMO_REG_MPEG_DEC_OUT2_V_ADDRH = REG_MPEG(0x90),
|
|
|
++ GLAMO_REG_MPEG_DEC_WIDTH = REG_MPEG(0x92),
|
|
|
++ GLAMO_REG_MPEG_DEC_HEIGHT = REG_MPEG(0x94),
|
|
|
++ GLAMO_REG_MPEG_SPECIAL = REG_MPEG(0x96),
|
|
|
++ GLAMO_REG_MPEG_DEC_IN_ADDRL = REG_MPEG(0x98),
|
|
|
++ GLAMO_REG_MPEG_DEC_IN_ADDRH = REG_MPEG(0x9a),
|
|
|
++ //
|
|
|
++ GLAMO_REG_MPEG_DEBLK_THRESHOLD = REG_MPEG(0xc0),
|
|
|
++ //
|
|
|
++ GLAMO_REG_MPEG_DEC_STATUS = REG_MPEG(0xc8),
|
|
|
++ GLAMO_REG_MPEG_DEC_RB0 = REG_MPEG(0xca),
|
|
|
++ GLAMO_REG_MPEG_DEC_RB1 = REG_MPEG(0xcc),
|
|
|
++};
|
|
|
++
|
|
|
++
|
|
|
++#define REG_2D(x) (GLAMO_REGOFS_2D+(x))
|
|
|
++
|
|
|
++enum glamo_register_2d {
|
|
|
++ GLAMO_REG_2D_SRC_ADDRL = REG_2D(0x00),
|
|
|
++ GLAMO_REG_2D_SRC_ADDRH = REG_2D(0x02),
|
|
|
++ GLAMO_REG_2D_SRC_PITCH = REG_2D(0x04),
|
|
|
++ GLAMO_REG_2D_SRC_X = REG_2D(0x06),
|
|
|
++ GLAMO_REG_2D_SRC_Y = REG_2D(0x08),
|
|
|
++ GLAMO_REG_2D_DST_X = REG_2D(0x0a),
|
|
|
++ GLAMO_REG_2D_DST_Y = REG_2D(0x0c),
|
|
|
++ GLAMO_REG_2D_DST_ADDRL = REG_2D(0x0e),
|
|
|
++ GLAMO_REG_2D_DST_ADDRH = REG_2D(0x10),
|
|
|
++ GLAMO_REG_2D_DST_PITCH = REG_2D(0x12),
|
|
|
++ GLAMO_REG_2D_DST_HEIGHT = REG_2D(0x14),
|
|
|
++ GLAMO_REG_2D_RECT_WIDTH = REG_2D(0x16),
|
|
|
++ GLAMO_REG_2D_RECT_HEIGHT = REG_2D(0x18),
|
|
|
++ GLAMO_REG_2D_PAT_ADDRL = REG_2D(0x1a),
|
|
|
++ GLAMO_REG_2D_PAT_ADDRH = REG_2D(0x1c),
|
|
|
++ GLAMO_REG_2D_PAT_FG = REG_2D(0x1e),
|
|
|
++ GLAMO_REG_2D_PAT_BG = REG_2D(0x20),
|
|
|
++ GLAMO_REG_2D_SRC_FG = REG_2D(0x22),
|
|
|
++ GLAMO_REG_2D_SRC_BG = REG_2D(0x24),
|
|
|
++ GLAMO_REG_2D_MASK1 = REG_2D(0x26),
|
|
|
++ GLAMO_REG_2D_MASK2 = REG_2D(0x28),
|
|
|
++ GLAMO_REG_2D_MASK3 = REG_2D(0x2a),
|
|
|
++ GLAMO_REG_2D_MASK4 = REG_2D(0x2c),
|
|
|
++ GLAMO_REG_2D_ROT_X = REG_2D(0x2e),
|
|
|
++ GLAMO_REG_2D_ROT_Y = REG_2D(0x30),
|
|
|
++ GLAMO_REG_2D_LEFT_CLIP = REG_2D(0x32),
|
|
|
++ GLAMO_REG_2D_TOP_CLIP = REG_2D(0x34),
|
|
|
++ GLAMO_REG_2D_RIGHT_CLIP = REG_2D(0x36),
|
|
|
++ GLAMO_REG_2D_BOTTOM_CLIP = REG_2D(0x38),
|
|
|
++ GLAMO_REG_2D_COMMAND1 = REG_2D(0x3A),
|
|
|
++ GLAMO_REG_2D_COMMAND2 = REG_2D(0x3C),
|
|
|
++ GLAMO_REG_2D_COMMAND3 = REG_2D(0x3E),
|
|
|
++ GLAMO_REG_2D_SAFE = REG_2D(0x40),
|
|
|
++ GLAMO_REG_2D_STATUS = REG_2D(0x42),
|
|
|
++ GLAMO_REG_2D_ID1 = REG_2D(0x44),
|
|
|
++ GLAMO_REG_2D_ID2 = REG_2D(0x46),
|
|
|
++ GLAMO_REG_2D_ID3 = REG_2D(0x48),
|
|
|
++};
|
|
|
++
|
|
|
++
|
|
|
++/* No offset this time */
|
|
|
++#define REG_3D(x) (x)
|
|
|
++
|
|
|
++enum glamo_register_3d
|
|
|
++{
|
|
|
++ /* Fire the engine */
|
|
|
++ G3D_FIRE = REG_3D(0x2058),
|
|
|
++
|
|
|
++ /* Streams of vertex/colour/normal/texcoord data */
|
|
|
++ G3D_ACTIVE_STREAMS = REG_3D(0x1f00),
|
|
|
++ G3D_LAST_STREAM__VCOLFMT = REG_3D(0x2030),
|
|
|
++ G3D_STREAM_MODE_0 = REG_3D(0x1f10),
|
|
|
++ G3D_STREAM_BASE_0 = REG_3D(0x1f14),
|
|
|
++ G3D_STREAM_MODE_1 = REG_3D(0x1f18),
|
|
|
++ G3D_STREAM_BASE_1 = REG_3D(0x1f1c),
|
|
|
++ G3D_STREAM_MODE_2 = REG_3D(0x1f20),
|
|
|
++ G3D_STREAM_BASE_2 = REG_3D(0x1f24),
|
|
|
++ G3D_STREAM_MODE_3 = REG_3D(0x1f28),
|
|
|
++ G3D_STREAM_BASE_3 = REG_3D(0x1f2c),
|
|
|
++ G3D_STREAM_MODE_4 = REG_3D(0x1f30),
|
|
|
++ G3D_STREAM_BASE_4 = REG_3D(0x1f34),
|
|
|
++ G3D_STREAM_MODE_5 = REG_3D(0x1f38),
|
|
|
++ G3D_STREAM_BASE_5 = REG_3D(0x1f3c),
|
|
|
++ G3D_STREAM_MODE_6 = REG_3D(0x1f40),
|
|
|
++ G3D_STREAM_BASE_6 = REG_3D(0x1f44),
|
|
|
++ G3D_STREAM_MODE_7 = REG_3D(0x1f48),
|
|
|
++ G3D_STREAM_BASE_7 = REG_3D(0x1f4c),
|
|
|
++
|
|
|
++ /* Modelview*projection matrix */
|
|
|
++ G3D_MATRIX_MVP = REG_3D(0x26a0), /* .. 0x27df */
|
|
|
++
|
|
|
++ /* Modelview matrix */
|
|
|
++ G3D_MATRIX_MV = REG_3D(0x26e0), /* .. 0x270f */
|
|
|
++
|
|
|
++ /* Inverse MVP, 3x3 only */
|
|
|
++ G3D_MATRIX_IMVP = REG_3D(0x2710), /* .. 0x2733 */
|
|
|
++
|
|
|
++};
|
|
|
++
|
|
|
++#endif /* _GLAMO_REGS_H */
|
|
|
+diff --git a/src/mesa/drivers/dri/glamo/glamo_render.c b/src/mesa/drivers/dri/glamo/glamo_render.c
|
|
|
+new file mode 100644
|
|
|
+index 0000000..d8b21d5
|
|
|
+--- /dev/null
|
|
|
++++ b/src/mesa/drivers/dri/glamo/glamo_render.c
|
|
|
+@@ -0,0 +1,230 @@
|
|
|
++/*
|
|
|
++ * Direct Rendering Support for SMedia Glamo 336x/337x
|
|
|
++ *
|
|
|
++ * (c) 2009 Thomas White <taw@bitwiz.org.uk>
|
|
|
++ *
|
|
|
++ * Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
++ * copy of this software and associated documentation files (the "Software"),
|
|
|
++ * to deal in the Software without restriction, including without limitation
|
|
|
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
++ * and/or sell copies of the Software, and to permit persons to whom the
|
|
|
++ * Software is furnished to do so, subject to the following conditions:
|
|
|
++ *
|
|
|
++ * The above copyright notice and this permission notice shall be included
|
|
|
++ * in all copies or substantial portions of the Software.
|
|
|
++ *
|
|
|
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
|
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
++ * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
|
|
++ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
|
++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
++ *
|
|
|
++ *
|
|
|
++ * Based on intel_render.c, to which the following notice applies:
|
|
|
++ *
|
|
|
++ * Copyright 2003 Tungsten Graphics, Inc., Cedar Park, Texas.
|
|
|
++ * All Rights Reserved.
|
|
|
++ *
|
|
|
++ * Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
++ * copy of this software and associated documentation files (the
|
|
|
++ * "Software"), to deal in the Software without restriction, including
|
|
|
++ * without limitation the rights to use, copy, modify, merge, publish,
|
|
|
++ * distribute, sub license, and/or sell copies of the Software, and to
|
|
|
++ * permit persons to whom the Software is furnished to do so, subject to
|
|
|
++ * the following conditions:
|
|
|
++ *
|
|
|
++ * The above copyright notice and this permission notice (including the
|
|
|
++ * next paragraph) shall be included in all copies or substantial portions
|
|
|
++ * of the Software.
|
|
|
++ *
|
|
|
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
|
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
|
++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
|
|
|
++ * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
|
|
|
++ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
|
|
++ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
|
|
++ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
++ *
|
|
|
++ */
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ * Render unclipped vertex buffers by emitting vertices directly to
|
|
|
++ * dma buffers. Use strip/fan hardware acceleration where possible.
|
|
|
++ *
|
|
|
++ */
|
|
|
++#include "main/glheader.h"
|
|
|
++#include "main/context.h"
|
|
|
++#include "main/macros.h"
|
|
|
++#include "main/imports.h"
|
|
|
++#include "main/mtypes.h"
|
|
|
++#include "main/enums.h"
|
|
|
++
|
|
|
++#include "tnl/t_context.h"
|
|
|
++#include "tnl/t_vertex.h"
|
|
|
++#include "tnl/t_pipeline.h"
|
|
|
++#include "math/m_xform.h"
|
|
|
++
|
|
|
++#include "glamo_context.h"
|
|
|
++#include "glamo_tris.h"
|
|
|
++#include "glamo_regs.h"
|
|
|
++
|
|
|
++/*
|
|
|
++ * Render unclipped vertex buffers by emitting vertices directly to
|
|
|
++ * VRAM buffers. Use strip/fan hardware primitives where possible.
|
|
|
++ * Try to simulate missing primitives with indexed vertices.
|
|
|
++ */
|
|
|
++#define HAVE_POINTS 1
|
|
|
++#define HAVE_LINES 1
|
|
|
++#define HAVE_LINE_STRIPS 0
|
|
|
++#define HAVE_TRIANGLES 1
|
|
|
++#define HAVE_TRI_STRIPS 0
|
|
|
++#define HAVE_TRI_STRIP_1 0
|
|
|
++#define HAVE_TRI_FANS 0
|
|
|
++#define HAVE_POLYGONS 0
|
|
|
++#define HAVE_QUADS 0
|
|
|
++#define HAVE_QUAD_STRIPS 0
|
|
|
++#define HAVE_ELTS 0
|
|
|
++
|
|
|
++
|
|
|
++static void glamoFlushPrim(struct glamo_context *gCtx)
|
|
|
++{
|
|
|
++ printf("glamoFlushPrim: %i vertices, %i %i\n", gCtx->prim.count,
|
|
|
++ gCtx->prim.start_offset, gCtx->prim.current_offset);
|
|
|
++
|
|
|
++ if ( gCtx->prim.vb_bo == NULL ) return;
|
|
|
++
|
|
|
++ /* Upload to hardware */
|
|
|
++ glamo_bo_subdata(gCtx->prim.vb_bo, 0, gCtx->prim.current_offset,
|
|
|
++ gCtx->prim.vb);
|
|
|
++
|
|
|
++ /* Dispatch to the hardware */
|
|
|
++ glamoDRMStartBurst(gCtx, G3D_STREAM_MODE_0);
|
|
|
++ glamoDRMAddData(gCtx, 0x000f0300, 4);
|
|
|
++ glamoDRMAddBO(gCtx, gCtx->prim.vb_bo);
|
|
|
++ glamoDRMDispatch(gCtx);
|
|
|
++
|
|
|
++ /* Please use a new BO for the next buffer */
|
|
|
++ gCtx->prim.vb_bo = NULL;
|
|
|
++
|
|
|
++ /* Continue from new start */
|
|
|
++ gCtx->prim.start_offset = gCtx->prim.current_offset;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static inline GLuint glamoGetVBMax(struct glamo_context *gCtx)
|
|
|
++{
|
|
|
++ return GLAMO_VB_SIZE / gCtx->vertex_size;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static inline GLuint glamoGetCurrentMax(struct glamo_context *gCtx)
|
|
|
++{
|
|
|
++ /* How many more vertices can be accommodated?
|
|
|
++ * Each vertex takes up 4x 32-bit fixed point values */
|
|
|
++ return (GLAMO_VB_SIZE - gCtx->prim.current_offset) / gCtx->vertex_size;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++#define LOCAL_VARS \
|
|
|
++ struct glamo_context *gCtx = GLAMO_CONTEXT(ctx);
|
|
|
++
|
|
|
++#define INIT(prim)
|
|
|
++
|
|
|
++#define FLUSH() glamoFlushPrim(gCtx)
|
|
|
++
|
|
|
++#define GET_SUBSEQUENT_VB_MAX_VERTS() glamoGetVBMax(gCtx)
|
|
|
++#define GET_CURRENT_VB_MAX_VERTS() glamoGetCurrentMax(gCtx)
|
|
|
++
|
|
|
++#define ALLOC_VERTS(nr) glamoGetPrimSpace(gCtx, nr)
|
|
|
++
|
|
|
++#define EMIT_VERTS(ctx, j, nr, buf) \
|
|
|
++ _tnl_emit_vertices_to_buffer(ctx, j, (j)+(nr), buf)
|
|
|
++
|
|
|
++#define TAG(x) glamo_##x
|
|
|
++#include "tnl_dd/t_dd_dmatmp.h"
|
|
|
++
|
|
|
++
|
|
|
++/**********************************************************************/
|
|
|
++/* Render pipeline stage */
|
|
|
++/**********************************************************************/
|
|
|
++
|
|
|
++static void glamoFireEngine(struct glamo_context *gCtx)
|
|
|
++{
|
|
|
++ glamoDRMStartBurst(gCtx, G3D_FIRE);
|
|
|
++ glamoDRMAddData(gCtx, 0, 2); /* Fire! */
|
|
|
++ glamoDRMDispatch(gCtx);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static GLboolean glamoRunRender(struct gl_context *ctx,
|
|
|
++ struct tnl_pipeline_stage *stage)
|
|
|
++{
|
|
|
++ TNLcontext *tnl = TNL_CONTEXT(ctx);
|
|
|
++ struct glamo_context *gCtx = GLAMO_CONTEXT(ctx);
|
|
|
++ struct vertex_buffer *VB = &tnl->vb;
|
|
|
++ GLuint i;
|
|
|
++
|
|
|
++ printf("glamoRunRender\n");
|
|
|
++
|
|
|
++ /* Don't handle clipping */
|
|
|
++ if ( !glamo_validate_render(ctx, VB) ) {
|
|
|
++ return GL_TRUE; /* Failed */
|
|
|
++ }
|
|
|
++
|
|
|
++ /* Validate GPU state */
|
|
|
++ if ( gCtx->new_state ) {
|
|
|
++ if ( !glamoValidateState(ctx, gCtx->new_state) ) {
|
|
|
++ printf("Couldn't validate state...\n");
|
|
|
++ }
|
|
|
++ } /* else nothing to update */
|
|
|
++
|
|
|
++ tnl->clipspace.new_inputs |= VERT_BIT_POS;
|
|
|
++
|
|
|
++ tnl->Driver.Render.Start(ctx);
|
|
|
++
|
|
|
++ for ( i=0; i<VB->PrimitiveCount; i++ ) {
|
|
|
++
|
|
|
++ GLuint prim = _tnl_translate_prim(&VB->Primitive[i]);
|
|
|
++ GLuint start = VB->Primitive[i].start;
|
|
|
++ GLuint length = VB->Primitive[i].count;
|
|
|
++
|
|
|
++ if (!length) continue;
|
|
|
++
|
|
|
++ glamo_render_tab_verts[prim & PRIM_MODE_MASK](ctx, start,
|
|
|
++ start + length, prim);
|
|
|
++
|
|
|
++ }
|
|
|
++
|
|
|
++ tnl->Driver.Render.Finish(ctx);
|
|
|
++
|
|
|
++ glamoFireEngine(gCtx);
|
|
|
++
|
|
|
++ return GL_FALSE; /* Ok */
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static const struct tnl_pipeline_stage _glamo_render_stage = {
|
|
|
++ "glamo render",
|
|
|
++ NULL,
|
|
|
++ NULL,
|
|
|
++ NULL,
|
|
|
++ NULL,
|
|
|
++ glamoRunRender
|
|
|
++};
|
|
|
++
|
|
|
++
|
|
|
++const struct tnl_pipeline_stage *glamo_pipeline[] = {
|
|
|
++ &_tnl_vertex_transform_stage,
|
|
|
++ &_tnl_normal_transform_stage,
|
|
|
++ &_tnl_lighting_stage,
|
|
|
++ &_tnl_fog_coordinate_stage,
|
|
|
++ &_tnl_texgen_stage,
|
|
|
++ &_tnl_texture_transform_stage,
|
|
|
++ &_tnl_point_attenuation_stage,
|
|
|
++ &_tnl_vertex_program_stage,
|
|
|
++ &_glamo_render_stage, /* ADD: unclipped rastersetup-to-dma */
|
|
|
++ &_tnl_render_stage,
|
|
|
++ 0,
|
|
|
++};
|
|
|
+diff --git a/src/mesa/drivers/dri/glamo/glamo_render.h b/src/mesa/drivers/dri/glamo/glamo_render.h
|
|
|
+new file mode 100644
|
|
|
+index 0000000..99c36a8
|
|
|
+--- /dev/null
|
|
|
++++ b/src/mesa/drivers/dri/glamo/glamo_render.h
|
|
|
+@@ -0,0 +1,31 @@
|
|
|
++/*
|
|
|
++ * Direct Rendering Support for SMedia Glamo 336x/337x
|
|
|
++ *
|
|
|
++ * (c) 2009 Thomas White <taw@bitwiz.org.uk>
|
|
|
++ *
|
|
|
++ * Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
++ * copy of this software and associated documentation files (the "Software"),
|
|
|
++ * to deal in the Software without restriction, including without limitation
|
|
|
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
++ * and/or sell copies of the Software, and to permit persons to whom the
|
|
|
++ * Software is furnished to do so, subject to the following conditions:
|
|
|
++ *
|
|
|
++ * The above copyright notice and this permission notice shall be included
|
|
|
++ * in all copies or substantial portions of the Software.
|
|
|
++ *
|
|
|
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
|
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
++ * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
|
|
++ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
|
++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
++ */
|
|
|
++
|
|
|
++#ifndef __GLAMO_RENDER_H
|
|
|
++#define __GLAMO_RENDER_H
|
|
|
++
|
|
|
++#include "main/mtypes.h"
|
|
|
++
|
|
|
++extern const struct tnl_pipeline_stage *glamo_pipeline[];
|
|
|
++
|
|
|
++#endif /* __GLAMO_RENDER_H */
|
|
|
+diff --git a/src/mesa/drivers/dri/glamo/glamo_screen.c b/src/mesa/drivers/dri/glamo/glamo_screen.c
|
|
|
+new file mode 100644
|
|
|
+index 0000000..cc8a730
|
|
|
+--- /dev/null
|
|
|
++++ b/src/mesa/drivers/dri/glamo/glamo_screen.c
|
|
|
+@@ -0,0 +1,250 @@
|
|
|
++/*
|
|
|
++ * Direct Rendering Support for SMedia Glamo 336x/337x
|
|
|
++ *
|
|
|
++ * (c) 2009 Thomas White <taw@bitwiz.org.uk>
|
|
|
++ * Roughly based on sis_screen.c (c) 2003 Eric Anholt
|
|
|
++ *
|
|
|
++ * Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
++ * copy of this software and associated documentation files (the "Software"),
|
|
|
++ * to deal in the Software without restriction, including without limitation
|
|
|
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
++ * and/or sell copies of the Software, and to permit persons to whom the
|
|
|
++ * Software is furnished to do so, subject to the following conditions:
|
|
|
++ *
|
|
|
++ * The above copyright notice and this permission notice shall be included
|
|
|
++ * in all copies or substantial portions of the Software.
|
|
|
++ *
|
|
|
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
|
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
++ * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
|
|
++ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
|
++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
++ */
|
|
|
++
|
|
|
++
|
|
|
++#include "dri_util.h"
|
|
|
++#include "utils.h"
|
|
|
++#include "xmlconfig.h"
|
|
|
++#include "GL/internal/dri_interface.h"
|
|
|
++#include "main/framebuffer.h"
|
|
|
++#include "main/renderbuffer.h"
|
|
|
++
|
|
|
++#include "glamo_screen.h"
|
|
|
++#include "glamo_context.h"
|
|
|
++#include "glamo_fbo.h"
|
|
|
++
|
|
|
++/* This comes from libdrm_glamo */
|
|
|
++#include <glamo_bo_gem.h>
|
|
|
++
|
|
|
++
|
|
|
++static int glamoInitDriver(__DRIscreen *psp)
|
|
|
++{
|
|
|
++ return 0;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static glamoScreenPtr glamoCreateScreen(__DRIscreen *sPriv)
|
|
|
++{
|
|
|
++ glamoScreenPtr glamoScreen;
|
|
|
++
|
|
|
++ /* Allocate the private area */
|
|
|
++ glamoScreen = (glamoScreenPtr)CALLOC(sizeof(*glamoScreen));
|
|
|
++ if ( glamoScreen == NULL )
|
|
|
++ return NULL;
|
|
|
++
|
|
|
++ glamoScreen->driScreen = sPriv;
|
|
|
++
|
|
|
++ /* This is our link to the kernel's memory manager, via libdrm */
|
|
|
++ glamoScreen->bom = glamo_bo_manager_gem_ctor(sPriv->fd);
|
|
|
++
|
|
|
++ return glamoScreen;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void glamoDestroyScreen(__DRIscreen *sPriv)
|
|
|
++{
|
|
|
++ glamoScreenPtr glamoScreen = (glamoScreenPtr)sPriv->private;
|
|
|
++
|
|
|
++ if ( glamoScreen == NULL )
|
|
|
++ return;
|
|
|
++
|
|
|
++ FREE(glamoScreen);
|
|
|
++ sPriv->private = NULL;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static const __DRIconfig **glamoInitScreen(__DRIscreen *sPriv)
|
|
|
++{
|
|
|
++ __DRIconfig **configs;
|
|
|
++ uint8_t depth_bits_array[2];
|
|
|
++ uint8_t stencil_bits_array[2];
|
|
|
++ uint8_t msaa_samples_array[1];
|
|
|
++ static const GLenum db_modes[] = { GLX_SWAP_COPY_OML, GLX_NONE };
|
|
|
++
|
|
|
++ /* Driver initialisation */
|
|
|
++ if ( glamoInitDriver(sPriv) ) {
|
|
|
++ return NULL;
|
|
|
++ }
|
|
|
++
|
|
|
++ /* Screen-specific initialisation */
|
|
|
++ sPriv->private = glamoCreateScreen(sPriv);
|
|
|
++ if ( !sPriv->private ) {
|
|
|
++ glamoDestroyScreen(sPriv);
|
|
|
++ return NULL;
|
|
|
++ }
|
|
|
++
|
|
|
++ depth_bits_array[0] = 0;
|
|
|
++ stencil_bits_array[0] = 0;
|
|
|
++ depth_bits_array[1] = 16;
|
|
|
++ stencil_bits_array[1] = 0;
|
|
|
++ msaa_samples_array[0] = 0;
|
|
|
++
|
|
|
++ configs = driCreateConfigs(GL_RGB, GL_UNSIGNED_SHORT_5_6_5,
|
|
|
++ depth_bits_array, stencil_bits_array, 2,
|
|
|
++ db_modes, 2, msaa_samples_array, 1, GL_TRUE);
|
|
|
++
|
|
|
++ if ( configs == NULL ) {
|
|
|
++ fprintf(stderr, "[%s:%u] Error creating FBConfig!\n", __func__, __LINE__);
|
|
|
++ return NULL;
|
|
|
++ }
|
|
|
++
|
|
|
++ return (const __DRIconfig **)configs;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static const __DRIconfig **glamoInitScreen2(__DRIscreen *sPriv)
|
|
|
++{
|
|
|
++ __DRIconfig **configs;
|
|
|
++ uint8_t depth_bits_array[2];
|
|
|
++ uint8_t stencil_bits_array[2];
|
|
|
++ uint8_t msaa_samples_array[1];
|
|
|
++ static const GLenum db_modes[] = { GLX_SWAP_COPY_OML, GLX_NONE };
|
|
|
++
|
|
|
++ /* Driver initialisation */
|
|
|
++ if ( glamoInitDriver(sPriv) ) {
|
|
|
++ return NULL;
|
|
|
++ }
|
|
|
++
|
|
|
++ /* Screen-specific initialisation */
|
|
|
++ sPriv->private = glamoCreateScreen(sPriv);
|
|
|
++ if ( !sPriv->private ) {
|
|
|
++ glamoDestroyScreen(sPriv);
|
|
|
++ return NULL;
|
|
|
++ }
|
|
|
++
|
|
|
++ depth_bits_array[0] = 0;
|
|
|
++ stencil_bits_array[0] = 0;
|
|
|
++ depth_bits_array[1] = 16;
|
|
|
++ stencil_bits_array[1] = 0;
|
|
|
++ msaa_samples_array[0] = 0;
|
|
|
++
|
|
|
++ configs = driCreateConfigs(GL_RGB, GL_UNSIGNED_SHORT_5_6_5,
|
|
|
++ depth_bits_array, stencil_bits_array, 2,
|
|
|
++ db_modes, 2, msaa_samples_array, 1, GL_TRUE);
|
|
|
++
|
|
|
++ if ( configs == NULL ) {
|
|
|
++ fprintf(stderr, "[%s:%u] Error creating FBConfig!\n", __func__, __LINE__);
|
|
|
++ return NULL;
|
|
|
++ }
|
|
|
++
|
|
|
++ return (const __DRIconfig **)configs;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/* Allocate buffers for a context. This is where the fun starts... */
|
|
|
++static GLboolean glamoCreateBuffer(__DRIscreen *driScrnPriv,
|
|
|
++ __DRIdrawable *driDrawPriv,
|
|
|
++ const struct gl_config *mesaVis,
|
|
|
++ GLboolean isPixmap)
|
|
|
++{
|
|
|
++ struct glamo_framebuffer *gfb;
|
|
|
++ GLenum rgbFormat;
|
|
|
++
|
|
|
++ if ( isPixmap ) return GL_FALSE; /* not implemented */
|
|
|
++
|
|
|
++ gfb = CALLOC_STRUCT(glamo_framebuffer);
|
|
|
++ if ( !gfb ) return GL_FALSE;
|
|
|
++
|
|
|
++ _mesa_initialize_window_framebuffer(&gfb->base, mesaVis);
|
|
|
++
|
|
|
++ /* we only support this one format at the moment */
|
|
|
++ rgbFormat = GL_RGB5;
|
|
|
++
|
|
|
++ /* Front color renderbuffer */
|
|
|
++ gfb->color_rb[0] = glamo_create_renderbuffer(rgbFormat, driDrawPriv);
|
|
|
++ _mesa_add_renderbuffer(&gfb->base, BUFFER_FRONT_LEFT,
|
|
|
++ &gfb->color_rb[0]->base);
|
|
|
++
|
|
|
++ /* Back color renderbuffer, if requested */
|
|
|
++ if ( mesaVis->doubleBufferMode ) {
|
|
|
++ gfb->color_rb[1] = glamo_create_renderbuffer(rgbFormat, driDrawPriv);
|
|
|
++ _mesa_add_renderbuffer(&gfb->base, BUFFER_BACK_LEFT,
|
|
|
++ &gfb->color_rb[1]->base);
|
|
|
++ }
|
|
|
++
|
|
|
++ if ( mesaVis->depthBits == 16 ) {
|
|
|
++ struct glamo_renderbuffer *depth;
|
|
|
++ depth = glamo_create_renderbuffer(GL_DEPTH_COMPONENT16, driDrawPriv);
|
|
|
++ _mesa_add_renderbuffer(&gfb->base, BUFFER_DEPTH, &depth->base);
|
|
|
++ }
|
|
|
++
|
|
|
++ /* Add software renderbuffers for the things we can't support in hardware */
|
|
|
++ _mesa_add_soft_renderbuffers(&gfb->base,
|
|
|
++ GL_FALSE, /* color */
|
|
|
++ GL_FALSE, /* depth */
|
|
|
++ mesaVis->stencilBits > 0, /* stencil, if required */
|
|
|
++ mesaVis->accumRedBits > 0, /* accum, if required */
|
|
|
++ GL_FALSE, /* alpha */
|
|
|
++ GL_FALSE /* aux */
|
|
|
++ );
|
|
|
++ driDrawPriv->driverPrivate = (void *)gfb;
|
|
|
++
|
|
|
++ return (driDrawPriv->driverPrivate != NULL);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void glamoDestroyBuffer(__DRIdrawable *driDrawPriv)
|
|
|
++{
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void glamoSwapBuffers(__DRIdrawable *driDrawPriv)
|
|
|
++{
|
|
|
++ printf("glamoSwapBuffers\n"); fflush(stdout);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++/*
|
|
|
++ * Mesa entry points
|
|
|
++ *
|
|
|
++ * See src/mesa/drivers/dri/common/dri_util.h for information about these
|
|
|
++ */
|
|
|
++const struct __DriverAPIRec driDriverAPI = {
|
|
|
++ .InitScreen = glamoInitScreen,
|
|
|
++ .DestroyScreen = glamoDestroyScreen,
|
|
|
++ .CreateContext = glamoCreateContext,
|
|
|
++ .DestroyContext = glamoDestroyContext,
|
|
|
++ .CreateBuffer = glamoCreateBuffer,
|
|
|
++ .DestroyBuffer = glamoDestroyBuffer,
|
|
|
++ .SwapBuffers = glamoSwapBuffers,
|
|
|
++ .MakeCurrent = glamoMakeCurrent,
|
|
|
++ .UnbindContext = glamoUnbindContext,
|
|
|
++ .GetSwapInfo = NULL, /* Not used */
|
|
|
++ .WaitForMSC = NULL,
|
|
|
++ .WaitForSBC = NULL,
|
|
|
++ .SwapBuffersMSC = NULL,
|
|
|
++ .CopySubBuffer = NULL,
|
|
|
++ .GetDrawableMSC = NULL, /* Not used */
|
|
|
++ .InitScreen2 = glamoInitScreen2, /* For DRI2 */
|
|
|
++};
|
|
|
++
|
|
|
++/* This is the table of extensions that the loader will dlsym() for. */
|
|
|
++PUBLIC const __DRIextension *__driDriverExtensions[] = {
|
|
|
++ &driCoreExtension.base,
|
|
|
++ &driLegacyExtension.base,
|
|
|
++ &driDRI2Extension.base,
|
|
|
++ NULL
|
|
|
++};
|
|
|
++
|
|
|
++/* kate: space-indent on; indent-width 3; mixedindent off; indent-mode cstyle; */
|
|
|
+diff --git a/src/mesa/drivers/dri/glamo/glamo_screen.h b/src/mesa/drivers/dri/glamo/glamo_screen.h
|
|
|
+new file mode 100644
|
|
|
+index 0000000..3f2eb5f
|
|
|
+--- /dev/null
|
|
|
++++ b/src/mesa/drivers/dri/glamo/glamo_screen.h
|
|
|
+@@ -0,0 +1,44 @@
|
|
|
++/*
|
|
|
++ * Direct Rendering Support for SMedia Glamo 336x/337x
|
|
|
++ *
|
|
|
++ * (c) 2009 Thomas White <taw@bitwiz.org.uk>
|
|
|
++ * Roughly based on sis_screen.h (c) 2003 Eric Anholt
|
|
|
++ *
|
|
|
++ * Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
++ * copy of this software and associated documentation files (the "Software"),
|
|
|
++ * to deal in the Software without restriction, including without limitation
|
|
|
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
++ * and/or sell copies of the Software, and to permit persons to whom the
|
|
|
++ * Software is furnished to do so, subject to the following conditions:
|
|
|
++ *
|
|
|
++ * The above copyright notice and this permission notice shall be included
|
|
|
++ * in all copies or substantial portions of the Software.
|
|
|
++ *
|
|
|
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
|
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
++ * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
|
|
++ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
|
++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
++ */
|
|
|
++
|
|
|
++#ifndef __GLAMO_SCREEN_H
|
|
|
++#define __GLAMO_SCREEN_H
|
|
|
++
|
|
|
++#include "xmlconfig.h"
|
|
|
++#include "dri_util.h"
|
|
|
++
|
|
|
++#include <glamo_bo_gem.h>
|
|
|
++
|
|
|
++typedef struct {
|
|
|
++
|
|
|
++ __DRIscreen *driScreen;
|
|
|
++ driOptionCache optionCache;
|
|
|
++
|
|
|
++ struct glamo_bo_manager *bom;
|
|
|
++
|
|
|
++} glamoScreenRec, *glamoScreenPtr;
|
|
|
++
|
|
|
++#endif /* __GLAMO_SCREEN_H */
|
|
|
++
|
|
|
++/* kate: space-indent on; indent-width 3; mixedindent off; indent-mode cstyle; */
|
|
|
+diff --git a/src/mesa/drivers/dri/glamo/glamo_state.c b/src/mesa/drivers/dri/glamo/glamo_state.c
|
|
|
+new file mode 100644
|
|
|
+index 0000000..3aa2f8b
|
|
|
+--- /dev/null
|
|
|
++++ b/src/mesa/drivers/dri/glamo/glamo_state.c
|
|
|
+@@ -0,0 +1,305 @@
|
|
|
++/*
|
|
|
++ * Direct Rendering Support for SMedia Glamo 336x/337x
|
|
|
++ *
|
|
|
++ * (c) 2009-2010 Thomas White <taw@bitwiz.org.uk>
|
|
|
++ * Roughly based on sis_state.c (c) 2003 Eric Anholt
|
|
|
++ *
|
|
|
++ * Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
++ * copy of this software and associated documentation files (the "Software"),
|
|
|
++ * to deal in the Software without restriction, including without limitation
|
|
|
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
++ * and/or sell copies of the Software, and to permit persons to whom the
|
|
|
++ * Software is furnished to do so, subject to the following conditions:
|
|
|
++ *
|
|
|
++ * The above copyright notice and this permission notice shall be included
|
|
|
++ * in all copies or substantial portions of the Software.
|
|
|
++ *
|
|
|
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
|
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
++ * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
|
|
++ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
|
++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
++ *
|
|
|
++ *
|
|
|
++ * Also partially based on intel_fbo.c, to which the following notice applies:
|
|
|
++ *
|
|
|
++ * Copyright 2006 Tungsten Graphics, Inc., Cedar Park, Texas.
|
|
|
++ * All Rights Reserved.
|
|
|
++ *
|
|
|
++ * Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
++ * copy of this software and associated documentation files (the
|
|
|
++ * "Software"), to deal in the Software without restriction, including
|
|
|
++ * without limitation the rights to use, copy, modify, merge, publish,
|
|
|
++ * distribute, sub license, and/or sell copies of the Software, and to
|
|
|
++ * permit persons to whom the Software is furnished to do so, subject to
|
|
|
++ * the following conditions:
|
|
|
++ *
|
|
|
++ * The above copyright notice and this permission notice (including the
|
|
|
++ * next paragraph) shall be included in all copies or substantial portions
|
|
|
++ * of the Software.
|
|
|
++ *
|
|
|
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
|
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
|
++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
|
|
|
++ * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
|
|
|
++ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
|
|
++ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
|
|
++ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
++ */
|
|
|
++
|
|
|
++
|
|
|
++#include "main/context.h"
|
|
|
++#include "main/framebuffer.h"
|
|
|
++#include "main/api_arrayelt.h"
|
|
|
++#include "main/macros.h"
|
|
|
++#include "swrast/swrast.h"
|
|
|
++#include "swrast_setup/swrast_setup.h"
|
|
|
++#include "tnl/tnl.h"
|
|
|
++
|
|
|
++#include "glamo_fbo.h"
|
|
|
++#include "glamo_state.h"
|
|
|
++#include "glamo_context.h"
|
|
|
++#include "glamo_cmdq.h"
|
|
|
++#include "glamo_regs.h"
|
|
|
++
|
|
|
++
|
|
|
++static void glamoResizeBuffers(struct gl_context *ctx, struct gl_framebuffer *fb,
|
|
|
++ GLuint width, GLuint height)
|
|
|
++{
|
|
|
++ struct glamo_framebuffer *glamo_fb = (struct glamo_framebuffer *)fb;
|
|
|
++ int i;
|
|
|
++
|
|
|
++ _mesa_resize_framebuffer(ctx, fb, width, height);
|
|
|
++
|
|
|
++ fb->Initialized = GL_TRUE; /* XXX remove someday */
|
|
|
++
|
|
|
++ if (fb->Name != 0) {
|
|
|
++ return;
|
|
|
++ }
|
|
|
++
|
|
|
++ /* Make sure all window system renderbuffers are up to date */
|
|
|
++ for (i = 0; i < 2; i++) {
|
|
|
++ struct gl_renderbuffer *rb = &glamo_fb->color_rb[i]->base;
|
|
|
++
|
|
|
++ /* only resize if size is changing */
|
|
|
++ if (rb && (rb->Width != width || rb->Height != height)) {
|
|
|
++ rb->AllocStorage(ctx, rb, rb->InternalFormat,
|
|
|
++ width, height);
|
|
|
++ }
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void glamoClear(struct gl_context *ctx, GLbitfield mask)
|
|
|
++{
|
|
|
++ glamoContext *gCtx;
|
|
|
++ struct gl_framebuffer *fb;
|
|
|
++ int i;
|
|
|
++
|
|
|
++ gCtx = GLAMO_CONTEXT(ctx);
|
|
|
++ fb = ctx->DrawBuffer;
|
|
|
++
|
|
|
++ printf("glamoClear (%f %f %f %f)\n", ctx->Color.ClearColor[0],
|
|
|
++ ctx->Color.ClearColor[1], ctx->Color.ClearColor[2],
|
|
|
++ ctx->Color.ClearColor[3]); fflush(stdout);
|
|
|
++
|
|
|
++ for (i = 0; i < fb->_NumColorDrawBuffers; i++) {
|
|
|
++
|
|
|
++ struct glamo_renderbuffer *grb;
|
|
|
++
|
|
|
++ grb = glamo_renderbuffer(fb->_ColorDrawBuffers[i]);
|
|
|
++
|
|
|
++ glamoDRMStartBurst(gCtx, GLAMO_REG_2D_DST_X);
|
|
|
++ glamoDRMAddData(gCtx, fb->_Xmin, 2); /* dest X */
|
|
|
++ glamoDRMAddData(gCtx, fb->_Ymin, 2); /* dest Y */
|
|
|
++ glamoDRMAddBO(gCtx, grb->bo); /* dest L/H */
|
|
|
++ glamoDRMAddData(gCtx, grb->pitch & 0x7ff, 2); /* dest pitch */
|
|
|
++ glamoDRMAddData(gCtx, grb->height, 2); /* dest height */
|
|
|
++ glamoDRMAddData(gCtx, fb->_Xmax-fb->_Xmin, 2); /* width */
|
|
|
++ glamoDRMAddData(gCtx, fb->_Ymax-fb->_Ymin, 2); /* height */
|
|
|
++ glamoDRMAddData(gCtx, 0x0000, 2); /* patt L */
|
|
|
++ glamoDRMAddData(gCtx, 0x0000, 2); /* patt H */
|
|
|
++ glamoDRMAddData(gCtx, gCtx->col_clear, 2); /* FG colour */
|
|
|
++ glamoDRMDispatch(gCtx);
|
|
|
++
|
|
|
++ glamoDRMStartBurst(gCtx, GLAMO_REG_2D_COMMAND1);
|
|
|
++ glamoDRMAddData(gCtx, 0x0000, 2); /* Cmd param 1 */
|
|
|
++ glamoDRMAddData(gCtx, 0xf0 << 8, 2); /* Cmd param 2 */
|
|
|
++ glamoDRMAddData(gCtx, 0x0000, 2); /* Cmd param 3 */
|
|
|
++ glamoDRMDispatch(gCtx);
|
|
|
++
|
|
|
++ }
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void glamoClearColor(struct gl_context *ctx, const GLfloat color[4])
|
|
|
++{
|
|
|
++ struct glamo_context *gCtx = GLAMO_CONTEXT(ctx);
|
|
|
++ GLubyte col_byte[4];
|
|
|
++
|
|
|
++ printf("glamoClearColor (%f %f %f %f)\n", color[0], color[1], color[2],
|
|
|
++ color[3]); fflush(stdout);
|
|
|
++
|
|
|
++ CLAMPED_FLOAT_TO_UBYTE(col_byte[0], color[0]);
|
|
|
++ CLAMPED_FLOAT_TO_UBYTE(col_byte[1], color[1]);
|
|
|
++ CLAMPED_FLOAT_TO_UBYTE(col_byte[2], color[2]);
|
|
|
++ CLAMPED_FLOAT_TO_UBYTE(col_byte[3], color[3]);
|
|
|
++
|
|
|
++ gCtx->col_clear = GLAMO_PACKCOLOR565(col_byte[0], col_byte[1],
|
|
|
++ col_byte[2]);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void glamoShadeModel(struct gl_context *ctx, GLenum mode)
|
|
|
++{
|
|
|
++ printf("glamoShadeModel\n"); fflush(stdout);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void glamoViewport(struct gl_context *ctx, GLint x, GLint y,
|
|
|
++ GLsizei width, GLsizei height )
|
|
|
++{
|
|
|
++ struct glamo_context *gCtx = GLAMO_CONTEXT(ctx);
|
|
|
++ __DRIcontext *driContext = gCtx->driContext;
|
|
|
++ void (*old_viewport)(struct gl_context *ctx, GLint x, GLint y,
|
|
|
++ GLsizei w, GLsizei h);
|
|
|
++
|
|
|
++ if ( !driContext->driScreenPriv->dri2.enabled ) return;
|
|
|
++
|
|
|
++ /* TODO: Flush before fiddling with fake front buffer */
|
|
|
++
|
|
|
++ if ( ctx->DrawBuffer->Name == 0 ) {
|
|
|
++
|
|
|
++ glamo_update_renderbuffers(driContext,
|
|
|
++ driContext->driDrawablePriv);
|
|
|
++ if ( driContext->driDrawablePriv
|
|
|
++ != driContext->driReadablePriv ) {
|
|
|
++ glamo_update_renderbuffers(driContext,
|
|
|
++ driContext->driReadablePriv);
|
|
|
++ }
|
|
|
++
|
|
|
++ }
|
|
|
++
|
|
|
++ old_viewport = ctx->Driver.Viewport;
|
|
|
++ ctx->Driver.Viewport = NULL;
|
|
|
++ gCtx->driDrawable = driContext->driDrawablePriv;
|
|
|
++ ctx->Driver.Viewport = old_viewport;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void glamoUploadMatrix(struct glamo_context *gCtx, uint16_t mreg,
|
|
|
++ GLfloat *matrix)
|
|
|
++{
|
|
|
++ int i;
|
|
|
++ char *type;
|
|
|
++
|
|
|
++ switch ( mreg ) {
|
|
|
++ case G3D_MATRIX_MVP :
|
|
|
++ type = "MVP"; break;
|
|
|
++ case G3D_MATRIX_MV :
|
|
|
++ type = "MV"; break;
|
|
|
++ case G3D_MATRIX_IMVP :
|
|
|
++ type = "inverse MVP"; break;
|
|
|
++ default :
|
|
|
++ type = "unknown"; break;
|
|
|
++ }
|
|
|
++ printf("Uploading %s matrix...\n", type);
|
|
|
++
|
|
|
++ glamoDRMStartBurst(gCtx, mreg);
|
|
|
++ if ( mreg != G3D_MATRIX_IMVP ) {
|
|
|
++ for ( i=0; i<16; i++ ) {
|
|
|
++ glamoDRMAddData(gCtx, float7s16(matrix[i]), 4);
|
|
|
++ }
|
|
|
++ } else {
|
|
|
++ /* Normal matrix needs special treatment */
|
|
|
++ for ( i=0; i<3; i++ ) {
|
|
|
++ glamoDRMAddData(gCtx, float7s16(matrix[4*i]), 4);
|
|
|
++ glamoDRMAddData(gCtx, float7s16(matrix[4*i+1]), 4);
|
|
|
++ glamoDRMAddData(gCtx, float7s16(matrix[4*i+2]), 4);
|
|
|
++ }
|
|
|
++ }
|
|
|
++ glamoDRMDispatch(gCtx);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++GLboolean glamoValidateState(struct gl_context *ctx, GLuint new_state)
|
|
|
++{
|
|
|
++ struct glamo_context *gCtx = GLAMO_CONTEXT(ctx);
|
|
|
++
|
|
|
++ if ( new_state & (_NEW_MODELVIEW|_NEW_PROJECTION) ) {
|
|
|
++
|
|
|
++ glamoUploadMatrix(gCtx, G3D_MATRIX_MVP,
|
|
|
++ ctx->_ModelProjectMatrix.m);
|
|
|
++
|
|
|
++ /* FIXME: The following two aren't needed unless lighting
|
|
|
++ * is in use... */
|
|
|
++ glamoUploadMatrix(gCtx, G3D_MATRIX_MV,
|
|
|
++ ctx->ModelviewMatrixStack.Top->m);
|
|
|
++ _math_matrix_alloc_inv(&(ctx->_ModelProjectMatrix));
|
|
|
++ _math_matrix_analyse(&(ctx->_ModelProjectMatrix));
|
|
|
++ glamoUploadMatrix(gCtx, G3D_MATRIX_IMVP,
|
|
|
++ ctx->_ModelProjectMatrix.inv);
|
|
|
++ }
|
|
|
++
|
|
|
++ gCtx->new_state = 0;
|
|
|
++ return GL_TRUE;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void glamoUpdateState(struct gl_context *ctx, GLbitfield new_state)
|
|
|
++{
|
|
|
++ struct glamo_context *gCtx = GLAMO_CONTEXT(ctx);
|
|
|
++
|
|
|
++ printf("glamoUpdateState\n");
|
|
|
++
|
|
|
++ _swrast_InvalidateState(ctx, new_state);
|
|
|
++ _swsetup_InvalidateState(ctx, new_state);
|
|
|
++ _vbo_InvalidateState(ctx, new_state);
|
|
|
++ _tnl_InvalidateState(ctx, new_state);
|
|
|
++ _ae_invalidate_state(ctx, new_state);
|
|
|
++
|
|
|
++ /* Make a note that some state has changed,
|
|
|
++ * so that it can be sent to the GPU later. */
|
|
|
++ gCtx->new_state |= new_state;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void glamoFlush(struct gl_context *ctx)
|
|
|
++{
|
|
|
++ printf("glamoFlush\n");
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++void glamoInitStateFuncs(struct gl_context *ctx)
|
|
|
++{
|
|
|
++ ctx->Driver.UpdateState = glamoUpdateState;
|
|
|
++ ctx->Driver.Clear = glamoClear;
|
|
|
++ ctx->Driver.ClearColor = glamoClearColor;
|
|
|
++ ctx->Driver.ClearDepth = NULL;
|
|
|
++ ctx->Driver.ClearStencil = NULL;
|
|
|
++ ctx->Driver.AlphaFunc = NULL;
|
|
|
++ ctx->Driver.BlendFuncSeparate = NULL;
|
|
|
++ ctx->Driver.ColorMask = NULL;
|
|
|
++ ctx->Driver.CullFace = NULL;
|
|
|
++ ctx->Driver.DepthMask = NULL;
|
|
|
++ ctx->Driver.DepthFunc = NULL;
|
|
|
++ ctx->Driver.DepthRange = NULL;
|
|
|
++ ctx->Driver.DrawBuffer = NULL;
|
|
|
++ ctx->Driver.Enable = NULL;
|
|
|
++ ctx->Driver.FrontFace = NULL;
|
|
|
++ ctx->Driver.Fogfv = NULL;
|
|
|
++ ctx->Driver.Hint = NULL;
|
|
|
++ ctx->Driver.Lightfv = NULL;
|
|
|
++ ctx->Driver.LogicOpcode = NULL;
|
|
|
++ ctx->Driver.PolygonMode = NULL;
|
|
|
++ ctx->Driver.PolygonStipple = NULL;
|
|
|
++ ctx->Driver.ReadBuffer = NULL;
|
|
|
++ ctx->Driver.RenderMode = NULL;
|
|
|
++ ctx->Driver.Scissor = NULL;
|
|
|
++ ctx->Driver.ShadeModel = glamoShadeModel;
|
|
|
++ ctx->Driver.LightModelfv = NULL;
|
|
|
++ ctx->Driver.Viewport = glamoViewport;
|
|
|
++ ctx->Driver.ResizeBuffers = glamoResizeBuffers;
|
|
|
++ ctx->Driver.Flush = glamoFlush;
|
|
|
++}
|
|
|
+diff --git a/src/mesa/drivers/dri/glamo/glamo_state.h b/src/mesa/drivers/dri/glamo/glamo_state.h
|
|
|
+new file mode 100644
|
|
|
+index 0000000..c3872c0
|
|
|
+--- /dev/null
|
|
|
++++ b/src/mesa/drivers/dri/glamo/glamo_state.h
|
|
|
+@@ -0,0 +1,34 @@
|
|
|
++/*
|
|
|
++ * Direct Rendering Support for SMedia Glamo 336x/337x
|
|
|
++ *
|
|
|
++ * (c) 2009 Thomas White <taw@bitwiz.org.uk>
|
|
|
++ * Roughly based on sis_state.h (c) 2003 Eric Anholt
|
|
|
++ *
|
|
|
++ * Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
++ * copy of this software and associated documentation files (the "Software"),
|
|
|
++ * to deal in the Software without restriction, including without limitation
|
|
|
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
++ * and/or sell copies of the Software, and to permit persons to whom the
|
|
|
++ * Software is furnished to do so, subject to the following conditions:
|
|
|
++ *
|
|
|
++ * The above copyright notice and this permission notice shall be included
|
|
|
++ * in all copies or substantial portions of the Software.
|
|
|
++ *
|
|
|
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
|
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
++ * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
|
|
++ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
|
++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
++ */
|
|
|
++
|
|
|
++#ifndef __GLAMO_STATE_H
|
|
|
++#define __GLAMO_STATE_H
|
|
|
++
|
|
|
++#include "main/context.h"
|
|
|
++
|
|
|
++extern void glamoInitStateFuncs(struct gl_context *ctx);
|
|
|
++
|
|
|
++#endif /* __GLAMO_STATE_H */
|
|
|
++
|
|
|
++/* kate: space-indent on; indent-width 3; mixedindent off; indent-mode cstyle; */
|
|
|
+diff --git a/src/mesa/drivers/dri/glamo/glamo_tris.c b/src/mesa/drivers/dri/glamo/glamo_tris.c
|
|
|
+new file mode 100644
|
|
|
+index 0000000..c45fe53
|
|
|
+--- /dev/null
|
|
|
++++ b/src/mesa/drivers/dri/glamo/glamo_tris.c
|
|
|
+@@ -0,0 +1,310 @@
|
|
|
++/*
|
|
|
++ * Direct Rendering Support for SMedia Glamo 336x/337x
|
|
|
++ *
|
|
|
++ * (c) 2009 Thomas White <taw@bitwiz.org.uk>
|
|
|
++ *
|
|
|
++ * Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
++ * copy of this software and associated documentation files (the "Software"),
|
|
|
++ * to deal in the Software without restriction, including without limitation
|
|
|
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
++ * and/or sell copies of the Software, and to permit persons to whom the
|
|
|
++ * Software is furnished to do so, subject to the following conditions:
|
|
|
++ *
|
|
|
++ * The above copyright notice and this permission notice shall be included
|
|
|
++ * in all copies or substantial portions of the Software.
|
|
|
++ *
|
|
|
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
|
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
++ * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
|
|
++ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
|
++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
++ *
|
|
|
++ *
|
|
|
++ * Based on intel_tris.c, to which the following notice applies:
|
|
|
++ *
|
|
|
++ * Copyright 2003 Tungsten Graphics, Inc., Cedar Park, Texas.
|
|
|
++ * All Rights Reserved.
|
|
|
++ *
|
|
|
++ * Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
++ * copy of this software and associated documentation files (the
|
|
|
++ * "Software"), to deal in the Software without restriction, including
|
|
|
++ * without limitation the rights to use, copy, modify, merge, publish,
|
|
|
++ * distribute, sub license, and/or sell copies of the Software, and to
|
|
|
++ * permit persons to whom the Software is furnished to do so, subject to
|
|
|
++ * the following conditions:
|
|
|
++ *
|
|
|
++ * The above copyright notice and this permission notice (including the
|
|
|
++ * next paragraph) shall be included in all copies or substantial portions
|
|
|
++ * of the Software.
|
|
|
++ *
|
|
|
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
|
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
|
++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
|
|
|
++ * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
|
|
|
++ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
|
|
++ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
|
|
++ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
++ *
|
|
|
++ */
|
|
|
++
|
|
|
++
|
|
|
++#include <glamo_bo.h>
|
|
|
++#include <glamo_bo_gem.h>
|
|
|
++#include <glamo_drm.h>
|
|
|
++
|
|
|
++#include "main/mtypes.h"
|
|
|
++#include "swrast/swrast.h"
|
|
|
++#include "tnl/t_context.h"
|
|
|
++#include "tnl/t_vertex.h"
|
|
|
++#include "tnl/t_pipeline.h"
|
|
|
++
|
|
|
++#include "glamo_tris.h"
|
|
|
++#include "glamo_context.h"
|
|
|
++
|
|
|
++
|
|
|
++static void glamoRunPipeline(struct gl_context *ctx)
|
|
|
++{
|
|
|
++ printf("glamoRunPipeline\n");
|
|
|
++
|
|
|
++ /* TODO: Emit state */
|
|
|
++
|
|
|
++ _tnl_run_pipeline(ctx);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void glamoRenderStart(struct gl_context *ctx)
|
|
|
++{
|
|
|
++ struct glamo_context *gCtx = GLAMO_CONTEXT(ctx);
|
|
|
++
|
|
|
++ /* Decide which attributes will be used */
|
|
|
++ gCtx->vertex_attrs[0].attrib = _TNL_ATTRIB_POS;
|
|
|
++ gCtx->vertex_attrs[0].format = EMIT_4F;
|
|
|
++
|
|
|
++ gCtx->vertex_size = _tnl_install_attrs(ctx, gCtx->vertex_attrs, 1,
|
|
|
++ NULL, 0);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void glamoRenderFinish(struct gl_context *ctx)
|
|
|
++{
|
|
|
++ printf("glamoRenderFinish\n");
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void glamoPrimitiveNotify(struct gl_context *ctx, GLenum prim)
|
|
|
++{
|
|
|
++ printf("glamoPrimitiveNotify\n");
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++uint32_t *glamoGetPrimSpace(struct glamo_context *gCtx, unsigned int count)
|
|
|
++{
|
|
|
++ uint32_t *addr;
|
|
|
++
|
|
|
++ printf("glamoGetPrimSpace\n");
|
|
|
++
|
|
|
++ /* Check for space in the existing VB */
|
|
|
++ if (gCtx->prim.vb_bo == NULL || (gCtx->prim.current_offset +
|
|
|
++ count * gCtx->vertex_size) > GLAMO_VB_SIZE) {
|
|
|
++
|
|
|
++ /* Not enough space, or no VB existing. Start a new one... */
|
|
|
++ if (gCtx->prim.vb == NULL) {
|
|
|
++ printf("Allocated %i bytes\n", GLAMO_VB_SIZE);
|
|
|
++ gCtx->prim.vb = malloc(GLAMO_VB_SIZE);
|
|
|
++ }
|
|
|
++ gCtx->prim.vb_bo = glamo_bo_open(gCtx->glamoScreen->bom, 0,
|
|
|
++ GLAMO_VB_SIZE, 4,
|
|
|
++ GLAMO_GEM_DOMAIN_VRAM, 0);
|
|
|
++ gCtx->prim.start_offset = 0;
|
|
|
++ gCtx->prim.current_offset = 0;
|
|
|
++ }
|
|
|
++
|
|
|
++ addr = (uint32_t *)(gCtx->prim.vb + gCtx->prim.current_offset);
|
|
|
++ gCtx->prim.current_offset += gCtx->vertex_size * count;
|
|
|
++ gCtx->prim.count += count;
|
|
|
++
|
|
|
++ return addr;
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++#define COPY_DWORDS( j, vb, vertsize, v ) \
|
|
|
++do { \
|
|
|
++ for ( j = 0 ; j < vertsize ; j++ ) { \
|
|
|
++ vb[j] = ((GLuint *)v)[j]; \
|
|
|
++ } \
|
|
|
++ vb += vertsize; \
|
|
|
++} while (0)
|
|
|
++
|
|
|
++
|
|
|
++static void glamo_draw_triangle(struct glamo_context *gCtx,
|
|
|
++ glamoVertexPtr v0, glamoVertexPtr v1,
|
|
|
++ glamoVertexPtr v2)
|
|
|
++{
|
|
|
++ GLuint *vb = glamoGetPrimSpace(gCtx, 3);
|
|
|
++ int j;
|
|
|
++
|
|
|
++ COPY_DWORDS(j, vb, gCtx->vertex_size, v0);
|
|
|
++ COPY_DWORDS(j, vb, gCtx->vertex_size, v1);
|
|
|
++ COPY_DWORDS(j, vb, gCtx->vertex_size, v2);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void glamo_draw_line(struct glamo_context *gCtx,
|
|
|
++ glamoVertexPtr v0, glamoVertexPtr v1)
|
|
|
++{
|
|
|
++ GLuint *vb = glamoGetPrimSpace(gCtx, 2);
|
|
|
++ int j;
|
|
|
++
|
|
|
++ COPY_DWORDS(j, vb, gCtx->vertex_size, v0);
|
|
|
++ COPY_DWORDS(j, vb, gCtx->vertex_size, v1);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++static void glamo_draw_point(struct glamo_context *gCtx, glamoVertexPtr v0)
|
|
|
++{
|
|
|
++ GLuint *vb = glamoGetPrimSpace(gCtx, 2);
|
|
|
++ int j;
|
|
|
++
|
|
|
++ COPY_DWORDS(j, vb, gCtx->vertex_size, v0);
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++#define TRI( a, b, c ) \
|
|
|
++do { \
|
|
|
++ glamo_draw_triangle(gCtx, a, b, c ); \
|
|
|
++} while (0)
|
|
|
++
|
|
|
++
|
|
|
++#define QUAD( a, b, c, d ) \
|
|
|
++printf("Drawing a quad\n"); \
|
|
|
++do { \
|
|
|
++ glamo_draw_triangle(gCtx, a, b, d); \
|
|
|
++ glamo_draw_triangle(gCtx, b, c, d); \
|
|
|
++} while (0)
|
|
|
++
|
|
|
++
|
|
|
++#define LINE(v0, v1) \
|
|
|
++do { \
|
|
|
++ glamo_draw_line(gCtx, v0, v1); \
|
|
|
++} while (0)
|
|
|
++
|
|
|
++
|
|
|
++#define POINT(v0) \
|
|
|
++do { \
|
|
|
++ glamo_draw_point(gCtx, v0); \
|
|
|
++} while (0)
|
|
|
++
|
|
|
++
|
|
|
++#define IND (0)
|
|
|
++#define TAG(x) x
|
|
|
++#include "tnl_dd/t_dd_tritmp.h"
|
|
|
++
|
|
|
++#define IND (0)
|
|
|
++#define TAG(x) x##_offset
|
|
|
++#include "tnl_dd/t_dd_tritmp.h"
|
|
|
++
|
|
|
++#define IND (0)
|
|
|
++#define TAG(x) x##_twoside
|
|
|
++#include "tnl_dd/t_dd_tritmp.h"
|
|
|
++
|
|
|
++#define IND (0)
|
|
|
++#define TAG(x) x##_twoside_offset
|
|
|
++#include "tnl_dd/t_dd_tritmp.h"
|
|
|
++
|
|
|
++#define IND (0)
|
|
|
++#define TAG(x) x##_unfilled
|
|
|
++#include "tnl_dd/t_dd_tritmp.h"
|
|
|
++
|
|
|
++#define IND (0)
|
|
|
++#define TAG(x) x##_offset_unfilled
|
|
|
++#include "tnl_dd/t_dd_tritmp.h"
|
|
|
++
|
|
|
++#define IND (0)
|
|
|
++#define TAG(x) x##_twoside_unfilled
|
|
|
++#include "tnl_dd/t_dd_tritmp.h"
|
|
|
++
|
|
|
++#define IND (0)
|
|
|
++#define TAG(x) x##_twoside_offset_unfilled
|
|
|
++#include "tnl_dd/t_dd_tritmp.h"
|
|
|
++
|
|
|
++#define IND (0)
|
|
|
++#define TAG(x) x##_fallback
|
|
|
++#include "tnl_dd/t_dd_tritmp.h"
|
|
|
++
|
|
|
++#define IND (0)
|
|
|
++#define TAG(x) x##_offset_fallback
|
|
|
++#include "tnl_dd/t_dd_tritmp.h"
|
|
|
++
|
|
|
++#define IND (0)
|
|
|
++#define TAG(x) x##_twoside_fallback
|
|
|
++#include "tnl_dd/t_dd_tritmp.h"
|
|
|
++
|
|
|
++#define IND (0)
|
|
|
++#define TAG(x) x##_twoside_offset_fallback
|
|
|
++#include "tnl_dd/t_dd_tritmp.h"
|
|
|
++
|
|
|
++#define IND (0)
|
|
|
++#define TAG(x) x##_unfilled_fallback
|
|
|
++#include "tnl_dd/t_dd_tritmp.h"
|
|
|
++
|
|
|
++#define IND (0)
|
|
|
++#define TAG(x) x##_offset_unfilled_fallback
|
|
|
++#include "tnl_dd/t_dd_tritmp.h"
|
|
|
++
|
|
|
++#define IND (0)
|
|
|
++#define TAG(x) x##_twoside_unfilled_fallback
|
|
|
++#include "tnl_dd/t_dd_tritmp.h"
|
|
|
++
|
|
|
++#define IND (0)
|
|
|
++#define TAG(x) x##_twoside_offset_unfilled_fallback
|
|
|
++#include "tnl_dd/t_dd_tritmp.h"
|
|
|
++
|
|
|
++
|
|
|
++static void init_rast_tab()
|
|
|
++{
|
|
|
++ init();
|
|
|
++ init_offset();
|
|
|
++ init_twoside();
|
|
|
++ init_twoside_offset();
|
|
|
++ init_unfilled();
|
|
|
++ init_offset_unfilled();
|
|
|
++ init_twoside_unfilled();
|
|
|
++ init_twoside_offset_unfilled();
|
|
|
++ init_fallback();
|
|
|
++ init_offset_fallback();
|
|
|
++ init_twoside_fallback();
|
|
|
++ init_twoside_offset_fallback();
|
|
|
++ init_unfilled_fallback();
|
|
|
++ init_offset_unfilled_fallback();
|
|
|
++ init_twoside_unfilled_fallback();
|
|
|
++ init_twoside_offset_unfilled_fallback();
|
|
|
++}
|
|
|
++
|
|
|
++
|
|
|
++void glamoInitTriFuncs(struct gl_context *ctx)
|
|
|
++{
|
|
|
++ TNLcontext *tnl = TNL_CONTEXT(ctx);
|
|
|
++ struct glamo_context *gCtx = GLAMO_CONTEXT(ctx);
|
|
|
++ static int firsttime = 1;
|
|
|
++
|
|
|
++ if (firsttime) {
|
|
|
++ init_rast_tab();
|
|
|
++ firsttime = 0;
|
|
|
++ }
|
|
|
++
|
|
|
++ gCtx->prim.start_offset = 0;
|
|
|
++ gCtx->prim.current_offset = 0;
|
|
|
++ gCtx->prim.vb_bo = NULL;
|
|
|
++ gCtx->prim.vb = NULL;
|
|
|
++ gCtx->prim.count = 0;
|
|
|
++
|
|
|
++ tnl->Driver.RunPipeline = glamoRunPipeline;
|
|
|
++ tnl->Driver.Render.Start = glamoRenderStart;
|
|
|
++ tnl->Driver.Render.Finish = glamoRenderFinish;
|
|
|
++ tnl->Driver.Render.PrimitiveNotify = glamoPrimitiveNotify;
|
|
|
++ tnl->Driver.Render.ResetLineStipple = _swrast_ResetLineStipple;
|
|
|
++ tnl->Driver.Render.BuildVertices = _tnl_build_vertices;
|
|
|
++ tnl->Driver.Render.CopyPV = _tnl_copy_pv;
|
|
|
++ tnl->Driver.Render.Interp = _tnl_interp;
|
|
|
++}
|
|
|
+diff --git a/src/mesa/drivers/dri/glamo/glamo_tris.h b/src/mesa/drivers/dri/glamo/glamo_tris.h
|
|
|
+new file mode 100644
|
|
|
+index 0000000..ea396c1
|
|
|
+--- /dev/null
|
|
|
++++ b/src/mesa/drivers/dri/glamo/glamo_tris.h
|
|
|
+@@ -0,0 +1,38 @@
|
|
|
++/*
|
|
|
++ * Direct Rendering Support for SMedia Glamo 336x/337x
|
|
|
++ *
|
|
|
++ * (c) 2009 Thomas White <taw@bitwiz.org.uk>
|
|
|
++ *
|
|
|
++ * Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
++ * copy of this software and associated documentation files (the "Software"),
|
|
|
++ * to deal in the Software without restriction, including without limitation
|
|
|
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
++ * and/or sell copies of the Software, and to permit persons to whom the
|
|
|
++ * Software is furnished to do so, subject to the following conditions:
|
|
|
++ *
|
|
|
++ * The above copyright notice and this permission notice shall be included
|
|
|
++ * in all copies or substantial portions of the Software.
|
|
|
++ *
|
|
|
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
|
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
++ * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
|
|
++ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
|
++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
++ */
|
|
|
++
|
|
|
++#ifndef __GLAMO_TRIS_H
|
|
|
++#define __GLAMO_TRIS_H
|
|
|
++
|
|
|
++#include "main/mtypes.h"
|
|
|
++
|
|
|
++#include "glamo_context.h"
|
|
|
++
|
|
|
++/* Amount of space reserved for vertex submission */
|
|
|
++#define GLAMO_VB_SIZE (32*1024)
|
|
|
++
|
|
|
++extern void glamoInitTriFuncs(struct gl_context *ctx);
|
|
|
++extern uint32_t *glamoGetPrimSpace(struct glamo_context *gCtx,
|
|
|
++ unsigned int count);
|
|
|
++
|
|
|
++#endif /* __GLAMO_TRIS_H */
|
|
|
+diff --git a/src/mesa/tnl_dd/t_dd_dmatmp.h b/src/mesa/tnl_dd/t_dd_dmatmp.h
|
|
|
+index 997fc0b..e3c9119 100644
|
|
|
+--- a/src/mesa/tnl_dd/t_dd_dmatmp.h
|
|
|
++++ b/src/mesa/tnl_dd/t_dd_dmatmp.h
|
|
|
+@@ -127,6 +127,8 @@ static void TAG(render_points_verts)( struct gl_context *ctx,
|
|
|
+ currentsz = dmasz;
|
|
|
+ }
|
|
|
+
|
|
|
++ FLUSH();
|
|
|
++
|
|
|
+ } else {
|
|
|
+ fprintf(stderr, "%s - cannot draw primitive\n", __FUNCTION__);
|
|
|
+ return;
|
|
|
+@@ -162,6 +164,8 @@ static void TAG(render_lines_verts)( struct gl_context *ctx,
|
|
|
+ currentsz = dmasz;
|
|
|
+ }
|
|
|
+
|
|
|
++ FLUSH();
|
|
|
++
|
|
|
+ } else {
|
|
|
+ fprintf(stderr, "%s - cannot draw primitive\n", __FUNCTION__);
|
|
|
+ return;
|
|
|
+@@ -191,7 +195,7 @@ static void TAG(render_line_strip_verts)( struct gl_context *ctx,
|
|
|
+ TAG(emit_verts)( ctx, j, nr, ALLOC_VERTS(nr) );
|
|
|
+ currentsz = dmasz;
|
|
|
+ }
|
|
|
+-
|
|
|
++
|
|
|
+ FLUSH();
|
|
|
+
|
|
|
+ } else {
|
|
|
+@@ -294,6 +298,8 @@ static void TAG(render_triangles_verts)( struct gl_context *ctx,
|
|
|
+ TAG(emit_verts)( ctx, j, nr, ALLOC_VERTS(nr) );
|
|
|
+ currentsz = dmasz;
|
|
|
+ }
|
|
|
++
|
|
|
++ FLUSH();
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+@@ -567,6 +573,8 @@ static void TAG(render_quads_verts)( struct gl_context *ctx,
|
|
|
+ TAG(emit_verts)( ctx, j, nr, ALLOC_VERTS(nr) );
|
|
|
+ currentsz = dmasz;
|
|
|
+ }
|
|
|
++
|
|
|
++ FLUSH();
|
|
|
+ }
|
|
|
+ else if (HAVE_ELTS) {
|
|
|
+ /* Hardware doesn't have a quad primitive type -- try to
|
|
|
+@@ -640,6 +648,8 @@ static void TAG(render_quads_verts)( struct gl_context *ctx,
|
|
|
+ tmp = EMIT_VERTS(ctx, j + 1, 3, tmp);
|
|
|
+ (void) tmp;
|
|
|
+ }
|
|
|
++
|
|
|
++ FLUSH();
|
|
|
+ }
|
|
|
+ else {
|
|
|
+ /* Vertices won't fit in a single buffer, should never happen.
|