/* * Copyright (C) 2008-2009 Advanced Micro Devices, 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 COPYRIGHT HOLDER(S) 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. */ /* * Authors: * Richard Li , */ #include "main/glheader.h" #include "main/mtypes.h" #include "main/imports.h" #include "main/enums.h" #include "main/macros.h" #include "main/context.h" #include "main/dd.h" #include "main/simple_list.h" #include "tnl/tnl.h" #include "tnl/t_pipeline.h" #include "swrast/swrast.h" #include "swrast_setup/swrast_setup.h" #include "main/api_arrayelt.h" #include "main/framebuffer.h" #include "drivers/common/meta.h" #include "program/prog_parameter.h" #include "program/prog_statevars.h" #include "vbo/vbo.h" #include "r600_context.h" #include "evergreen_state.h" #include "evergreen_diff.h" #include "evergreen_vertprog.h" #include "evergreen_fragprog.h" #include "evergreen_tex.h" void evergreenUpdateStateParameters(struct gl_context * ctx, GLuint new_state); //same void evergreenUpdateShaders(struct gl_context * ctx) { context_t *context = EVERGREEN_CONTEXT(ctx); /* should only happenen once, just after context is created */ /* TODO: shouldn't we fallback to sw here? */ if (!ctx->FragmentProgram._Current) { fprintf(stderr, "No ctx->FragmentProgram._Current!!\n"); return; } evergreenSelectFragmentShader(ctx); evergreenSelectVertexShader(ctx); evergreenUpdateStateParameters(ctx, _NEW_PROGRAM | _NEW_PROGRAM_CONSTANTS); context->radeon.NewGLState = 0; } void evergreeUpdateShaders(struct gl_context * ctx) { context_t *context = R700_CONTEXT(ctx); /* should only happenen once, just after context is created */ /* TODO: shouldn't we fallback to sw here? */ if (!ctx->FragmentProgram._Current) { fprintf(stderr, "No ctx->FragmentProgram._Current!!\n"); return; } evergreenSelectFragmentShader(ctx); evergreenSelectVertexShader(ctx); evergreenUpdateStateParameters(ctx, _NEW_PROGRAM | _NEW_PROGRAM_CONSTANTS); context->radeon.NewGLState = 0; } /* * To correctly position primitives: */ void evergreenUpdateViewportOffset(struct gl_context * ctx) //------------------ { context_t *context = R700_CONTEXT(ctx); EVERGREEN_CHIP_CONTEXT *evergreen = GET_EVERGREEN_CHIP(context); __DRIdrawable *dPriv = radeon_get_drawable(&context->radeon); GLfloat xoffset = (GLfloat) dPriv->x; GLfloat yoffset = (GLfloat) dPriv->y + dPriv->h; const GLfloat *v = ctx->Viewport._WindowMap.m; int id = 0; GLfloat tx = v[MAT_TX] + xoffset; GLfloat ty = (-v[MAT_TY]) + yoffset; if (evergreen->viewport[id].PA_CL_VPORT_XOFFSET.f32All != tx || evergreen->viewport[id].PA_CL_VPORT_YOFFSET.f32All != ty) { /* Note: this should also modify whatever data the context reset * code uses... */ EVERGREEN_STATECHANGE(context, pa); evergreen->viewport[id].PA_CL_VPORT_XOFFSET.f32All = tx; evergreen->viewport[id].PA_CL_VPORT_YOFFSET.f32All = ty; } radeonUpdateScissor(ctx); } void evergreenUpdateStateParameters(struct gl_context * ctx, GLuint new_state) //same { struct evergreen_fragment_program *fp = (struct evergreen_fragment_program *)ctx->FragmentProgram._Current; struct gl_program_parameter_list *paramList; if (!(new_state & (_NEW_BUFFERS | _NEW_PROGRAM | _NEW_PROGRAM_CONSTANTS))) return; if (!ctx->FragmentProgram._Current || !fp) return; paramList = ctx->FragmentProgram._Current->Base.Parameters; if (!paramList) return; _mesa_load_state_parameters(ctx, paramList); } /** * Called by Mesa after an internal state update. */ static void evergreenInvalidateState(struct gl_context * ctx, GLuint new_state) //same { context_t *context = EVERGREEN_CONTEXT(ctx); EVERGREEN_CHIP_CONTEXT *evergreen = GET_EVERGREEN_CHIP(context); _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); if (new_state & _NEW_BUFFERS) { _mesa_update_framebuffer(ctx); /* this updates the DrawBuffer's Width/Height if it's a FBO */ _mesa_update_draw_buffer_bounds(ctx); EVERGREEN_STATECHANGE(context, cb); EVERGREEN_STATECHANGE(context, db); } if (new_state & (_NEW_LIGHT)) { EVERGREEN_STATECHANGE(context, pa); if (ctx->Light.ProvokingVertex == GL_LAST_VERTEX_CONVENTION) SETbit(evergreen->PA_SU_SC_MODE_CNTL.u32All, PROVOKING_VTX_LAST_bit); else CLEARbit(evergreen->PA_SU_SC_MODE_CNTL.u32All, PROVOKING_VTX_LAST_bit); } evergreenUpdateStateParameters(ctx, new_state); EVERGREEN_STATECHANGE(context, pa); EVERGREEN_STATECHANGE(context, spi); if(GL_TRUE == evergreen->bEnablePerspective) { /* Do scale XY and Z by 1/W0 for perspective correction on pos. For orthogonal case, set both to one. */ CLEARbit(evergreen->PA_CL_VTE_CNTL.u32All, VTX_XY_FMT_bit); CLEARbit(evergreen->PA_CL_VTE_CNTL.u32All, VTX_Z_FMT_bit); SETbit(evergreen->PA_CL_VTE_CNTL.u32All, VTX_W0_FMT_bit); SETbit(evergreen->SPI_PS_IN_CONTROL_0.u32All, PERSP_GRADIENT_ENA_bit); CLEARbit(evergreen->SPI_PS_IN_CONTROL_0.u32All, LINEAR_GRADIENT_ENA_bit); SETfield(evergreen->SPI_BARYC_CNTL.u32All, 1, EG_SPI_BARYC_CNTL__PERSP_CENTROID_ENA_shift, EG_SPI_BARYC_CNTL__PERSP_CENTROID_ENA_mask); } else { /* For orthogonal case. */ SETbit(evergreen->PA_CL_VTE_CNTL.u32All, VTX_XY_FMT_bit); SETbit(evergreen->PA_CL_VTE_CNTL.u32All, VTX_Z_FMT_bit); SETbit(evergreen->PA_CL_VTE_CNTL.u32All, VTX_W0_FMT_bit); CLEARbit(evergreen->SPI_PS_IN_CONTROL_0.u32All, PERSP_GRADIENT_ENA_bit); SETbit(evergreen->SPI_PS_IN_CONTROL_0.u32All, LINEAR_GRADIENT_ENA_bit); SETfield(evergreen->SPI_BARYC_CNTL.u32All, 1, EG_SPI_BARYC_CNTL__LINEAR_CENTROID_ENA_shift, EG_SPI_BARYC_CNTL__LINEAR_CENTROID_ENA_mask); } context->radeon.NewGLState |= new_state; } static void evergreenSetAlphaState(struct gl_context * ctx) //same { context_t *context = EVERGREEN_CONTEXT(ctx); EVERGREEN_CHIP_CONTEXT *evergreen = GET_EVERGREEN_CHIP(context); uint32_t alpha_func = REF_ALWAYS; GLboolean really_enabled = ctx->Color.AlphaEnabled; EVERGREEN_STATECHANGE(context, sx); switch (ctx->Color.AlphaFunc) { case GL_NEVER: alpha_func = REF_NEVER; break; case GL_LESS: alpha_func = REF_LESS; break; case GL_EQUAL: alpha_func = REF_EQUAL; break; case GL_LEQUAL: alpha_func = REF_LEQUAL; break; case GL_GREATER: alpha_func = REF_GREATER; break; case GL_NOTEQUAL: alpha_func = REF_NOTEQUAL; break; case GL_GEQUAL: alpha_func = REF_GEQUAL; break; case GL_ALWAYS: /*alpha_func = REF_ALWAYS; */ really_enabled = GL_FALSE; break; } if (really_enabled) { SETfield(evergreen->SX_ALPHA_TEST_CONTROL.u32All, alpha_func, ALPHA_FUNC_shift, ALPHA_FUNC_mask); SETbit(evergreen->SX_ALPHA_TEST_CONTROL.u32All, ALPHA_TEST_ENABLE_bit); evergreen->SX_ALPHA_REF.f32All = ctx->Color.AlphaRef; } else { CLEARbit(evergreen->SX_ALPHA_TEST_CONTROL.u32All, ALPHA_TEST_ENABLE_bit); } } static void evergreenAlphaFunc(struct gl_context * ctx, GLenum func, GLfloat ref) //same { (void)func; (void)ref; evergreenSetAlphaState(ctx); } static void evergreenBlendColor(struct gl_context * ctx, const GLfloat cf[4]) //same { context_t *context = EVERGREEN_CONTEXT(ctx); EVERGREEN_CHIP_CONTEXT *evergreen = GET_EVERGREEN_CHIP(context); EVERGREEN_STATECHANGE(context, cb); evergreen->CB_BLEND_RED.f32All = cf[0]; evergreen->CB_BLEND_GREEN.f32All = cf[1]; evergreen->CB_BLEND_BLUE.f32All = cf[2]; evergreen->CB_BLEND_ALPHA.f32All = cf[3]; } static int evergreenblend_factor(GLenum factor, GLboolean is_src) //same { switch (factor) { case GL_ZERO: return BLEND_ZERO; break; case GL_ONE: return BLEND_ONE; break; case GL_DST_COLOR: return BLEND_DST_COLOR; break; case GL_ONE_MINUS_DST_COLOR: return BLEND_ONE_MINUS_DST_COLOR; break; case GL_SRC_COLOR: return BLEND_SRC_COLOR; break; case GL_ONE_MINUS_SRC_COLOR: return BLEND_ONE_MINUS_SRC_COLOR; break; case GL_SRC_ALPHA: return BLEND_SRC_ALPHA; break; case GL_ONE_MINUS_SRC_ALPHA: return BLEND_ONE_MINUS_SRC_ALPHA; break; case GL_DST_ALPHA: return BLEND_DST_ALPHA; break; case GL_ONE_MINUS_DST_ALPHA: return BLEND_ONE_MINUS_DST_ALPHA; break; case GL_SRC_ALPHA_SATURATE: return (is_src) ? BLEND_SRC_ALPHA_SATURATE : BLEND_ZERO; break; case GL_CONSTANT_COLOR: return BLEND_CONSTANT_COLOR; break; case GL_ONE_MINUS_CONSTANT_COLOR: return BLEND_ONE_MINUS_CONSTANT_COLOR; break; case GL_CONSTANT_ALPHA: return BLEND_CONSTANT_ALPHA; break; case GL_ONE_MINUS_CONSTANT_ALPHA: return BLEND_ONE_MINUS_CONSTANT_ALPHA; break; default: fprintf(stderr, "unknown blend factor %x\n", factor); return (is_src) ? BLEND_ONE : BLEND_ZERO; break; } } static void evergreenSetBlendState(struct gl_context * ctx) //diff : CB_COLOR_CONTROL, CB_BLEND0_CONTROL bits { context_t *context = EVERGREEN_CONTEXT(ctx); EVERGREEN_CHIP_CONTEXT *evergreen = GET_EVERGREEN_CHIP(context); uint32_t blend_reg = 0, eqn, eqnA; EVERGREEN_STATECHANGE(context, cb); if (RGBA_LOGICOP_ENABLED(ctx) || !ctx->Color.BlendEnabled) { SETfield(blend_reg, BLEND_ONE, COLOR_SRCBLEND_shift, COLOR_SRCBLEND_mask); SETfield(blend_reg, BLEND_ZERO, COLOR_DESTBLEND_shift, COLOR_DESTBLEND_mask); SETfield(blend_reg, COMB_DST_PLUS_SRC, COLOR_COMB_FCN_shift, COLOR_COMB_FCN_mask); SETfield(blend_reg, BLEND_ONE, ALPHA_SRCBLEND_shift, ALPHA_SRCBLEND_mask); SETfield(blend_reg, BLEND_ZERO, ALPHA_DESTBLEND_shift, ALPHA_DESTBLEND_mask); SETfield(blend_reg, COMB_DST_PLUS_SRC, ALPHA_COMB_FCN_shift, ALPHA_COMB_FCN_mask); //if (context->radeon.radeonScreen->chip_family == CHIP_FAMILY_R600) // evergreen->CB_BLEND_CONTROL.u32All = blend_reg; //else evergreen->CB_BLEND0_CONTROL.u32All = blend_reg; return; } SETfield(blend_reg, evergreenblend_factor(ctx->Color.BlendSrcRGB, GL_TRUE), COLOR_SRCBLEND_shift, COLOR_SRCBLEND_mask); SETfield(blend_reg, evergreenblend_factor(ctx->Color.BlendDstRGB, GL_FALSE), COLOR_DESTBLEND_shift, COLOR_DESTBLEND_mask); switch (ctx->Color.BlendEquationRGB) { case GL_FUNC_ADD: eqn = COMB_DST_PLUS_SRC; break; case GL_FUNC_SUBTRACT: eqn = COMB_SRC_MINUS_DST; break; case GL_FUNC_REVERSE_SUBTRACT: eqn = COMB_DST_MINUS_SRC; break; case GL_MIN: eqn = COMB_MIN_DST_SRC; SETfield(blend_reg, BLEND_ONE, COLOR_SRCBLEND_shift, COLOR_SRCBLEND_mask); SETfield(blend_reg, BLEND_ONE, COLOR_DESTBLEND_shift, COLOR_DESTBLEND_mask); break; case GL_MAX: eqn = COMB_MAX_DST_SRC; SETfield(blend_reg, BLEND_ONE, COLOR_SRCBLEND_shift, COLOR_SRCBLEND_mask); SETfield(blend_reg, BLEND_ONE, COLOR_DESTBLEND_shift, COLOR_DESTBLEND_mask); break; default: fprintf(stderr, "[%s:%u] Invalid RGB blend equation (0x%04x).\n", __FUNCTION__, __LINE__, ctx->Color.BlendEquationRGB); return; } SETfield(blend_reg, eqn, COLOR_COMB_FCN_shift, COLOR_COMB_FCN_mask); SETfield(blend_reg, evergreenblend_factor(ctx->Color.BlendSrcA, GL_TRUE), ALPHA_SRCBLEND_shift, ALPHA_SRCBLEND_mask); SETfield(blend_reg, evergreenblend_factor(ctx->Color.BlendDstA, GL_FALSE), ALPHA_DESTBLEND_shift, ALPHA_DESTBLEND_mask); switch (ctx->Color.BlendEquationA) { case GL_FUNC_ADD: eqnA = COMB_DST_PLUS_SRC; break; case GL_FUNC_SUBTRACT: eqnA = COMB_SRC_MINUS_DST; break; case GL_FUNC_REVERSE_SUBTRACT: eqnA = COMB_DST_MINUS_SRC; break; case GL_MIN: eqnA = COMB_MIN_DST_SRC; SETfield(blend_reg, BLEND_ONE, ALPHA_SRCBLEND_shift, ALPHA_SRCBLEND_mask); SETfield(blend_reg, BLEND_ONE, ALPHA_DESTBLEND_shift, ALPHA_DESTBLEND_mask); break; case GL_MAX: eqnA = COMB_MAX_DST_SRC; SETfield(blend_reg, BLEND_ONE, ALPHA_SRCBLEND_shift, ALPHA_SRCBLEND_mask); SETfield(blend_reg, BLEND_ONE, ALPHA_DESTBLEND_shift, ALPHA_DESTBLEND_mask); break; default: fprintf(stderr, "[%s:%u] Invalid A blend equation (0x%04x).\n", __FUNCTION__, __LINE__, ctx->Color.BlendEquationA); return; } SETfield(blend_reg, eqnA, ALPHA_COMB_FCN_shift, ALPHA_COMB_FCN_mask); SETbit(blend_reg, SEPARATE_ALPHA_BLEND_bit); SETbit(blend_reg, EG_CB_BLENDX_CONTROL_ENABLE_bit); evergreen->CB_BLEND0_CONTROL.u32All = blend_reg; } static void evergreenBlendEquationSeparate(struct gl_context * ctx, GLenum modeRGB, GLenum modeA) //same { evergreenSetBlendState(ctx); } static void evergreenBlendFuncSeparate(struct gl_context * ctx, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorA, GLenum dfactorA) //same { evergreenSetBlendState(ctx); } static GLuint evergreen_translate_logicop(GLenum logicop) //same { switch (logicop) { case GL_CLEAR: return 0x00; case GL_SET: return 0xff; case GL_COPY: return 0xcc; case GL_COPY_INVERTED: return 0x33; case GL_NOOP: return 0xaa; case GL_INVERT: return 0x55; case GL_AND: return 0x88; case GL_NAND: return 0x77; case GL_OR: return 0xee; case GL_NOR: return 0x11; case GL_XOR: return 0x66; case GL_EQUIV: return 0x99; case GL_AND_REVERSE: return 0x44; case GL_AND_INVERTED: return 0x22; case GL_OR_REVERSE: return 0xdd; case GL_OR_INVERTED: return 0xbb; default: fprintf(stderr, "unknown blend logic operation %x\n", logicop); return 0xcc; } } static void evergreenSetLogicOpState(struct gl_context *ctx) //diff : CB_COLOR_CONTROL.ROP3 is actually same bits. { context_t *context = EVERGREEN_CONTEXT(ctx); EVERGREEN_CHIP_CONTEXT *evergreen = GET_EVERGREEN_CHIP(context); EVERGREEN_STATECHANGE(context, cb); if (RGBA_LOGICOP_ENABLED(ctx)) SETfield(evergreen->CB_COLOR_CONTROL.u32All, evergreen_translate_logicop(ctx->Color.LogicOp), EG_CB_COLOR_CONTROL__ROP3_shift, EG_CB_COLOR_CONTROL__ROP3_mask); else SETfield(evergreen->CB_COLOR_CONTROL.u32All, 0xCC, EG_CB_COLOR_CONTROL__ROP3_shift, EG_CB_COLOR_CONTROL__ROP3_mask); } static void evergreenClipPlane( struct gl_context *ctx, GLenum plane, const GLfloat *eq ) //same , but PA_CL_UCP_0_ offset diff { context_t *context = EVERGREEN_CONTEXT(ctx); EVERGREEN_CHIP_CONTEXT *evergreen = GET_EVERGREEN_CHIP(context); GLint p; GLint *ip; p = (GLint) plane - (GLint) GL_CLIP_PLANE0; ip = (GLint *)ctx->Transform._ClipUserPlane[p]; EVERGREEN_STATECHANGE(context, pa); evergreen->ucp[p].PA_CL_UCP_0_X.u32All = ip[0]; evergreen->ucp[p].PA_CL_UCP_0_Y.u32All = ip[1]; evergreen->ucp[p].PA_CL_UCP_0_Z.u32All = ip[2]; evergreen->ucp[p].PA_CL_UCP_0_W.u32All = ip[3]; } static void evergreenSetClipPlaneState(struct gl_context * ctx, GLenum cap, GLboolean state) //diff in func calls { context_t *context = EVERGREEN_CONTEXT(ctx); EVERGREEN_CHIP_CONTEXT *evergreen = GET_EVERGREEN_CHIP(context); GLuint p; p = cap - GL_CLIP_PLANE0; EVERGREEN_STATECHANGE(context, pa); if (state) { evergreen->PA_CL_CLIP_CNTL.u32All |= (UCP_ENA_0_bit << p); evergreen->ucp[p].enabled = GL_TRUE; evergreenClipPlane(ctx, cap, NULL); } else { evergreen->PA_CL_CLIP_CNTL.u32All &= ~(UCP_ENA_0_bit << p); evergreen->ucp[p].enabled = GL_FALSE; } } static void evergreenSetDBRenderState(struct gl_context * ctx) { context_t *context = EVERGREEN_CONTEXT(ctx); EVERGREEN_CHIP_CONTEXT *evergreen = GET_EVERGREEN_CHIP(context); struct evergreen_fragment_program *fp = (struct evergreen_fragment_program *)(ctx->FragmentProgram._Current); EVERGREEN_STATECHANGE(context, db); SETbit(evergreen->DB_SHADER_CONTROL.u32All, DUAL_EXPORT_ENABLE_bit); SETfield(evergreen->DB_SHADER_CONTROL.u32All, EARLY_Z_THEN_LATE_Z, Z_ORDER_shift, Z_ORDER_mask); /* XXX need to enable htile for hiz/s */ SETfield(evergreen->DB_RENDER_OVERRIDE.u32All, FORCE_DISABLE, FORCE_HIZ_ENABLE_shift, FORCE_HIZ_ENABLE_mask); SETfield(evergreen->DB_RENDER_OVERRIDE.u32All, FORCE_DISABLE, FORCE_HIS_ENABLE0_shift, FORCE_HIS_ENABLE0_mask); SETfield(evergreen->DB_RENDER_OVERRIDE.u32All, FORCE_DISABLE, FORCE_HIS_ENABLE1_shift, FORCE_HIS_ENABLE1_mask); if (context->radeon.query.current) { SETbit(evergreen->DB_RENDER_OVERRIDE.u32All, NOOP_CULL_DISABLE_bit); SETbit(evergreen->DB_COUNT_CONTROL.u32All, EG_DB_COUNT_CONTROL__PERFECT_ZPASS_COUNTS_bit); } else { CLEARbit(evergreen->DB_RENDER_OVERRIDE.u32All, NOOP_CULL_DISABLE_bit); CLEARbit(evergreen->DB_COUNT_CONTROL.u32All, EG_DB_COUNT_CONTROL__PERFECT_ZPASS_COUNTS_bit); } if (fp) { if (fp->r700Shader.killIsUsed) { SETbit(evergreen->DB_SHADER_CONTROL.u32All, KILL_ENABLE_bit); } else { CLEARbit(evergreen->DB_SHADER_CONTROL.u32All, KILL_ENABLE_bit); } if (fp->r700Shader.depthIsExported) { SETbit(evergreen->DB_SHADER_CONTROL.u32All, Z_EXPORT_ENABLE_bit); } else { CLEARbit(evergreen->DB_SHADER_CONTROL.u32All, Z_EXPORT_ENABLE_bit); } } } void evergreenUpdateShaderStates(struct gl_context * ctx) { evergreenSetDBRenderState(ctx); evergreenUpdateTextureState(ctx); } static void evergreenSetDepthState(struct gl_context * ctx) //same { context_t *context = EVERGREEN_CONTEXT(ctx); EVERGREEN_CHIP_CONTEXT *evergreen = GET_EVERGREEN_CHIP(context); EVERGREEN_STATECHANGE(context, db); if (ctx->Depth.Test) { SETbit(evergreen->DB_DEPTH_CONTROL.u32All, Z_ENABLE_bit); if (ctx->Depth.Mask) { SETbit(evergreen->DB_DEPTH_CONTROL.u32All, Z_WRITE_ENABLE_bit); } else { CLEARbit(evergreen->DB_DEPTH_CONTROL.u32All, Z_WRITE_ENABLE_bit); } switch (ctx->Depth.Func) { case GL_NEVER: SETfield(evergreen->DB_DEPTH_CONTROL.u32All, FRAG_NEVER, ZFUNC_shift, ZFUNC_mask); break; case GL_LESS: SETfield(evergreen->DB_DEPTH_CONTROL.u32All, FRAG_LESS, ZFUNC_shift, ZFUNC_mask); break; case GL_EQUAL: SETfield(evergreen->DB_DEPTH_CONTROL.u32All, FRAG_EQUAL, ZFUNC_shift, ZFUNC_mask); break; case GL_LEQUAL: SETfield(evergreen->DB_DEPTH_CONTROL.u32All, FRAG_LEQUAL, ZFUNC_shift, ZFUNC_mask); break; case GL_GREATER: SETfield(evergreen->DB_DEPTH_CONTROL.u32All, FRAG_GREATER, ZFUNC_shift, ZFUNC_mask); break; case GL_NOTEQUAL: SETfield(evergreen->DB_DEPTH_CONTROL.u32All, FRAG_NOTEQUAL, ZFUNC_shift, ZFUNC_mask); break; case GL_GEQUAL: SETfield(evergreen->DB_DEPTH_CONTROL.u32All, FRAG_GEQUAL, ZFUNC_shift, ZFUNC_mask); break; case GL_ALWAYS: SETfield(evergreen->DB_DEPTH_CONTROL.u32All, FRAG_ALWAYS, ZFUNC_shift, ZFUNC_mask); break; default: SETfield(evergreen->DB_DEPTH_CONTROL.u32All, FRAG_ALWAYS, ZFUNC_shift, ZFUNC_mask); break; } } else { CLEARbit(evergreen->DB_DEPTH_CONTROL.u32All, Z_ENABLE_bit); CLEARbit(evergreen->DB_DEPTH_CONTROL.u32All, Z_WRITE_ENABLE_bit); } } static void evergreenSetStencilState(struct gl_context * ctx, GLboolean state) //same { context_t *context = EVERGREEN_CONTEXT(ctx); EVERGREEN_CHIP_CONTEXT *evergreen = GET_EVERGREEN_CHIP(context); GLboolean hw_stencil = GL_FALSE; if (ctx->DrawBuffer) { struct radeon_renderbuffer *rrbStencil = radeon_get_renderbuffer(ctx->DrawBuffer, BUFFER_STENCIL); hw_stencil = (rrbStencil && rrbStencil->bo); } if (hw_stencil) { EVERGREEN_STATECHANGE(context, db); if (state) { SETbit(evergreen->DB_DEPTH_CONTROL.u32All, STENCIL_ENABLE_bit); SETbit(evergreen->DB_DEPTH_CONTROL.u32All, BACKFACE_ENABLE_bit); SETbit(evergreen->DB_STENCIL_INFO.u32All, EG_DB_STENCIL_INFO__FORMAT_bit); } else CLEARbit(evergreen->DB_DEPTH_CONTROL.u32All, STENCIL_ENABLE_bit); } } static void evergreenUpdateCulling(struct gl_context * ctx) //same { context_t *context = EVERGREEN_CONTEXT(ctx); EVERGREEN_CHIP_CONTEXT *evergreen = GET_EVERGREEN_CHIP(context); EVERGREEN_STATECHANGE(context, pa); CLEARbit(evergreen->PA_SU_SC_MODE_CNTL.u32All, FACE_bit); CLEARbit(evergreen->PA_SU_SC_MODE_CNTL.u32All, CULL_FRONT_bit); CLEARbit(evergreen->PA_SU_SC_MODE_CNTL.u32All, CULL_BACK_bit); if (ctx->Polygon.CullFlag) { switch (ctx->Polygon.CullFaceMode) { case GL_FRONT: SETbit(evergreen->PA_SU_SC_MODE_CNTL.u32All, CULL_FRONT_bit); CLEARbit(evergreen->PA_SU_SC_MODE_CNTL.u32All, CULL_BACK_bit); break; case GL_BACK: CLEARbit(evergreen->PA_SU_SC_MODE_CNTL.u32All, CULL_FRONT_bit); SETbit(evergreen->PA_SU_SC_MODE_CNTL.u32All, CULL_BACK_bit); break; case GL_FRONT_AND_BACK: SETbit(evergreen->PA_SU_SC_MODE_CNTL.u32All, CULL_FRONT_bit); SETbit(evergreen->PA_SU_SC_MODE_CNTL.u32All, CULL_BACK_bit); break; default: CLEARbit(evergreen->PA_SU_SC_MODE_CNTL.u32All, CULL_FRONT_bit); CLEARbit(evergreen->PA_SU_SC_MODE_CNTL.u32All, CULL_BACK_bit); break; } } switch (ctx->Polygon.FrontFace) { case GL_CW: SETbit(evergreen->PA_SU_SC_MODE_CNTL.u32All, FACE_bit); break; case GL_CCW: CLEARbit(evergreen->PA_SU_SC_MODE_CNTL.u32All, FACE_bit); break; default: CLEARbit(evergreen->PA_SU_SC_MODE_CNTL.u32All, FACE_bit); /* default: ccw */ break; } /* Winding is inverted when rendering to FBO */ if (ctx->DrawBuffer && ctx->DrawBuffer->Name) evergreen->PA_SU_SC_MODE_CNTL.u32All ^= FACE_bit; } static void evergreenSetPolygonOffsetState(struct gl_context * ctx, GLboolean state) //same { context_t *context = EVERGREEN_CONTEXT(ctx); EVERGREEN_CHIP_CONTEXT *evergreen = GET_EVERGREEN_CHIP(context); EVERGREEN_STATECHANGE(context, pa); if (state) { SETbit(evergreen->PA_SU_SC_MODE_CNTL.u32All, POLY_OFFSET_FRONT_ENABLE_bit); SETbit(evergreen->PA_SU_SC_MODE_CNTL.u32All, POLY_OFFSET_BACK_ENABLE_bit); SETbit(evergreen->PA_SU_SC_MODE_CNTL.u32All, POLY_OFFSET_PARA_ENABLE_bit); } else { CLEARbit(evergreen->PA_SU_SC_MODE_CNTL.u32All, POLY_OFFSET_FRONT_ENABLE_bit); CLEARbit(evergreen->PA_SU_SC_MODE_CNTL.u32All, POLY_OFFSET_BACK_ENABLE_bit); CLEARbit(evergreen->PA_SU_SC_MODE_CNTL.u32All, POLY_OFFSET_PARA_ENABLE_bit); } } static void evergreenUpdateLineStipple(struct gl_context * ctx) //diff { /* TODO */ } void evergreenSetScissor(context_t *context) //diff { EVERGREEN_CHIP_CONTEXT *evergreen = GET_EVERGREEN_CHIP(context); unsigned x1, y1, x2, y2; int id = 0; struct radeon_renderbuffer *rrb; rrb = radeon_get_colorbuffer(&context->radeon); if (!rrb || !rrb->bo) { return; } if (context->radeon.state.scissor.enabled) { x1 = context->radeon.state.scissor.rect.x1; y1 = context->radeon.state.scissor.rect.y1; x2 = context->radeon.state.scissor.rect.x2; y2 = context->radeon.state.scissor.rect.y2; /* r600 has exclusive BR scissors */ if (context->radeon.radeonScreen->kernel_mm) { x2++; y2++; } } else { if (context->radeon.radeonScreen->driScreen->dri2.enabled) { x1 = 0; y1 = 0; x2 = rrb->base.Width; y2 = rrb->base.Height; } else { x1 = rrb->dPriv->x; y1 = rrb->dPriv->y; x2 = rrb->dPriv->x + rrb->dPriv->w; y2 = rrb->dPriv->y + rrb->dPriv->h; } } EVERGREEN_STATECHANGE(context, pa); /* screen */ /* TODO : check WINDOW_OFFSET_DISABLE */ //SETbit(evergreen->PA_SC_SCREEN_SCISSOR_TL.u32All, WINDOW_OFFSET_DISABLE_bit); SETfield(evergreen->PA_SC_SCREEN_SCISSOR_TL.u32All, x1, PA_SC_SCREEN_SCISSOR_TL__TL_X_shift, EG_PA_SC_SCREEN_SCISSOR_TL__TL_X_mask); SETfield(evergreen->PA_SC_SCREEN_SCISSOR_TL.u32All, y1, PA_SC_SCREEN_SCISSOR_TL__TL_Y_shift, EG_PA_SC_SCREEN_SCISSOR_TL__TL_Y_mask); SETfield(evergreen->PA_SC_SCREEN_SCISSOR_BR.u32All, x2, PA_SC_SCREEN_SCISSOR_BR__BR_X_shift, EG_PA_SC_SCREEN_SCISSOR_BR__BR_X_mask); SETfield(evergreen->PA_SC_SCREEN_SCISSOR_BR.u32All, y2, PA_SC_SCREEN_SCISSOR_BR__BR_Y_shift, EG_PA_SC_SCREEN_SCISSOR_BR__BR_Y_mask); /* window */ SETbit(evergreen->PA_SC_WINDOW_SCISSOR_TL.u32All, WINDOW_OFFSET_DISABLE_bit); SETfield(evergreen->PA_SC_WINDOW_SCISSOR_TL.u32All, x1, PA_SC_WINDOW_SCISSOR_TL__TL_X_shift, EG_PA_SC_WINDOW_SCISSOR_TL__TL_X_mask); SETfield(evergreen->PA_SC_WINDOW_SCISSOR_TL.u32All, y1, PA_SC_WINDOW_SCISSOR_TL__TL_Y_shift, EG_PA_SC_WINDOW_SCISSOR_TL__TL_Y_mask); SETfield(evergreen->PA_SC_WINDOW_SCISSOR_BR.u32All, x2, PA_SC_WINDOW_SCISSOR_BR__BR_X_shift, EG_PA_SC_WINDOW_SCISSOR_BR__BR_X_mask); SETfield(evergreen->PA_SC_WINDOW_SCISSOR_BR.u32All, y2, PA_SC_WINDOW_SCISSOR_BR__BR_Y_shift, EG_PA_SC_WINDOW_SCISSOR_BR__BR_Y_mask); SETfield(evergreen->PA_SC_CLIPRECT_0_TL.u32All, x1, PA_SC_CLIPRECT_0_TL__TL_X_shift, EG_PA_SC_CLIPRECT_0_TL__TL_X_mask); SETfield(evergreen->PA_SC_CLIPRECT_0_TL.u32All, y1, PA_SC_CLIPRECT_0_TL__TL_Y_shift, EG_PA_SC_CLIPRECT_0_TL__TL_Y_mask); SETfield(evergreen->PA_SC_CLIPRECT_0_BR.u32All, x2, PA_SC_CLIPRECT_0_BR__BR_X_shift, EG_PA_SC_CLIPRECT_0_BR__BR_X_mask); SETfield(evergreen->PA_SC_CLIPRECT_0_BR.u32All, y2, PA_SC_CLIPRECT_0_BR__BR_Y_shift, EG_PA_SC_CLIPRECT_0_BR__BR_Y_mask); evergreen->PA_SC_CLIPRECT_1_TL.u32All = evergreen->PA_SC_CLIPRECT_0_TL.u32All; evergreen->PA_SC_CLIPRECT_1_BR.u32All = evergreen->PA_SC_CLIPRECT_0_BR.u32All; evergreen->PA_SC_CLIPRECT_2_TL.u32All = evergreen->PA_SC_CLIPRECT_0_TL.u32All; evergreen->PA_SC_CLIPRECT_2_BR.u32All = evergreen->PA_SC_CLIPRECT_0_BR.u32All; evergreen->PA_SC_CLIPRECT_3_TL.u32All = evergreen->PA_SC_CLIPRECT_0_TL.u32All; evergreen->PA_SC_CLIPRECT_3_BR.u32All = evergreen->PA_SC_CLIPRECT_0_BR.u32All; /* more....2d clip */ SETbit(evergreen->PA_SC_GENERIC_SCISSOR_TL.u32All, WINDOW_OFFSET_DISABLE_bit); SETfield(evergreen->PA_SC_GENERIC_SCISSOR_TL.u32All, x1, PA_SC_GENERIC_SCISSOR_TL__TL_X_shift, EG_PA_SC_GENERIC_SCISSOR_TL__TL_X_mask); SETfield(evergreen->PA_SC_GENERIC_SCISSOR_TL.u32All, y1, PA_SC_GENERIC_SCISSOR_TL__TL_Y_shift, EG_PA_SC_GENERIC_SCISSOR_TL__TL_Y_mask); SETfield(evergreen->PA_SC_GENERIC_SCISSOR_BR.u32All, x2, PA_SC_GENERIC_SCISSOR_BR__BR_X_shift, EG_PA_SC_GENERIC_SCISSOR_BR__BR_X_mask); SETfield(evergreen->PA_SC_GENERIC_SCISSOR_BR.u32All, y2, PA_SC_GENERIC_SCISSOR_BR__BR_Y_shift, EG_PA_SC_GENERIC_SCISSOR_BR__BR_Y_mask); SETbit(evergreen->viewport[id].PA_SC_VPORT_SCISSOR_0_TL.u32All, WINDOW_OFFSET_DISABLE_bit); SETfield(evergreen->viewport[id].PA_SC_VPORT_SCISSOR_0_TL.u32All, x1, PA_SC_VPORT_SCISSOR_0_TL__TL_X_shift, EG_PA_SC_VPORT_SCISSOR_0_TL__TL_X_mask); SETfield(evergreen->viewport[id].PA_SC_VPORT_SCISSOR_0_TL.u32All, y1, PA_SC_VPORT_SCISSOR_0_TL__TL_Y_shift, EG_PA_SC_VPORT_SCISSOR_0_TL__TL_Y_mask); SETfield(evergreen->viewport[id].PA_SC_VPORT_SCISSOR_0_BR.u32All, x2, PA_SC_VPORT_SCISSOR_0_BR__BR_X_shift, EG_PA_SC_VPORT_SCISSOR_0_BR__BR_X_mask); SETfield(evergreen->viewport[id].PA_SC_VPORT_SCISSOR_0_BR.u32All, y2, PA_SC_VPORT_SCISSOR_0_BR__BR_Y_shift, EG_PA_SC_VPORT_SCISSOR_0_BR__BR_Y_mask); id = 1; SETbit(evergreen->viewport[id].PA_SC_VPORT_SCISSOR_0_TL.u32All, WINDOW_OFFSET_DISABLE_bit); SETfield(evergreen->viewport[id].PA_SC_VPORT_SCISSOR_0_TL.u32All, x1, PA_SC_VPORT_SCISSOR_0_TL__TL_X_shift, EG_PA_SC_VPORT_SCISSOR_0_TL__TL_X_mask); SETfield(evergreen->viewport[id].PA_SC_VPORT_SCISSOR_0_TL.u32All, y1, PA_SC_VPORT_SCISSOR_0_TL__TL_Y_shift, EG_PA_SC_VPORT_SCISSOR_0_TL__TL_Y_mask); SETfield(evergreen->viewport[id].PA_SC_VPORT_SCISSOR_0_BR.u32All, x2, PA_SC_VPORT_SCISSOR_0_BR__BR_X_shift, EG_PA_SC_VPORT_SCISSOR_0_BR__BR_X_mask); SETfield(evergreen->viewport[id].PA_SC_VPORT_SCISSOR_0_BR.u32All, y2, PA_SC_VPORT_SCISSOR_0_BR__BR_Y_shift, EG_PA_SC_VPORT_SCISSOR_0_BR__BR_Y_mask); evergreen->viewport[id].enabled = GL_TRUE; } static void evergreenUpdateWindow(struct gl_context * ctx, int id) //diff in calling evergreenSetScissor { context_t *context = EVERGREEN_CONTEXT(ctx); EVERGREEN_CHIP_CONTEXT *evergreen = GET_EVERGREEN_CHIP(context); __DRIdrawable *dPriv = radeon_get_drawable(&context->radeon); GLfloat xoffset = dPriv ? (GLfloat) dPriv->x : 0; GLfloat yoffset = dPriv ? (GLfloat) dPriv->y + dPriv->h : 0; const GLfloat *v = ctx->Viewport._WindowMap.m; const GLfloat depthScale = 1.0F / ctx->DrawBuffer->_DepthMaxF; const GLboolean render_to_fbo = (ctx->DrawBuffer->Name != 0); GLfloat y_scale, y_bias; if (render_to_fbo) { y_scale = 1.0; y_bias = 0; } else { y_scale = -1.0; y_bias = yoffset; } GLfloat sx = v[MAT_SX]; GLfloat tx = v[MAT_TX] + xoffset; GLfloat sy = v[MAT_SY] * y_scale; GLfloat ty = (v[MAT_TY] * y_scale) + y_bias; GLfloat sz = v[MAT_SZ] * depthScale; GLfloat tz = v[MAT_TZ] * depthScale; EVERGREEN_STATECHANGE(context, pa); evergreen->viewport[id].PA_CL_VPORT_XSCALE.f32All = sx; evergreen->viewport[id].PA_CL_VPORT_XOFFSET.f32All = tx; evergreen->viewport[id].PA_CL_VPORT_YSCALE.f32All = sy; evergreen->viewport[id].PA_CL_VPORT_YOFFSET.f32All = ty; evergreen->viewport[id].PA_CL_VPORT_ZSCALE.f32All = sz; evergreen->viewport[id].PA_CL_VPORT_ZOFFSET.f32All = tz; if (ctx->Transform.DepthClamp) { evergreen->viewport[id].PA_SC_VPORT_ZMIN_0.f32All = MIN2(ctx->Viewport.Near, ctx->Viewport.Far); evergreen->viewport[id].PA_SC_VPORT_ZMAX_0.f32All = MAX2(ctx->Viewport.Near, ctx->Viewport.Far); SETbit(evergreen->PA_CL_CLIP_CNTL.u32All, ZCLIP_NEAR_DISABLE_bit); SETbit(evergreen->PA_CL_CLIP_CNTL.u32All, ZCLIP_FAR_DISABLE_bit); } else { evergreen->viewport[id].PA_SC_VPORT_ZMIN_0.f32All = 0.0; evergreen->viewport[id].PA_SC_VPORT_ZMAX_0.f32All = 1.0; CLEARbit(evergreen->PA_CL_CLIP_CNTL.u32All, ZCLIP_NEAR_DISABLE_bit); CLEARbit(evergreen->PA_CL_CLIP_CNTL.u32All, ZCLIP_FAR_DISABLE_bit); } evergreen->viewport[id].enabled = GL_TRUE; evergreenSetScissor(context); } static void evergreenEnable(struct gl_context * ctx, GLenum cap, GLboolean state) //diff in func calls { context_t *context = EVERGREEN_CONTEXT(ctx); switch (cap) { case GL_TEXTURE_1D: case GL_TEXTURE_2D: case GL_TEXTURE_3D: /* empty */ break; case GL_FOG: /* empty */ break; case GL_ALPHA_TEST: evergreenSetAlphaState(ctx); break; case GL_COLOR_LOGIC_OP: evergreenSetLogicOpState(ctx); /* fall-through, because logic op overrides blending */ case GL_BLEND: evergreenSetBlendState(ctx); break; case GL_CLIP_PLANE0: case GL_CLIP_PLANE1: case GL_CLIP_PLANE2: case GL_CLIP_PLANE3: case GL_CLIP_PLANE4: case GL_CLIP_PLANE5: evergreenSetClipPlaneState(ctx, cap, state); break; case GL_DEPTH_TEST: evergreenSetDepthState(ctx); break; case GL_STENCIL_TEST: evergreenSetStencilState(ctx, state); break; case GL_CULL_FACE: evergreenUpdateCulling(ctx); break; case GL_POLYGON_OFFSET_POINT: case GL_POLYGON_OFFSET_LINE: case GL_POLYGON_OFFSET_FILL: evergreenSetPolygonOffsetState(ctx, state); break; case GL_SCISSOR_TEST: radeon_firevertices(&context->radeon); context->radeon.state.scissor.enabled = state; radeonUpdateScissor(ctx); break; case GL_LINE_STIPPLE: evergreenUpdateLineStipple(ctx); break; case GL_DEPTH_CLAMP: evergreenUpdateWindow(ctx, 0); break; default: break; } } static void evergreenColorMask(struct gl_context * ctx, GLboolean r, GLboolean g, GLboolean b, GLboolean a) //same { context_t *context = EVERGREEN_CONTEXT(ctx); EVERGREEN_CHIP_CONTEXT *evergreen = GET_EVERGREEN_CHIP(context); unsigned int mask = ((r ? 1 : 0) | (g ? 2 : 0) | (b ? 4 : 0) | (a ? 8 : 0)); if (mask != evergreen->CB_TARGET_MASK.u32All) { EVERGREEN_STATECHANGE(context, cb); SETfield(evergreen->CB_TARGET_MASK.u32All, mask, TARGET0_ENABLE_shift, TARGET0_ENABLE_mask); } } static void evergreenDepthFunc(struct gl_context * ctx, GLenum func) //same { evergreenSetDepthState(ctx); } static void evergreenDepthMask(struct gl_context * ctx, GLboolean mask) //same { evergreenSetDepthState(ctx); } static void evergreenCullFace(struct gl_context * ctx, GLenum mode) //same { evergreenUpdateCulling(ctx); } static void evergreenFogfv(struct gl_context * ctx, GLenum pname, const GLfloat * param) //same { } static void evergreenUpdatePolygonMode(struct gl_context * ctx) //same { context_t *context = EVERGREEN_CONTEXT(ctx); EVERGREEN_CHIP_CONTEXT *evergreen = GET_EVERGREEN_CHIP(context); EVERGREEN_STATECHANGE(context, pa); SETfield(evergreen->PA_SU_SC_MODE_CNTL.u32All, X_DISABLE_POLY_MODE, POLY_MODE_shift, POLY_MODE_mask); /* Only do something if a polygon mode is wanted, default is GL_FILL */ if (ctx->Polygon.FrontMode != GL_FILL || ctx->Polygon.BackMode != GL_FILL) { GLenum f, b; /* Handle GL_CW (clock wise and GL_CCW (counter clock wise) * correctly by selecting the correct front and back face */ f = ctx->Polygon.FrontMode; b = ctx->Polygon.BackMode; /* Enable polygon mode */ SETfield(evergreen->PA_SU_SC_MODE_CNTL.u32All, X_DUAL_MODE, POLY_MODE_shift, POLY_MODE_mask); switch (f) { case GL_LINE: SETfield(evergreen->PA_SU_SC_MODE_CNTL.u32All, X_DRAW_LINES, POLYMODE_FRONT_PTYPE_shift, POLYMODE_FRONT_PTYPE_mask); break; case GL_POINT: SETfield(evergreen->PA_SU_SC_MODE_CNTL.u32All, X_DRAW_POINTS, POLYMODE_FRONT_PTYPE_shift, POLYMODE_FRONT_PTYPE_mask); break; case GL_FILL: SETfield(evergreen->PA_SU_SC_MODE_CNTL.u32All, X_DRAW_TRIANGLES, POLYMODE_FRONT_PTYPE_shift, POLYMODE_FRONT_PTYPE_mask); break; } switch (b) { case GL_LINE: SETfield(evergreen->PA_SU_SC_MODE_CNTL.u32All, X_DRAW_LINES, POLYMODE_BACK_PTYPE_shift, POLYMODE_BACK_PTYPE_mask); break; case GL_POINT: SETfield(evergreen->PA_SU_SC_MODE_CNTL.u32All, X_DRAW_POINTS, POLYMODE_BACK_PTYPE_shift, POLYMODE_BACK_PTYPE_mask); break; case GL_FILL: SETfield(evergreen->PA_SU_SC_MODE_CNTL.u32All, X_DRAW_TRIANGLES, POLYMODE_BACK_PTYPE_shift, POLYMODE_BACK_PTYPE_mask); break; } } } static void evergreenFrontFace(struct gl_context * ctx, GLenum mode) //same { evergreenUpdateCulling(ctx); evergreenUpdatePolygonMode(ctx); } static void evergreenShadeModel(struct gl_context * ctx, GLenum mode) //same { context_t *context = EVERGREEN_CONTEXT(ctx); EVERGREEN_CHIP_CONTEXT *evergreen = GET_EVERGREEN_CHIP(context); EVERGREEN_STATECHANGE(context, spi); /* also need to set/clear FLAT_SHADE bit per param in SPI_PS_INPUT_CNTL_[0-31] */ switch (mode) { case GL_FLAT: SETbit(evergreen->SPI_INTERP_CONTROL_0.u32All, FLAT_SHADE_ENA_bit); break; case GL_SMOOTH: CLEARbit(evergreen->SPI_INTERP_CONTROL_0.u32All, FLAT_SHADE_ENA_bit); break; default: return; } } static void evergreenLogicOpcode(struct gl_context *ctx, GLenum logicop) //diff { if (RGBA_LOGICOP_ENABLED(ctx)) evergreenSetLogicOpState(ctx); } static void evergreenPointSize(struct gl_context * ctx, GLfloat size) //same { context_t *context = EVERGREEN_CONTEXT(ctx); EVERGREEN_CHIP_CONTEXT *evergreen = GET_EVERGREEN_CHIP(context); EVERGREEN_STATECHANGE(context, pa); /* We need to clamp to user defined range here, because * the HW clamping happens only for per vertex point size. */ size = CLAMP(size, ctx->Point.MinSize, ctx->Point.MaxSize); /* same size limits for AA, non-AA points */ size = CLAMP(size, ctx->Const.MinPointSize, ctx->Const.MaxPointSize); /* format is 12.4 fixed point */ SETfield(evergreen->PA_SU_POINT_SIZE.u32All, (int)(size * 8.0), PA_SU_POINT_SIZE__HEIGHT_shift, PA_SU_POINT_SIZE__HEIGHT_mask); SETfield(evergreen->PA_SU_POINT_SIZE.u32All, (int)(size * 8.0), PA_SU_POINT_SIZE__WIDTH_shift, PA_SU_POINT_SIZE__WIDTH_mask); } static void evergreenPointParameter(struct gl_context * ctx, GLenum pname, const GLfloat * param) //same { context_t *context = EVERGREEN_CONTEXT(ctx); EVERGREEN_CHIP_CONTEXT *evergreen = GET_EVERGREEN_CHIP(context); EVERGREEN_STATECHANGE(context, pa); /* format is 12.4 fixed point */ switch (pname) { case GL_POINT_SIZE_MIN: SETfield(evergreen->PA_SU_POINT_MINMAX.u32All, (int)(ctx->Point.MinSize * 8.0), MIN_SIZE_shift, MIN_SIZE_mask); evergreenPointSize(ctx, ctx->Point.Size); break; case GL_POINT_SIZE_MAX: SETfield(evergreen->PA_SU_POINT_MINMAX.u32All, (int)(ctx->Point.MaxSize * 8.0), MAX_SIZE_shift, MAX_SIZE_mask); evergreenPointSize(ctx, ctx->Point.Size); break; case GL_POINT_DISTANCE_ATTENUATION: break; case GL_POINT_FADE_THRESHOLD_SIZE: break; default: break; } } static int evergreen_translate_stencil_func(int func) //same { switch (func) { case GL_NEVER: return REF_NEVER; case GL_LESS: return REF_LESS; case GL_EQUAL: return REF_EQUAL; case GL_LEQUAL: return REF_LEQUAL; case GL_GREATER: return REF_GREATER; case GL_NOTEQUAL: return REF_NOTEQUAL; case GL_GEQUAL: return REF_GEQUAL; case GL_ALWAYS: return REF_ALWAYS; } return 0; } static void evergreenStencilFuncSeparate(struct gl_context * ctx, GLenum face, GLenum func, GLint ref, GLuint mask) //same { context_t *context = EVERGREEN_CONTEXT(ctx); EVERGREEN_CHIP_CONTEXT *evergreen = GET_EVERGREEN_CHIP(context); const unsigned back = ctx->Stencil._BackFace; EVERGREEN_STATECHANGE(context, db); //front SETfield(evergreen->DB_STENCILREFMASK.u32All, ctx->Stencil.Ref[0], STENCILREF_shift, STENCILREF_mask); SETfield(evergreen->DB_STENCILREFMASK.u32All, ctx->Stencil.ValueMask[0], STENCILMASK_shift, STENCILMASK_mask); SETfield(evergreen->DB_DEPTH_CONTROL.u32All, evergreen_translate_stencil_func(ctx->Stencil.Function[0]), STENCILFUNC_shift, STENCILFUNC_mask); //back SETfield(evergreen->DB_STENCILREFMASK_BF.u32All, ctx->Stencil.Ref[back], STENCILREF_BF_shift, STENCILREF_BF_mask); SETfield(evergreen->DB_STENCILREFMASK_BF.u32All, ctx->Stencil.ValueMask[back], STENCILMASK_BF_shift, STENCILMASK_BF_mask); SETfield(evergreen->DB_DEPTH_CONTROL.u32All, evergreen_translate_stencil_func(ctx->Stencil.Function[back]), STENCILFUNC_BF_shift, STENCILFUNC_BF_mask); } static void evergreenStencilMaskSeparate(struct gl_context * ctx, GLenum face, GLuint mask) //same { context_t *context = EVERGREEN_CONTEXT(ctx); EVERGREEN_CHIP_CONTEXT *evergreen = GET_EVERGREEN_CHIP(context); const unsigned back = ctx->Stencil._BackFace; EVERGREEN_STATECHANGE(context, db); // front SETfield(evergreen->DB_STENCILREFMASK.u32All, ctx->Stencil.WriteMask[0], STENCILWRITEMASK_shift, STENCILWRITEMASK_mask); // back SETfield(evergreen->DB_STENCILREFMASK_BF.u32All, ctx->Stencil.WriteMask[back], STENCILWRITEMASK_BF_shift, STENCILWRITEMASK_BF_mask); } static int evergreen_translate_stencil_op(int op) //same { switch (op) { case GL_KEEP: return STENCIL_KEEP; case GL_ZERO: return STENCIL_ZERO; case GL_REPLACE: return STENCIL_REPLACE; case GL_INCR: return STENCIL_INCR_CLAMP; case GL_DECR: return STENCIL_DECR_CLAMP; case GL_INCR_WRAP_EXT: return STENCIL_INCR_WRAP; case GL_DECR_WRAP_EXT: return STENCIL_DECR_WRAP; case GL_INVERT: return STENCIL_INVERT; default: WARN_ONCE("Do not know how to translate stencil op"); return STENCIL_KEEP; } return 0; } static void evergreenStencilOpSeparate(struct gl_context * ctx, GLenum face, GLenum fail, GLenum zfail, GLenum zpass) //same { context_t *context = EVERGREEN_CONTEXT(ctx); EVERGREEN_CHIP_CONTEXT *evergreen = GET_EVERGREEN_CHIP(context); const unsigned back = ctx->Stencil._BackFace; EVERGREEN_STATECHANGE(context, db); SETfield(evergreen->DB_DEPTH_CONTROL.u32All, evergreen_translate_stencil_op(ctx->Stencil.FailFunc[0]), STENCILFAIL_shift, STENCILFAIL_mask); SETfield(evergreen->DB_DEPTH_CONTROL.u32All, evergreen_translate_stencil_op(ctx->Stencil.ZFailFunc[0]), STENCILZFAIL_shift, STENCILZFAIL_mask); SETfield(evergreen->DB_DEPTH_CONTROL.u32All, evergreen_translate_stencil_op(ctx->Stencil.ZPassFunc[0]), STENCILZPASS_shift, STENCILZPASS_mask); SETfield(evergreen->DB_DEPTH_CONTROL.u32All, evergreen_translate_stencil_op(ctx->Stencil.FailFunc[back]), STENCILFAIL_BF_shift, STENCILFAIL_BF_mask); SETfield(evergreen->DB_DEPTH_CONTROL.u32All, evergreen_translate_stencil_op(ctx->Stencil.ZFailFunc[back]), STENCILZFAIL_BF_shift, STENCILZFAIL_BF_mask); SETfield(evergreen->DB_DEPTH_CONTROL.u32All, evergreen_translate_stencil_op(ctx->Stencil.ZPassFunc[back]), STENCILZPASS_BF_shift, STENCILZPASS_BF_mask); } static void evergreenViewport(struct gl_context * ctx, GLint x, GLint y, GLsizei width, GLsizei height) //diff in evergreenUpdateWindow { evergreenUpdateWindow(ctx, 0); radeon_viewport(ctx, x, y, width, height); } static void evergreenDepthRange(struct gl_context * ctx, GLclampd nearval, GLclampd farval) //diff in evergreenUpdateWindow { evergreenUpdateWindow(ctx, 0); } static void evergreenLineWidth(struct gl_context * ctx, GLfloat widthf) //same { context_t *context = EVERGREEN_CONTEXT(ctx); EVERGREEN_CHIP_CONTEXT *evergreen = GET_EVERGREEN_CHIP(context); uint32_t lineWidth = (uint32_t)((widthf * 0.5) * (1 << 4)); EVERGREEN_STATECHANGE(context, pa); if (lineWidth > 0xFFFF) lineWidth = 0xFFFF; SETfield(evergreen->PA_SU_LINE_CNTL.u32All,(uint16_t)lineWidth, PA_SU_LINE_CNTL__WIDTH_shift, PA_SU_LINE_CNTL__WIDTH_mask); } static void evergreenLineStipple(struct gl_context *ctx, GLint factor, GLushort pattern) //same { context_t *context = EVERGREEN_CONTEXT(ctx); EVERGREEN_CHIP_CONTEXT *evergreen = GET_EVERGREEN_CHIP(context); EVERGREEN_STATECHANGE(context, pa); SETfield(evergreen->PA_SC_LINE_STIPPLE.u32All, pattern, LINE_PATTERN_shift, LINE_PATTERN_mask); SETfield(evergreen->PA_SC_LINE_STIPPLE.u32All, (factor-1), REPEAT_COUNT_shift, REPEAT_COUNT_mask); SETfield(evergreen->PA_SC_LINE_STIPPLE.u32All, 1, AUTO_RESET_CNTL_shift, AUTO_RESET_CNTL_mask); } static void evergreenPolygonOffset(struct gl_context * ctx, GLfloat factor, GLfloat units) //diff : //all register here offset diff, bits same { context_t *context = EVERGREEN_CONTEXT(ctx); EVERGREEN_CHIP_CONTEXT *evergreen = GET_EVERGREEN_CHIP(context); GLfloat constant = units; GLchar depth = 0; EVERGREEN_STATECHANGE(context, pa); switch (ctx->Visual.depthBits) { case 16: constant *= 4.0; depth = -16; break; case 24: constant *= 2.0; depth = -24; break; } factor *= 12.0; SETfield(evergreen->PA_SU_POLY_OFFSET_DB_FMT_CNTL.u32All, depth, POLY_OFFSET_NEG_NUM_DB_BITS_shift, POLY_OFFSET_NEG_NUM_DB_BITS_mask); //evergreen->PA_SU_POLY_OFFSET_CLAMP.f32All = constant; //??? evergreen->PA_SU_POLY_OFFSET_FRONT_SCALE.f32All = factor; evergreen->PA_SU_POLY_OFFSET_FRONT_OFFSET.f32All = constant; evergreen->PA_SU_POLY_OFFSET_BACK_SCALE.f32All = factor; evergreen->PA_SU_POLY_OFFSET_BACK_OFFSET.f32All = constant; } static void evergreenPolygonMode(struct gl_context * ctx, GLenum face, GLenum mode) //same { (void)face; (void)mode; evergreenUpdatePolygonMode(ctx); } static void evergreenRenderMode(struct gl_context * ctx, GLenum mode) //same { } //TODO : move to kernel. static void evergreenInitSQConfig(struct gl_context * ctx) { context_t *context = EVERGREEN_CONTEXT(ctx); EVERGREEN_CHIP_CONTEXT *evergreen = GET_EVERGREEN_CHIP(context); uint32_t uSqNumCfInsts, uMaxGPRs, uMaxThreads, uMaxStackEntries, uPSThreadCount, uOtherThreadCount; uint32_t NUM_PS_GPRS, NUM_VS_GPRS, NUM_GS_GPRS, NUM_ES_GPRS, NUM_HS_GPRS, NUM_LS_GPRS, NUM_CLAUSE_TEMP_GPRS; GLboolean bVC_ENABLE = GL_TRUE; R600_STATECHANGE(context, sq); switch (context->radeon.radeonScreen->chip_family) { case CHIP_FAMILY_CEDAR: uSqNumCfInsts = 1; bVC_ENABLE = GL_FALSE; uMaxGPRs = 256; uPSThreadCount = 96; uMaxThreads = 192; uMaxStackEntries = 256; break; case CHIP_FAMILY_REDWOOD: uSqNumCfInsts = 2; bVC_ENABLE = GL_TRUE; uMaxGPRs = 256; uPSThreadCount = 128; uMaxThreads = 248; uMaxStackEntries = 256; break; case CHIP_FAMILY_JUNIPER: uSqNumCfInsts = 2; bVC_ENABLE = GL_TRUE; uMaxGPRs = 256; uPSThreadCount = 128; uMaxThreads = 248; uMaxStackEntries = 512; break; case CHIP_FAMILY_CYPRESS: uSqNumCfInsts = 2; bVC_ENABLE = GL_TRUE; uMaxGPRs = 256; uPSThreadCount = 128; uMaxThreads = 248; uMaxStackEntries = 512; break; case CHIP_FAMILY_HEMLOCK: uSqNumCfInsts = 2;//? bVC_ENABLE = GL_TRUE; uMaxGPRs = 256; uPSThreadCount = 128; uMaxThreads = 248; uMaxStackEntries = 512; break; case CHIP_FAMILY_PALM: uSqNumCfInsts = 1; bVC_ENABLE = GL_FALSE; uMaxGPRs = 256; uPSThreadCount = 96; uMaxThreads = 192; uMaxStackEntries = 256; break; case CHIP_FAMILY_BARTS: uSqNumCfInsts = 2; bVC_ENABLE = GL_TRUE; uMaxGPRs = 256; uPSThreadCount = 128; uMaxThreads = 248; uMaxStackEntries = 512; break; case CHIP_FAMILY_TURKS: uSqNumCfInsts = 2; bVC_ENABLE = GL_TRUE; uMaxGPRs = 256; uPSThreadCount = 128; uMaxThreads = 248; uMaxStackEntries = 256; break; case CHIP_FAMILY_CAICOS: uSqNumCfInsts = 1; bVC_ENABLE = GL_FALSE; uMaxGPRs = 256; uPSThreadCount = 128; uMaxThreads = 192; uMaxStackEntries = 256; break; default: uSqNumCfInsts = 2; bVC_ENABLE = GL_TRUE; uMaxGPRs = 256; uPSThreadCount = 128; uMaxThreads = 248; uMaxStackEntries = 512; break; } evergreen->evergreen_config.SQ_DYN_GPR_CNTL_PS_FLUSH_REQ.u32All = 0; evergreen->evergreen_config.SPI_CONFIG_CNTL.u32All = 0; evergreen->evergreen_config.SPI_CONFIG_CNTL_1.u32All = 0; SETfield(evergreen->evergreen_config.SPI_CONFIG_CNTL_1.u32All, 4, EG_SPI_CONFIG_CNTL_1__VTX_DONE_DELAY_shift, EG_SPI_CONFIG_CNTL_1__VTX_DONE_DELAY_mask); evergreen->evergreen_config.CP_PERFMON_CNTL.u32All = 0; evergreen->evergreen_config.SQ_MS_FIFO_SIZES.u32All = 0; SETfield(evergreen->evergreen_config.SQ_MS_FIFO_SIZES.u32All, 16 * uSqNumCfInsts, EG_SQ_MS_FIFO_SIZES__CACHE_FIFO_SIZE_shift, EG_SQ_MS_FIFO_SIZES__CACHE_FIFO_SIZE_mask); SETfield(evergreen->evergreen_config.SQ_MS_FIFO_SIZES.u32All, 0x4, EG_SQ_MS_FIFO_SIZES__FETCH_FIFO_HIWATER_shift, EG_SQ_MS_FIFO_SIZES__FETCH_FIFO_HIWATER_mask); SETfield(evergreen->evergreen_config.SQ_MS_FIFO_SIZES.u32All, 0xE0, EG_SQ_MS_FIFO_SIZES__DONE_FIFO_HIWATER_shift, EG_SQ_MS_FIFO_SIZES__DONE_FIFO_HIWATER_mask); SETfield(evergreen->evergreen_config.SQ_MS_FIFO_SIZES.u32All, 0x8, EG_SQ_MS_FIFO_SIZES__ALU_UPDATE_FIFO_HIWATER_shift, EG_SQ_MS_FIFO_SIZES__ALU_UPDATE_FIFO_HIWATER_mask); if(bVC_ENABLE == GL_TRUE) { SETbit(evergreen->evergreen_config.SQ_CONFIG.u32All, EG_SQ_CONFIG__VC_ENABLE_bit); } else { CLEARbit(evergreen->evergreen_config.SQ_CONFIG.u32All, EG_SQ_CONFIG__VC_ENABLE_bit); } SETbit(evergreen->evergreen_config.SQ_CONFIG.u32All, EG_SQ_CONFIG__EXPORT_SRC_C_bit); SETfield(evergreen->evergreen_config.SQ_CONFIG.u32All, 0, EG_SQ_CONFIG__PS_PRIO_shift, EG_SQ_CONFIG__PS_PRIO_mask); SETfield(evergreen->evergreen_config.SQ_CONFIG.u32All, 1, EG_SQ_CONFIG__VS_PRIO_shift, EG_SQ_CONFIG__VS_PRIO_mask); SETfield(evergreen->evergreen_config.SQ_CONFIG.u32All, 2, EG_SQ_CONFIG__GS_PRIO_shift, EG_SQ_CONFIG__GS_PRIO_mask); SETfield(evergreen->evergreen_config.SQ_CONFIG.u32All, 3, EG_SQ_CONFIG__ES_PRIO_shift, EG_SQ_CONFIG__ES_PRIO_mask); NUM_CLAUSE_TEMP_GPRS = 4; NUM_PS_GPRS = ((uMaxGPRs-(4*2))*12/32); // 93 NUM_VS_GPRS = ((uMaxGPRs-(4*2))*6/32); // 46 NUM_GS_GPRS = ((uMaxGPRs-(4*2))*4/32); // 31 NUM_ES_GPRS = ((uMaxGPRs-(4*2))*4/32); // 31 NUM_HS_GPRS = ((uMaxGPRs-(4*2))*3/32); // 23 NUM_LS_GPRS = ((uMaxGPRs-(4*2))*3/32); // 23 evergreen->evergreen_config.SQ_GPR_RESOURCE_MGMT_1.u32All = 0; evergreen->evergreen_config.SQ_GPR_RESOURCE_MGMT_2.u32All = 0; evergreen->evergreen_config.SQ_GPR_RESOURCE_MGMT_3.u32All = 0; SETfield(evergreen->evergreen_config.SQ_GPR_RESOURCE_MGMT_1.u32All, NUM_PS_GPRS, NUM_PS_GPRS_shift, NUM_PS_GPRS_mask); SETfield(evergreen->evergreen_config.SQ_GPR_RESOURCE_MGMT_1.u32All, NUM_VS_GPRS, NUM_VS_GPRS_shift, NUM_VS_GPRS_mask); SETfield(evergreen->evergreen_config.SQ_GPR_RESOURCE_MGMT_1.u32All, NUM_CLAUSE_TEMP_GPRS, NUM_CLAUSE_TEMP_GPRS_shift, NUM_CLAUSE_TEMP_GPRS_mask); SETfield(evergreen->evergreen_config.SQ_GPR_RESOURCE_MGMT_2.u32All, NUM_GS_GPRS, NUM_GS_GPRS_shift, NUM_GS_GPRS_mask); SETfield(evergreen->evergreen_config.SQ_GPR_RESOURCE_MGMT_2.u32All, NUM_ES_GPRS, NUM_ES_GPRS_shift, NUM_ES_GPRS_mask); SETfield(evergreen->evergreen_config.SQ_GPR_RESOURCE_MGMT_3.u32All, NUM_HS_GPRS, NUM_PS_GPRS_shift, NUM_PS_GPRS_mask); SETfield(evergreen->evergreen_config.SQ_GPR_RESOURCE_MGMT_3.u32All, NUM_LS_GPRS, NUM_VS_GPRS_shift, NUM_VS_GPRS_mask); uOtherThreadCount = (((uMaxThreads-uPSThreadCount)/6)/8)*8; evergreen->evergreen_config.SQ_THREAD_RESOURCE_MGMT.u32All = 0; evergreen->evergreen_config.SQ_THREAD_RESOURCE_MGMT_2.u32All = 0; SETfield(evergreen->evergreen_config.SQ_THREAD_RESOURCE_MGMT.u32All, uPSThreadCount, NUM_PS_THREADS_shift, NUM_PS_THREADS_mask); SETfield(evergreen->evergreen_config.SQ_THREAD_RESOURCE_MGMT.u32All, uOtherThreadCount, NUM_VS_THREADS_shift, NUM_VS_THREADS_mask); SETfield(evergreen->evergreen_config.SQ_THREAD_RESOURCE_MGMT.u32All, uOtherThreadCount, NUM_GS_THREADS_shift, NUM_GS_THREADS_mask); SETfield(evergreen->evergreen_config.SQ_THREAD_RESOURCE_MGMT.u32All, uOtherThreadCount, NUM_ES_THREADS_shift, NUM_ES_THREADS_mask); SETfield(evergreen->evergreen_config.SQ_THREAD_RESOURCE_MGMT_2.u32All, uOtherThreadCount, NUM_PS_THREADS_shift, NUM_PS_THREADS_mask); SETfield(evergreen->evergreen_config.SQ_THREAD_RESOURCE_MGMT_2.u32All, uOtherThreadCount, NUM_VS_THREADS_shift, NUM_VS_THREADS_mask); uMaxStackEntries = ((uMaxStackEntries*1)/6); evergreen->evergreen_config.SQ_STACK_RESOURCE_MGMT_1.u32All = 0; evergreen->evergreen_config.SQ_STACK_RESOURCE_MGMT_2.u32All = 0; evergreen->evergreen_config.SQ_STACK_RESOURCE_MGMT_3.u32All = 0; SETfield(evergreen->evergreen_config.SQ_STACK_RESOURCE_MGMT_1.u32All, uMaxStackEntries, NUM_PS_STACK_ENTRIES_shift, NUM_PS_STACK_ENTRIES_mask); SETfield(evergreen->evergreen_config.SQ_STACK_RESOURCE_MGMT_1.u32All, uMaxStackEntries, NUM_VS_STACK_ENTRIES_shift, NUM_VS_STACK_ENTRIES_mask); SETfield(evergreen->evergreen_config.SQ_STACK_RESOURCE_MGMT_2.u32All, uMaxStackEntries, NUM_GS_STACK_ENTRIES_shift, NUM_GS_STACK_ENTRIES_mask); SETfield(evergreen->evergreen_config.SQ_STACK_RESOURCE_MGMT_2.u32All, uMaxStackEntries, NUM_ES_STACK_ENTRIES_shift, NUM_ES_STACK_ENTRIES_mask); SETfield(evergreen->evergreen_config.SQ_STACK_RESOURCE_MGMT_3.u32All, uMaxStackEntries, NUM_PS_STACK_ENTRIES_shift, NUM_PS_STACK_ENTRIES_mask); SETfield(evergreen->evergreen_config.SQ_STACK_RESOURCE_MGMT_3.u32All, uMaxStackEntries, NUM_VS_STACK_ENTRIES_shift, NUM_VS_STACK_ENTRIES_mask); evergreen->evergreen_config.PA_SC_FORCE_EOV_MAX_CNTS.u32All = 0; SETfield(evergreen->evergreen_config.PA_SC_FORCE_EOV_MAX_CNTS.u32All, 4095, EG_PA_SC_FORCE_EOV_MAX_CNTS__FORCE_EOV_MAX_CLK_CNT_shift, EG_PA_SC_FORCE_EOV_MAX_CNTS__FORCE_EOV_MAX_CLK_CNT_mask); SETfield(evergreen->evergreen_config.PA_SC_FORCE_EOV_MAX_CNTS.u32All, 255, EG_PA_SC_FORCE_EOV_MAX_CNTS__FORCE_EOV_MAX_REZ_CNT_shift, EG_PA_SC_FORCE_EOV_MAX_CNTS__FORCE_EOV_MAX_REZ_CNT_mask); evergreen->evergreen_config.VGT_CACHE_INVALIDATION.u32All = 0; SETfield(evergreen->evergreen_config.VGT_CACHE_INVALIDATION.u32All, 2, EG_VGT_CACHE_INVALIDATION__CACHE_INVALIDATION_shift, EG_VGT_CACHE_INVALIDATION__CACHE_INVALIDATION_mask); evergreen->evergreen_config.VGT_GS_VERTEX_REUSE.u32All = 0; SETfield(evergreen->evergreen_config.VGT_GS_VERTEX_REUSE.u32All, 16, VERT_REUSE_shift, VERT_REUSE_mask); evergreen->evergreen_config.PA_SC_LINE_STIPPLE_STATE.u32All = 0; evergreen->evergreen_config.PA_CL_ENHANCE.u32All = 0; SETbit(evergreen->evergreen_config.PA_CL_ENHANCE.u32All, CLIP_VTX_REORDER_ENA_bit); SETfield(evergreen->evergreen_config.PA_CL_ENHANCE.u32All, 3, NUM_CLIP_SEQ_shift, NUM_CLIP_SEQ_mask); } void evergreenInitState(struct gl_context * ctx) //diff { context_t *context = R700_CONTEXT(ctx); EVERGREEN_CHIP_CONTEXT *evergreen = GET_EVERGREEN_CHIP(context); int id = 0; //calloc should have done this memset(evergreen, 0, sizeof(EVERGREEN_CHIP_CONTEXT)); // Disable window clipping and offset: SETfield(evergreen->PA_SC_WINDOW_OFFSET.u32All, 0, EG_PA_SC_WINDOW_OFFSET__WINDOW_X_OFFSET_shift, EG_PA_SC_WINDOW_OFFSET__WINDOW_X_OFFSET_mask); SETfield(evergreen->PA_SC_WINDOW_OFFSET.u32All, 0, EG_PA_SC_WINDOW_OFFSET__WINDOW_Y_OFFSET_shift, EG_PA_SC_WINDOW_OFFSET__WINDOW_Y_OFFSET_mask); SETbit(evergreen->PA_SC_WINDOW_SCISSOR_TL.u32All, WINDOW_OFFSET_DISABLE_bit); evergreen->PA_SC_CLIPRECT_RULE.u32All = 0x0000FFFF; evergreen->PA_SC_EDGERULE.u32All = 0xAAAAAAAA; // Set up Z min/max: evergreen->viewport[id].PA_SC_VPORT_ZMIN_0.f32All = 0.0; evergreen->viewport[id].PA_SC_VPORT_ZMAX_0.f32All = 1.0; SETfield(evergreen->CB_TARGET_MASK.u32All, 0xF, TARGET0_ENABLE_shift, TARGET0_ENABLE_mask); SETfield(evergreen->CB_SHADER_MASK.u32All, 0xF, OUTPUT0_ENABLE_shift, OUTPUT0_ENABLE_mask); SETfield(evergreen->SPI_BARYC_CNTL.u32All, 1, EG_SPI_BARYC_CNTL__PERSP_CENTROID_ENA_shift, EG_SPI_BARYC_CNTL__PERSP_CENTROID_ENA_mask); SETfield(evergreen->SPI_BARYC_CNTL.u32All, 1, EG_SPI_BARYC_CNTL__LINEAR_CENTROID_ENA_shift, EG_SPI_BARYC_CNTL__LINEAR_CENTROID_ENA_mask); // Turn off vgt reuse: evergreen->VGT_REUSE_OFF.u32All = 0; SETbit(evergreen->VGT_REUSE_OFF.u32All, REUSE_OFF_bit); // Specify offsetting and clamp values for vertices: evergreen->VGT_MAX_VTX_INDX.u32All = 0xFFFFFF; evergreen->VGT_MIN_VTX_INDX.u32All = 0; evergreen->VGT_INDX_OFFSET.u32All = 0; evergreen->VGT_DMA_NUM_INSTANCES.u32All = 1; // Do not alpha blend: SETfield(evergreen->SX_ALPHA_TEST_CONTROL.u32All, REF_NEVER, ALPHA_FUNC_shift, ALPHA_FUNC_mask); CLEARbit(evergreen->SX_ALPHA_TEST_CONTROL.u32All, ALPHA_TEST_ENABLE_bit); evergreen->SPI_VS_OUT_ID_0.u32All = 0x03020100; evergreen->SPI_VS_OUT_ID_1.u32All = 0x07060504; evergreen->SPI_PS_INPUT_CNTL[0].u32All = 0x00000800; evergreen->SPI_PS_INPUT_CNTL[1].u32All = 0x00000801; evergreen->SPI_PS_INPUT_CNTL[2].u32All = 0x00000802; // Depth buffer currently disabled: evergreen->DB_DEPTH_CONTROL.u32All = 0; SETbit(evergreen->DB_DEPTH_CONTROL.u32All, Z_WRITE_ENABLE_bit); SETfield(evergreen->DB_DEPTH_CONTROL.u32All, FRAG_ALWAYS, ZFUNC_shift, ZFUNC_mask); evergreen->DB_Z_READ_BASE.u32All = 0; evergreen->DB_Z_WRITE_BASE.u32All = 0; evergreen->DB_DEPTH_CLEAR.f32All = 1.0; evergreen->DB_DEPTH_VIEW.u32All = 0; evergreen->DB_SHADER_CONTROL.u32All = 0; SETbit(evergreen->DB_SHADER_CONTROL.u32All, EG_DB_SHADER_CONTROL__DUAL_EXPORT_ENABLE_bit); evergreen->DB_Z_INFO.u32All = 0; SETfield(evergreen->DB_Z_INFO.u32All , ARRAY_1D_TILED_THIN1, EG_DB_Z_INFO__ARRAY_MODE_shift, EG_DB_Z_INFO__ARRAY_MODE_mask); SETfield(evergreen->DB_Z_INFO.u32All , EG_Z_24, EG_DB_Z_INFO__FORMAT_shift, EG_DB_Z_INFO__FORMAT_mask); SETfield(evergreen->DB_Z_INFO.u32All , EG_ADDR_SURF_TILE_SPLIT_256B, EG_DB_Z_INFO__TILE_SPLIT_shift, EG_DB_Z_INFO__TILE_SPLIT_mask); SETfield(evergreen->DB_Z_INFO.u32All , EG_ADDR_SURF_8_BANK, EG_DB_Z_INFO__NUM_BANKS_shift, EG_DB_Z_INFO__NUM_BANKS_mask); SETfield(evergreen->DB_Z_INFO.u32All , EG_ADDR_SURF_BANK_WIDTH_1, EG_DB_Z_INFO__BANK_WIDTH_shift, EG_DB_Z_INFO__BANK_WIDTH_mask); SETfield(evergreen->DB_Z_INFO.u32All , EG_ADDR_SURF_BANK_HEIGHT_1, EG_DB_Z_INFO__BANK_HEIGHT_shift, EG_DB_Z_INFO__BANK_HEIGHT_mask); evergreen->DB_STENCIL_INFO.u32All = 0; CLEARbit(evergreen->DB_STENCIL_INFO.u32All, EG_DB_STENCIL_INFO__FORMAT_bit); SETfield(evergreen->DB_STENCIL_INFO.u32All, 0, EG_DB_STENCIL_INFO__TILE_SPLIT_shift, EG_DB_STENCIL_INFO__TILE_SPLIT_mask); evergreen->DB_RENDER_CONTROL.u32All = 0; evergreen->DB_RENDER_OVERRIDE.u32All = 0; SETfield(evergreen->DB_RENDER_OVERRIDE.u32All, FORCE_DISABLE, FORCE_HIZ_ENABLE_shift, FORCE_HIZ_ENABLE_mask); SETfield(evergreen->DB_RENDER_OVERRIDE.u32All, FORCE_DISABLE, FORCE_HIS_ENABLE0_shift, FORCE_HIS_ENABLE0_mask); SETfield(evergreen->DB_RENDER_OVERRIDE.u32All, FORCE_DISABLE, FORCE_HIS_ENABLE1_shift, FORCE_HIS_ENABLE1_mask); /* stencil */ evergreenEnable(ctx, GL_STENCIL_TEST, ctx->Stencil._Enabled); evergreenStencilMaskSeparate(ctx, 0, ctx->Stencil.WriteMask[0]); evergreenStencilFuncSeparate(ctx, 0, ctx->Stencil.Function[0], ctx->Stencil.Ref[0], ctx->Stencil.ValueMask[0]); evergreenStencilOpSeparate(ctx, 0, ctx->Stencil.FailFunc[0], ctx->Stencil.ZFailFunc[0], ctx->Stencil.ZPassFunc[0]); // Disable ROP3 modes by setting src to dst copy: SETfield(evergreen->CB_COLOR_CONTROL.u32All, 0xCC, EG_CB_COLOR_CONTROL__ROP3_shift, EG_CB_COLOR_CONTROL__ROP3_mask); SETfield(evergreen->CB_COLOR_CONTROL.u32All, EG_CB_NORMAL, EG_CB_COLOR_CONTROL__MODE_shift, EG_CB_COLOR_CONTROL__MODE_mask); SETfield(evergreen->CB_BLEND0_CONTROL.u32All, BLEND_ONE, COLOR_SRCBLEND_shift, COLOR_SRCBLEND_mask); SETfield(evergreen->CB_BLEND0_CONTROL.u32All, BLEND_ONE, ALPHA_SRCBLEND_shift, ALPHA_SRCBLEND_mask); //evergreen->PA_CL_CLIP_CNTL.CLIP_DISABLE = 1; SETbit(evergreen->PA_CL_CLIP_CNTL.u32All, DX_LINEAR_ATTR_CLIP_ENA_bit); // Set up the culling control register: SETfield(evergreen->PA_SU_SC_MODE_CNTL.u32All, 2, POLYMODE_FRONT_PTYPE_shift, POLYMODE_FRONT_PTYPE_mask); // draw using triangles SETfield(evergreen->PA_SU_SC_MODE_CNTL.u32All, 2, POLYMODE_BACK_PTYPE_shift, POLYMODE_BACK_PTYPE_mask); // draw using triangles // Do scale XY or X by 1/W0. eg: evergreen->bEnablePerspective = GL_TRUE; CLEARbit(evergreen->PA_CL_VTE_CNTL.u32All, VTX_XY_FMT_bit); CLEARbit(evergreen->PA_CL_VTE_CNTL.u32All, VTX_Z_FMT_bit); SETbit(evergreen->PA_CL_VTE_CNTL.u32All, VTX_W0_FMT_bit); // Enable viewport scaling for all three axis: SETbit(evergreen->PA_CL_VTE_CNTL.u32All, VPORT_X_SCALE_ENA_bit); SETbit(evergreen->PA_CL_VTE_CNTL.u32All, VPORT_X_OFFSET_ENA_bit); SETbit(evergreen->PA_CL_VTE_CNTL.u32All, VPORT_Y_SCALE_ENA_bit); SETbit(evergreen->PA_CL_VTE_CNTL.u32All, VPORT_Y_OFFSET_ENA_bit); SETbit(evergreen->PA_CL_VTE_CNTL.u32All, VPORT_Z_SCALE_ENA_bit); SETbit(evergreen->PA_CL_VTE_CNTL.u32All, VPORT_Z_OFFSET_ENA_bit); // Set up point sizes and min/max values: SETfield(evergreen->PA_SU_POINT_SIZE.u32All, 0x8, PA_SU_POINT_SIZE__HEIGHT_shift, PA_SU_POINT_SIZE__HEIGHT_mask); SETfield(evergreen->PA_SU_POINT_SIZE.u32All, 0x8, PA_SU_POINT_SIZE__WIDTH_shift, PA_SU_POINT_SIZE__WIDTH_mask); CLEARfield(evergreen->PA_SU_POINT_MINMAX.u32All, MIN_SIZE_mask); SETfield(evergreen->PA_SU_POINT_MINMAX.u32All, 0x8000, MAX_SIZE_shift, MAX_SIZE_mask); SETfield(evergreen->PA_SU_LINE_CNTL.u32All,0x8, PA_SU_LINE_CNTL__WIDTH_shift, PA_SU_LINE_CNTL__WIDTH_mask); // Set up line control: evergreen->PA_SC_LINE_CNTL.u32All = 0; CLEARbit(evergreen->PA_SC_LINE_CNTL.u32All, EXPAND_LINE_WIDTH_bit); SETbit(evergreen->PA_SC_LINE_CNTL.u32All, LAST_PIXEL_bit); // Set up vertex control: evergreen->PA_SU_VTX_CNTL.u32All = 0; CLEARfield(evergreen->PA_SU_VTX_CNTL.u32All, QUANT_MODE_mask); SETbit(evergreen->PA_SU_VTX_CNTL.u32All, PIX_CENTER_bit); SETfield(evergreen->PA_SU_VTX_CNTL.u32All, X_ROUND_TO_EVEN, PA_SU_VTX_CNTL__ROUND_MODE_shift, PA_SU_VTX_CNTL__ROUND_MODE_mask); // to 1.0 = no guard band: evergreen->PA_CL_GB_VERT_CLIP_ADJ.u32All = 0x3F800000; // 1.0 evergreen->PA_CL_GB_VERT_DISC_ADJ.u32All = 0x3F800000; // 1.0 evergreen->PA_CL_GB_HORZ_CLIP_ADJ.u32All = 0x3F800000; // 1.0 evergreen->PA_CL_GB_HORZ_DISC_ADJ.u32All = 0x3F800000; // 1.0 // Diable color compares: SETfield(evergreen->CB_CLRCMP_CONTROL.u32All, CLRCMP_DRAW_ALWAYS, CLRCMP_FCN_SRC_shift, CLRCMP_FCN_SRC_mask); SETfield(evergreen->CB_CLRCMP_CONTROL.u32All, CLRCMP_DRAW_ALWAYS, CLRCMP_FCN_DST_shift, CLRCMP_FCN_DST_mask); SETfield(evergreen->CB_CLRCMP_CONTROL.u32All, CLRCMP_SEL_SRC, CLRCMP_FCN_SEL_shift, CLRCMP_FCN_SEL_mask); // Zero out source: evergreen->CB_CLRCMP_SRC.u32All = 0x00000000; // Put a compare color in for error checking: evergreen->CB_CLRCMP_DST.u32All = 0x000000FF; // Set up color compare mask: evergreen->CB_CLRCMP_MSK.u32All = 0xFFFFFFFF; // Enable all samples for multi-sample anti-aliasing: evergreen->PA_SC_AA_MASK.u32All = 0xFFFFFFFF; // Turn off AA: evergreen->PA_SC_AA_CONFIG.u32All = 0; SETfield(evergreen->VGT_OUT_DEALLOC_CNTL.u32All, 16, DEALLOC_DIST_shift, DEALLOC_DIST_mask); SETfield(evergreen->VGT_VERTEX_REUSE_BLOCK_CNTL.u32All, 14, VTX_REUSE_DEPTH_shift, VTX_REUSE_DEPTH_mask); evergreen->SX_MISC.u32All = 0; SETfield(evergreen->render_target[id].CB_COLOR0_INFO.u32All, 1, EG_CB_COLOR0_INFO__SOURCE_FORMAT_shift, EG_CB_COLOR0_INFO__SOURCE_FORMAT_mask); SETbit(evergreen->render_target[id].CB_COLOR0_INFO.u32All, EG_CB_COLOR0_INFO__BLEND_CLAMP_bit); SETfield(evergreen->render_target[id].CB_COLOR0_INFO.u32All, 0, EG_CB_COLOR0_INFO__NUMBER_TYPE_shift, EG_CB_COLOR0_INFO__NUMBER_TYPE_mask); SETfield(evergreen->render_target[id].CB_COLOR0_INFO.u32All, SWAP_STD, EG_CB_COLOR0_INFO__COMP_SWAP_shift, EG_CB_COLOR0_INFO__COMP_SWAP_mask); evergreen->render_target[id].CB_COLOR0_VIEW.u32All = 0; evergreen->render_target[id].CB_COLOR0_CMASK.u32All = 0; evergreen->render_target[id].CB_COLOR0_FMASK.u32All = 0; evergreen->render_target[id].CB_COLOR0_FMASK_SLICE.u32All = 0; evergreenInitSQConfig(ctx); context->radeon.hw.all_dirty = GL_TRUE; } void evergreenInitStateFuncs(radeonContextPtr radeon, struct dd_function_table *functions) { functions->UpdateState = evergreenInvalidateState; functions->AlphaFunc = evergreenAlphaFunc; functions->BlendColor = evergreenBlendColor; functions->BlendEquationSeparate = evergreenBlendEquationSeparate; functions->BlendFuncSeparate = evergreenBlendFuncSeparate; functions->Enable = evergreenEnable; functions->ColorMask = evergreenColorMask; functions->DepthFunc = evergreenDepthFunc; functions->DepthMask = evergreenDepthMask; functions->CullFace = evergreenCullFace; functions->Fogfv = evergreenFogfv; functions->FrontFace = evergreenFrontFace; functions->ShadeModel = evergreenShadeModel; functions->LogicOpcode = evergreenLogicOpcode; /* ARB_point_parameters */ functions->PointParameterfv = evergreenPointParameter; /* Stencil related */ functions->StencilFuncSeparate = evergreenStencilFuncSeparate; functions->StencilMaskSeparate = evergreenStencilMaskSeparate; functions->StencilOpSeparate = evergreenStencilOpSeparate; /* Viewport related */ functions->Viewport = evergreenViewport; functions->DepthRange = evergreenDepthRange; functions->PointSize = evergreenPointSize; functions->LineWidth = evergreenLineWidth; functions->LineStipple = evergreenLineStipple; functions->PolygonOffset = evergreenPolygonOffset; functions->PolygonMode = evergreenPolygonMode; functions->RenderMode = evergreenRenderMode; functions->ClipPlane = evergreenClipPlane; functions->Scissor = radeonScissor; functions->DrawBuffer = radeonDrawBuffer; functions->ReadBuffer = radeonReadBuffer; if (radeon->radeonScreen->kernel_mm) { functions->CopyPixels = _mesa_meta_CopyPixels; functions->DrawPixels = _mesa_meta_DrawPixels; functions->ReadPixels = radeonReadPixels; } }