Merge branch 'master' of git+ssh://keithw@git.freedesktop.org/git/mesa/mesa into vbo-0.2

Conflicts:

	src/mesa/array_cache/sources
	src/mesa/drivers/dri/i965/brw_context.c
	src/mesa/drivers/dri/i965/brw_draw.c
	src/mesa/drivers/dri/i965/brw_fallback.c
	src/mesa/drivers/dri/i965/brw_vs_emit.c
	src/mesa/drivers/dri/i965/brw_vs_tnl.c
	src/mesa/drivers/dri/mach64/mach64_context.c
	src/mesa/main/extensions.c
	src/mesa/main/getstring.c
	src/mesa/tnl/sources
	src/mesa/tnl/t_save_api.c
	src/mesa/tnl/t_save_playback.c
	src/mesa/tnl/t_vtx_api.c
	src/mesa/tnl/t_vtx_exec.c
	src/mesa/vbo/vbo_attrib.h
	src/mesa/vbo/vbo_exec_api.c
	src/mesa/vbo/vbo_save_api.c
	src/mesa/vbo/vbo_save_draw.c

11 files changed, 355 insertions, 84 deletions

diff --git a/src/mesa/drivers/dri/r200/.gitignore b/src/mesa/drivers/dri/r200/.gitignore
new file mode 100644
index 0000000000..3773d8ea73
--- /dev/null
+++ b/src/mesa/drivers/dri/r200/.gitignore
@@ -0,0 +1,3 @@
+radeon_chipset.h
+radeon_screen.*
+server
diff --git a/src/mesa/drivers/dri/r200/r200_context.c b/src/mesa/drivers/dri/r200/r200_context.c
index a1533d7f3e..fc6eb93daa 100644
--- a/src/mesa/drivers/dri/r200/r200_context.c
+++ b/src/mesa/drivers/dri/r200/r200_context.c
@@ -86,21 +86,6 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 int R200_DEBUG = (0);
 #endif
 
-
-/* Return the width and height of the given buffer.
- */
-static void r200GetBufferSize( GLframebuffer *buffer,
-			       GLuint *width, GLuint *height )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   r200ContextPtr rmesa = R200_CONTEXT(ctx);
-
-   LOCK_HARDWARE( rmesa );
-   *width  = rmesa->dri.drawable->w;
-   *height = rmesa->dri.drawable->h;
-   UNLOCK_HARDWARE( rmesa );
-}
-
 /* Return various strings for glGetString().
  */
 static const GLubyte *r200GetString( GLcontext *ctx, GLenum name )
@@ -232,12 +217,8 @@ static const struct tnl_pipeline_stage *r200_pipeline[] = {
  */
 static void r200InitDriverFuncs( struct dd_function_table *functions )
 {
-    functions->GetBufferSize		= r200GetBufferSize;
+    functions->GetBufferSize		= NULL; /* OBSOLETE */
     functions->GetString		= r200GetString;
-
-    functions->Error			= NULL;
-    functions->DrawPixels		= NULL;
-    functions->Bitmap			= NULL;
 }
 
 static const struct dri_debug_control debug_control[] =
@@ -690,7 +671,13 @@ r200MakeCurrent( __DRIcontextPrivate *driContextPriv,
       if ( newCtx->dri.drawable != driDrawPriv ) {
 	 driDrawableInitVBlank( driDrawPriv, newCtx->vblank_flags,
 				&newCtx->vbl_seq );
+      }
+
+      if ( newCtx->dri.drawable != driDrawPriv ||
+           newCtx->dri.readable != driReadPriv ) {
 	 newCtx->dri.drawable = driDrawPriv;
+	 newCtx->dri.readable = driReadPriv;
+
 	 r200UpdateWindow( newCtx->glCtx );
 	 r200UpdateViewportOffset( newCtx->glCtx );
       }
diff --git a/src/mesa/drivers/dri/r200/r200_context.h b/src/mesa/drivers/dri/r200/r200_context.h
index 07b6d6e12d..44c67b68cb 100644
--- a/src/mesa/drivers/dri/r200/r200_context.h
+++ b/src/mesa/drivers/dri/r200/r200_context.h
@@ -107,6 +107,8 @@ struct r200_vertex_program {
         VERTEX_SHADER_INSTRUCTION instr[R200_VSF_MAX_INST + 6];
         int pos_end;
         int inputs[VERT_ATTRIB_MAX];
+        int rev_inputs[16];
+        int gen_inputs_mapped;
         int native;
         int fogpidx;
         int fogmode;
@@ -699,6 +701,7 @@ struct r200_dri_mirror {
    __DRIcontextPrivate	*context;	/* DRI context */
    __DRIscreenPrivate	*screen;	/* DRI screen */
    __DRIdrawablePrivate	*drawable;	/* DRI drawable bound to this ctx */
+   __DRIdrawablePrivate	*readable;	/* DRI readable bound to this ctx */
 
    drm_context_t hwContext;
    drm_hw_lock_t *hwLock;
@@ -725,19 +728,21 @@ struct r200_tcl_info {
    GLint last_offset;
    GLuint hw_primitive;
 
-/* FIXME: what's the maximum number of components? */
-   struct r200_dma_region *aos_components[11];
+/* hw can handle 12 components max */
+   struct r200_dma_region *aos_components[12];
    GLuint nr_aos_components;
 
    GLuint *Elts;
 
    struct r200_dma_region indexed_verts;
+   struct r200_dma_region weight;
    struct r200_dma_region obj;
    struct r200_dma_region rgba;
    struct r200_dma_region spec;
    struct r200_dma_region fog;
    struct r200_dma_region tex[R200_MAX_TEXTURE_UNITS];
    struct r200_dma_region norm;
+   struct r200_dma_region generic[16];
 };
 
 
diff --git a/src/mesa/drivers/dri/r200/r200_fragshader.c b/src/mesa/drivers/dri/r200/r200_fragshader.c
index 7993e3015a..5dd3adaef6 100644
--- a/src/mesa/drivers/dri/r200/r200_fragshader.c
+++ b/src/mesa/drivers/dri/r200/r200_fragshader.c
@@ -132,10 +132,10 @@ static void r200UpdateFSArith( GLcontext *ctx )
    R200_STATECHANGE( rmesa, afs[1] );
 
    if (shader->NumPasses < 2) {
-      afs_cmd = rmesa->hw.afs[1].cmd;
+      afs_cmd = (GLuint *) rmesa->hw.afs[1].cmd;
    }
    else {
-      afs_cmd = rmesa->hw.afs[0].cmd;
+      afs_cmd = (GLuint *) rmesa->hw.afs[0].cmd;
    }
    for (pass = 0; pass < shader->NumPasses; pass++) {
       GLuint opnum = 0;
@@ -317,7 +317,7 @@ static void r200UpdateFSArith( GLcontext *ctx )
 		SET_INST(opnum, 1), SET_INST_2(opnum, 1));*/
          opnum++;
       }
-      afs_cmd = rmesa->hw.afs[1].cmd;
+      afs_cmd = (GLuint *) rmesa->hw.afs[1].cmd;
    }
    rmesa->afs_loaded = ctx->ATIFragmentShader.Current;
 }
@@ -362,7 +362,7 @@ static void r200UpdateFSRouting( GLcontext *ctx ) {
 
    if (shader->NumPasses < 2) {
       for (reg = 0; reg < R200_MAX_TEXTURE_UNITS; reg++) {
-	 struct gl_texture_object *texObj = ctx->Texture.Unit[reg]._Current;
+	 GLbitfield targetbit = ctx->Texture.Unit[reg]._ReallyEnabled;
          R200_STATECHANGE( rmesa, tex[reg] );
 	 rmesa->hw.tex[reg].cmd[TEX_PP_TXMULTI_CTL] = 0;
 	 if (shader->SetupInst[0][reg].Opcode) {
@@ -385,15 +385,16 @@ static void r200UpdateFSRouting( GLcontext *ctx ) {
 	       else {
 		  txformat_x |= R200_TEXCOORD_PROJ;
 	       }
+	       rmesa->hw.ctx.cmd[CTX_PP_CNTL] |= R200_TEX_0_ENABLE << reg;
 	    }
-	    else if (texObj->Target == GL_TEXTURE_3D) {
+	    else if (targetbit == TEXTURE_3D_BIT) {
 	       txformat_x |= R200_TEXCOORD_VOLUME;
 	    }
-	    else if (texObj->Target == GL_TEXTURE_CUBE_MAP) {
+	    else if (targetbit == TEXTURE_CUBE_BIT) {
 	       txformat_x |= R200_TEXCOORD_CUBIC_ENV;
 	    }
 	    else if (shader->SetupInst[0][reg].swizzle == GL_SWIZZLE_STR_ATI ||
-		shader->SetupInst[0][reg].swizzle == GL_SWIZZLE_STQ_ATI) {
+	       shader->SetupInst[0][reg].swizzle == GL_SWIZZLE_STQ_ATI) {
 	       txformat_x |= R200_TEXCOORD_NONPROJ;
 	    }
 	    else {
@@ -401,16 +402,16 @@ static void r200UpdateFSRouting( GLcontext *ctx ) {
 	    }
 	    rmesa->hw.tex[reg].cmd[TEX_PP_TXFORMAT] = txformat;
 	    rmesa->hw.tex[reg].cmd[TEX_PP_TXFORMAT_X] = txformat_x;
-	    /* is this a good idea? Could potentially sample from not enabled unit.
-	       results are probably undefined anyway (?) but I hope it doesn't lock up... */
-	    rmesa->hw.ctx.cmd[CTX_PP_CNTL] |= R200_TEX_0_ENABLE << reg;
+	    /* enabling texturing when unit isn't correctly configured may not be safe */
+	    if (targetbit)
+	       rmesa->hw.ctx.cmd[CTX_PP_CNTL] |= R200_TEX_0_ENABLE << reg;
 	 }
       }
 
    } else {
       /* setup 1st pass */
       for (reg = 0; reg < R200_MAX_TEXTURE_UNITS; reg++) {
-	 struct gl_texture_object *texObj = ctx->Texture.Unit[reg]._Current;
+	 GLbitfield targetbit = ctx->Texture.Unit[reg]._ReallyEnabled;
 	 R200_STATECHANGE( rmesa, tex[reg] );
 	 GLuint txformat_multi = 0;
 	 if (shader->SetupInst[0][reg].Opcode) {
@@ -425,11 +426,12 @@ static void r200UpdateFSRouting( GLcontext *ctx ) {
 	       else {
 		  txformat_multi |= R200_PASS1_TEXCOORD_PROJ;
 	       }
+	       rmesa->hw.cst.cmd[CST_PP_CNTL_X] |= R200_PPX_TEX_0_ENABLE << reg;
 	    }
-	    else if (texObj->Target == GL_TEXTURE_3D) {
+	    else if (targetbit == TEXTURE_3D_BIT) {
 	       txformat_multi |= R200_PASS1_TEXCOORD_VOLUME;
 	    }
-	    else if (texObj->Target == GL_TEXTURE_CUBE_MAP) {
+	    else if (targetbit == TEXTURE_CUBE_BIT) {
 	       txformat_multi |= R200_PASS1_TEXCOORD_CUBIC_ENV;
 	    }
 	    else if (shader->SetupInst[0][reg].swizzle == GL_SWIZZLE_STR_ATI ||
@@ -439,14 +441,15 @@ static void r200UpdateFSRouting( GLcontext *ctx ) {
 	    else {
 	       txformat_multi |= R200_PASS1_TEXCOORD_PROJ;
 	    }
-	    rmesa->hw.cst.cmd[CST_PP_CNTL_X] |= R200_PPX_TEX_0_ENABLE << reg;
+	    if (targetbit)
+	       rmesa->hw.cst.cmd[CST_PP_CNTL_X] |= R200_PPX_TEX_0_ENABLE << reg;
 	 }
          rmesa->hw.tex[reg].cmd[TEX_PP_TXMULTI_CTL] = txformat_multi;
       }
 
       /* setup 2nd pass */
       for (reg=0; reg < R200_MAX_TEXTURE_UNITS; reg++) {
-	 struct gl_texture_object *texObj = ctx->Texture.Unit[reg]._Current;
+	 GLbitfield targetbit = ctx->Texture.Unit[reg]._ReallyEnabled;
 	 if (shader->SetupInst[1][reg].Opcode) {
 	    GLuint coord = shader->SetupInst[1][reg].src;
 	    GLuint txformat = rmesa->hw.tex[reg].cmd[TEX_PP_TXFORMAT]
@@ -463,15 +466,16 @@ static void r200UpdateFSRouting( GLcontext *ctx ) {
 	       else {
 		  txformat_x |= R200_TEXCOORD_PROJ;
 	       }
+	       rmesa->hw.ctx.cmd[CTX_PP_CNTL] |= R200_TEX_0_ENABLE << reg;
 	    }
-	    else if (texObj->Target == GL_TEXTURE_3D) {
+	    else if (targetbit == TEXTURE_3D_BIT) {
 	       txformat_x |= R200_TEXCOORD_VOLUME;
 	    }
-	    else if (texObj->Target == GL_TEXTURE_CUBE_MAP) {
+	    else if (targetbit == TEXTURE_CUBE_BIT) {
 	       txformat_x |= R200_TEXCOORD_CUBIC_ENV;
 	    }
 	    else if (shader->SetupInst[1][reg].swizzle == GL_SWIZZLE_STR_ATI ||
-		shader->SetupInst[1][reg].swizzle == GL_SWIZZLE_STQ_ATI) {
+	       shader->SetupInst[1][reg].swizzle == GL_SWIZZLE_STQ_ATI) {
 	       txformat_x |= R200_TEXCOORD_NONPROJ;
 	    }
 	    else {
@@ -488,7 +492,8 @@ static void r200UpdateFSRouting( GLcontext *ctx ) {
 	    }
 	    rmesa->hw.tex[reg].cmd[TEX_PP_TXFORMAT_X] = txformat_x;
 	    rmesa->hw.tex[reg].cmd[TEX_PP_TXFORMAT] = txformat;
-	    rmesa->hw.ctx.cmd[CTX_PP_CNTL] |= R200_TEX_0_ENABLE << reg;
+	    if (targetbit)
+	       rmesa->hw.ctx.cmd[CTX_PP_CNTL] |= R200_TEX_0_ENABLE << reg;
 	 }
       }
    }
diff --git a/src/mesa/drivers/dri/r200/r200_lock.c b/src/mesa/drivers/dri/r200/r200_lock.c
index 66bb075864..bcc0c91639 100644
--- a/src/mesa/drivers/dri/r200/r200_lock.c
+++ b/src/mesa/drivers/dri/r200/r200_lock.c
@@ -69,7 +69,8 @@ r200UpdatePageFlipping( r200ContextPtr rmesa )
  */
 void r200GetLock( r200ContextPtr rmesa, GLuint flags )
 {
-   __DRIdrawablePrivate *dPriv = rmesa->dri.drawable;
+   __DRIdrawablePrivate *drawable = rmesa->dri.drawable;
+   __DRIdrawablePrivate *readable = rmesa->dri.readable;
    __DRIscreenPrivate *sPriv = rmesa->dri.screen;
    drm_radeon_sarea_t *sarea = rmesa->sarea;
    int i;
@@ -84,17 +85,20 @@ void r200GetLock( r200ContextPtr rmesa, GLuint flags )
     * Since the hardware state depends on having the latest drawable
     * clip rects, all state checking must be done _after_ this call.
     */
-   DRI_VALIDATE_DRAWABLE_INFO( sPriv, dPriv );
+   DRI_VALIDATE_DRAWABLE_INFO( sPriv, drawable );
+   if (drawable != readable) {
+      DRI_VALIDATE_DRAWABLE_INFO( sPriv, readable );
+   }
 
-   if ( rmesa->lastStamp != dPriv->lastStamp ) {
+   if ( rmesa->lastStamp != drawable->lastStamp ) {
       r200UpdatePageFlipping( rmesa );
       if (rmesa->glCtx->DrawBuffer->_ColorDrawBufferMask[0] == BUFFER_BIT_BACK_LEFT)
          r200SetCliprects( rmesa, GL_BACK_LEFT );
       else
          r200SetCliprects( rmesa, GL_FRONT_LEFT );
       r200UpdateViewportOffset( rmesa->glCtx );
-      driUpdateFramebufferSize(rmesa->glCtx, dPriv);
-      rmesa->lastStamp = dPriv->lastStamp;
+      driUpdateFramebufferSize(rmesa->glCtx, drawable);
+      rmesa->lastStamp = drawable->lastStamp;
    }
 
    R200_STATECHANGE( rmesa, ctx );
diff --git a/src/mesa/drivers/dri/r200/r200_maos_arrays.c b/src/mesa/drivers/dri/r200/r200_maos_arrays.c
index 92348c90ca..270dc35a46 100644
--- a/src/mesa/drivers/dri/r200/r200_maos_arrays.c
+++ b/src/mesa/drivers/dri/r200/r200_maos_arrays.c
@@ -385,8 +385,16 @@ void r200EmitArrays( GLcontext *ctx, GLuint inputs )
    GLuint vfmt0 = 0, vfmt1 = 0;
    GLuint count = VB->Count;
    GLuint i;
-   
-   if (1) {
+   GLuint generic_in_mapped = 0;
+   struct r200_vertex_program *vp = NULL;
+
+   /* this looks way more complicated than necessary... */
+   if (ctx->VertexProgram._Enabled) {
+      vp = rmesa->curr_vp_hw;
+      generic_in_mapped = vp->gen_inputs_mapped;
+   }
+
+   if (inputs & VERT_BIT_POS) {
       if (!rmesa->tcl.obj.buf) 
 	 emit_vector( ctx, 
 		      &rmesa->tcl.obj, 
@@ -404,7 +412,33 @@ void r200EmitArrays( GLcontext *ctx, GLuint inputs )
       }
       component[nr++] = &rmesa->tcl.obj;
    }
-   
+   else if (generic_in_mapped & (1 << 0)) {
+      int geninput = vp->rev_inputs[0] - VERT_ATTRIB_GENERIC0;
+      if (!rmesa->tcl.generic[geninput].buf) {
+         emit_vector( ctx,
+		      &(rmesa->tcl.generic[geninput]),
+		      (char *)VB->AttribPtr[geninput + VERT_ATTRIB_GENERIC0]->data,
+		      4,
+		      VB->AttribPtr[geninput + VERT_ATTRIB_GENERIC0]->stride,
+		      count );
+      }
+      component[nr++] = &rmesa->tcl.generic[geninput];
+      vfmt0 |= R200_VTX_W0 | R200_VTX_Z0;
+   }
+
+   if (inputs & VERT_BIT_WEIGHT) {
+      if (!rmesa->tcl.weight.buf)
+	 emit_vector( ctx, 
+		      &rmesa->tcl.weight, 
+		      (char *)VB->AttribPtr[VERT_ATTRIB_WEIGHT]->data,
+		      VB->AttribPtr[VERT_ATTRIB_WEIGHT]->size,
+		      VB->AttribPtr[VERT_ATTRIB_WEIGHT]->stride,
+		      count);
+
+      assert(VB->AttribPtr[VERT_ATTRIB_WEIGHT]->size <= 4);
+      vfmt0 |= VB->AttribPtr[VERT_ATTRIB_WEIGHT]->size << R200_VTX_WEIGHT_COUNT_SHIFT;
+      component[nr++] = &rmesa->tcl.weight;
+   }
 
    if (inputs & VERT_BIT_NORMAL) {
       if (!rmesa->tcl.norm.buf)
@@ -464,6 +498,23 @@ void r200EmitArrays( GLcontext *ctx, GLuint inputs )
 
       component[nr++] = &rmesa->tcl.rgba;
    }
+/*	vfmt0 |= R200_VTX_PK_RGBA << R200_VTX_COLOR_0_SHIFT;
+	emit_ubyte_rgba( ctx, &rmesa->tcl.rgba, 
+		(char *)VB->ColorPtr[0]->data, 4,
+		      VB->ColorPtr[0]->stride, count);*/
+   else if (generic_in_mapped & (1 << 2)) {
+      int geninput = vp->rev_inputs[2] - VERT_ATTRIB_GENERIC0;
+      if (!rmesa->tcl.generic[geninput].buf) {
+         emit_vector( ctx,
+		      &(rmesa->tcl.generic[geninput]),
+		      (char *)VB->AttribPtr[geninput + VERT_ATTRIB_GENERIC0]->data,
+		      4,
+		      VB->AttribPtr[geninput + VERT_ATTRIB_GENERIC0]->stride,
+		      count );
+      }
+      component[nr++] = &rmesa->tcl.generic[geninput];
+      vfmt0 |= R200_VTX_FP_RGBA << R200_VTX_COLOR_0_SHIFT;
+   }
 
 
    if (inputs & VERT_BIT_COLOR1) {
@@ -481,8 +532,49 @@ void r200EmitArrays( GLcontext *ctx, GLuint inputs )
       vfmt0 |= R200_VTX_FP_RGB << R200_VTX_COLOR_1_SHIFT; 
       component[nr++] = &rmesa->tcl.spec;
    }
-      
-   for ( i = 0 ; i < ctx->Const.MaxTextureUnits ; i++ ) {
+   else if (generic_in_mapped & (1 << 3)) {
+      int geninput = vp->rev_inputs[3] - VERT_ATTRIB_GENERIC0;
+      if (!rmesa->tcl.generic[geninput].buf) {
+         emit_vector( ctx,
+		      &(rmesa->tcl.generic[geninput]),
+		      (char *)VB->AttribPtr[geninput + VERT_ATTRIB_GENERIC0]->data,
+		      4,
+		      VB->AttribPtr[geninput + VERT_ATTRIB_GENERIC0]->stride,
+		      count );
+      }
+      component[nr++] = &rmesa->tcl.generic[geninput];
+      vfmt0 |= R200_VTX_FP_RGBA << R200_VTX_COLOR_1_SHIFT;
+   }
+
+   if (generic_in_mapped & (1 << 4)) {
+      int geninput = vp->rev_inputs[4] - VERT_ATTRIB_GENERIC0;
+      if (!rmesa->tcl.generic[geninput].buf) {
+         emit_vector( ctx,
+		      &(rmesa->tcl.generic[geninput]),
+		      (char *)VB->AttribPtr[geninput + VERT_ATTRIB_GENERIC0]->data,
+		      4,
+		      VB->AttribPtr[geninput + VERT_ATTRIB_GENERIC0]->stride,
+		      count );
+      }
+      component[nr++] = &rmesa->tcl.generic[geninput];
+      vfmt0 |= R200_VTX_FP_RGBA << R200_VTX_COLOR_2_SHIFT;
+   }
+
+   if (generic_in_mapped & (1 << 5)) {
+      int geninput = vp->rev_inputs[5] - VERT_ATTRIB_GENERIC0;
+      if (!rmesa->tcl.generic[geninput].buf) {
+         emit_vector( ctx,
+		      &(rmesa->tcl.generic[geninput]),
+		      (char *)VB->AttribPtr[geninput + VERT_ATTRIB_GENERIC0]->data,
+		      4,
+		      VB->AttribPtr[geninput + VERT_ATTRIB_GENERIC0]->stride,
+		      count );
+      }
+      component[nr++] = &rmesa->tcl.generic[geninput];
+      vfmt0 |= R200_VTX_FP_RGBA << R200_VTX_COLOR_3_SHIFT;
+   }
+
+   for ( i = 0 ; i < 6 ; i++ ) {
       if (inputs & (VERT_BIT_TEX0 << i)) {
 	 if (!rmesa->tcl.tex[i].buf)
 	     emit_vector( ctx, 
@@ -495,8 +587,82 @@ void r200EmitArrays( GLcontext *ctx, GLuint inputs )
 	 vfmt1 |= VB->TexCoordPtr[i]->size << (i * 3);
 	 component[nr++] = &rmesa->tcl.tex[i];
       }
+      else if (generic_in_mapped & (1 << (i + 6))) {
+	 int geninput = vp->rev_inputs[i + 6] - VERT_ATTRIB_GENERIC0;
+	 if (!rmesa->tcl.generic[geninput].buf) {
+            emit_vector( ctx,
+			 &(rmesa->tcl.generic[geninput]),
+			(char *)VB->AttribPtr[geninput + VERT_ATTRIB_GENERIC0]->data,
+			4,
+			VB->AttribPtr[geninput + VERT_ATTRIB_GENERIC0]->stride,
+			count );
+	 }
+	 component[nr++] = &rmesa->tcl.generic[geninput];
+	 vfmt1 |= 4 << (R200_VTX_TEX0_COMP_CNT_SHIFT + (i * 3));
+      }
    }
 
+   if (generic_in_mapped & (1 << 13)) {
+      int geninput = vp->rev_inputs[13] - VERT_ATTRIB_GENERIC0;
+      if (!rmesa->tcl.generic[geninput].buf) {
+         emit_vector( ctx,
+		      &(rmesa->tcl.generic[geninput]),
+		      (char *)VB->AttribPtr[geninput + VERT_ATTRIB_GENERIC0]->data,
+		      4,
+		      VB->AttribPtr[geninput + VERT_ATTRIB_GENERIC0]->stride,
+		      count );
+      }
+      component[nr++] = &rmesa->tcl.generic[geninput];
+      vfmt0 |= R200_VTX_XY1 | R200_VTX_Z1 | R200_VTX_W1;
+   }
+
+/* doesn't work. Wrong order with mixed generic & conventional! */
+/*
+   if (ctx->VertexProgram._Enabled) {
+      int *vp_inputs = rmesa->curr_vp_hw->inputs;
+      for ( i = VERT_ATTRIB_GENERIC0; i < VERT_ATTRIB_MAX; i++ ) {
+	 if (inputs & (1 << i)) {
+	    int geninput = i - VERT_ATTRIB_GENERIC0;
+	    if (!rmesa->tcl.generic[geninput].buf) {
+	       emit_vector( ctx,
+			  &(rmesa->tcl.generic[geninput]),
+			  (char *)VB->AttribPtr[i]->data,
+			  4,
+			  VB->AttribPtr[i]->stride,
+			  count );
+	    }
+	    component[nr++] = &rmesa->tcl.generic[geninput];
+	    switch (vp_inputs[i]) {
+	    case 0:
+	       vfmt0 |=  R200_VTX_W0 | R200_VTX_Z0;
+	       break;
+	    case 2:
+	    case 3:
+	    case 4:
+	    case 5:
+	       vfmt0 |= R200_VTX_FP_RGBA << (R200_VTX_COLOR_0_SHIFT + (vp_inputs[i] - 2) * 2);
+	       break;
+	    case 6:
+	    case 7:
+	    case 8:
+	    case 9:
+	    case 10:
+	    case 11:
+	       vfmt1 |= 4 << (R200_VTX_TEX0_COMP_CNT_SHIFT + (vp_inputs[i] - 6) * 3);
+	       break;
+	    case 13:
+	       vfmt0 |= R200_VTX_XY1 | R200_VTX_Z1 | R200_VTX_W1;
+	       break;
+	    case 1:
+	    case 12:
+	    default:
+	       assert(0);
+	    }
+	 }
+      }
+   }
+*/
+
    if (vfmt0 != rmesa->hw.vtx.cmd[VTX_VTXFMT_0] ||
        vfmt1 != rmesa->hw.vtx.cmd[VTX_VTXFMT_1]) { 
       R200_STATECHANGE( rmesa, vtx ); 
@@ -520,9 +686,12 @@ void r200ReleaseArrays( GLcontext *ctx, GLuint newinputs )
    if (newinputs & VERT_BIT_POS) 
      r200ReleaseDmaRegion( rmesa, &rmesa->tcl.obj, __FUNCTION__ );
 
+   if (newinputs & VERT_BIT_WEIGHT) 
+     r200ReleaseDmaRegion( rmesa, &rmesa->tcl.weight, __FUNCTION__ );
+
    if (newinputs & VERT_BIT_NORMAL) 
       r200ReleaseDmaRegion( rmesa, &rmesa->tcl.norm, __FUNCTION__ );
-      
+
    if (newinputs & VERT_BIT_FOG) 
       r200ReleaseDmaRegion( rmesa, &rmesa->tcl.fog, __FUNCTION__ );
 
@@ -536,4 +705,14 @@ void r200ReleaseArrays( GLcontext *ctx, GLuint newinputs )
       if (newinputs & VERT_BIT_TEX(unit))
 	 r200ReleaseDmaRegion( rmesa, &rmesa->tcl.tex[unit], __FUNCTION__ );
    }
+
+   if (ctx->VertexProgram._Enabled) {
+      int i;
+      for (i = VERT_ATTRIB_GENERIC0; i < VERT_ATTRIB_MAX; i++) {
+	 if (newinputs & (1 << i))
+	    r200ReleaseDmaRegion( rmesa,
+	       &rmesa->tcl.generic[i - VERT_ATTRIB_GENERIC0], __FUNCTION__ );
+      }
+   }
+
 }
diff --git a/src/mesa/drivers/dri/r200/r200_sanity.c b/src/mesa/drivers/dri/r200/r200_sanity.c
index ca5b926a94..3f2a866530 100644
--- a/src/mesa/drivers/dri/r200/r200_sanity.c
+++ b/src/mesa/drivers/dri/r200/r200_sanity.c
@@ -978,7 +978,7 @@ static int radeon_emit_veclinear(
       }
    }
    else if ((start >= 0x180) && (start < 0x1c0)) {
-      for (i = start ; (i < start + sz) ;  i += 4) {
+      for (i = 0 ; i < sz ;  i += 4) {
 	 fprintf(stderr, "R200_VS_PROG %d OPDST %08x\n", (i >> 2) + start - 0x180 + 0x40, data[i]);
 	 fprintf(stderr, "R200_VS_PROG %d SRC1  %08x\n", (i >> 2) + start - 0x180 + 0x40, data[i+1]);
 	 fprintf(stderr, "R200_VS_PROG %d SRC2  %08x\n", (i >> 2) + start - 0x180 + 0x40, data[i+2]);
diff --git a/src/mesa/drivers/dri/r200/r200_state.c b/src/mesa/drivers/dri/r200/r200_state.c
index e68f1e30f3..bab767838d 100644
--- a/src/mesa/drivers/dri/r200/r200_state.c
+++ b/src/mesa/drivers/dri/r200/r200_state.c
@@ -40,6 +40,7 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include "enums.h"
 #include "colormac.h"
 #include "light.h"
+#include "framebuffer.h"
 
 #include "swrast/swrast.h"
 #include "vbo/vbo.h"
@@ -1844,23 +1845,26 @@ static void r200LogicOpCode( GLcontext *ctx, GLenum opcode )
 
 void r200SetCliprects( r200ContextPtr rmesa, GLenum mode )
 {
-   __DRIdrawablePrivate *dPriv = rmesa->dri.drawable;
+   __DRIdrawablePrivate *const drawable = rmesa->dri.drawable;
+   __DRIdrawablePrivate *const readable = rmesa->dri.readable;
+   GLframebuffer *const draw_fb = (GLframebuffer*) drawable->driverPrivate;
+   GLframebuffer *const read_fb = (GLframebuffer*) readable->driverPrivate;
 
    switch ( mode ) {
    case GL_FRONT_LEFT:
-      rmesa->numClipRects = dPriv->numClipRects;
-      rmesa->pClipRects = dPriv->pClipRects;
+      rmesa->numClipRects = drawable->numClipRects;
+      rmesa->pClipRects = drawable->pClipRects;
       break;
    case GL_BACK_LEFT:
       /* Can't ignore 2d windows if we are page flipping.
        */
-      if ( dPriv->numBackClipRects == 0 || rmesa->doPageFlip ) {
-	 rmesa->numClipRects = dPriv->numClipRects;
-	 rmesa->pClipRects = dPriv->pClipRects;
+      if ( drawable->numBackClipRects == 0 || rmesa->doPageFlip ) {
+         rmesa->numClipRects = drawable->numClipRects;
+         rmesa->pClipRects = drawable->pClipRects;
       }
       else {
-	 rmesa->numClipRects = dPriv->numBackClipRects;
-	 rmesa->pClipRects = dPriv->pBackClipRects;
+         rmesa->numClipRects = drawable->numBackClipRects;
+         rmesa->pClipRects = drawable->pBackClipRects;
       }
       break;
    default:
@@ -1868,6 +1872,21 @@ void r200SetCliprects( r200ContextPtr rmesa, GLenum mode )
       return;
    }
 
+   if ((draw_fb->Width != drawable->w) || (draw_fb->Height != drawable->h)) {
+      _mesa_resize_framebuffer(rmesa->glCtx, draw_fb,
+			       drawable->w, drawable->h);
+      draw_fb->Initialized = GL_TRUE;
+   }
+
+   if (drawable != readable) {
+      if ((read_fb->Width != readable->w) ||
+	  (read_fb->Height != readable->h)) {
+	 _mesa_resize_framebuffer(rmesa->glCtx, read_fb,
+				  readable->w, readable->h);
+	 read_fb->Initialized = GL_TRUE;
+      }
+   }
+
    if (rmesa->state.scissor.enabled)
       r200RecalcScissorRects( rmesa );
 }
diff --git a/src/mesa/drivers/dri/r200/r200_tcl.c b/src/mesa/drivers/dri/r200/r200_tcl.c
index 0b3bb281e0..62c335a707 100644
--- a/src/mesa/drivers/dri/r200/r200_tcl.c
+++ b/src/mesa/drivers/dri/r200/r200_tcl.c
@@ -384,7 +384,7 @@ static GLboolean r200_run_tcl_render( GLcontext *ctx,
    r200ContextPtr rmesa = R200_CONTEXT(ctx);
    TNLcontext *tnl = TNL_CONTEXT(ctx);
    struct vertex_buffer *VB = &tnl->vb;
-   GLuint inputs = VERT_BIT_POS | VERT_BIT_COLOR0;
+   GLuint inputs = 0;
    GLuint i;
 
    /* TODO: separate this from the swtnl pipeline 
@@ -404,6 +404,7 @@ static GLboolean r200_run_tcl_render( GLcontext *ctx,
       r200ValidateState( ctx );
 
    if (!ctx->VertexProgram._Enabled) {
+      inputs = VERT_BIT_POS | VERT_BIT_COLOR0;
    /* NOTE: inputs != tnl->render_inputs - these are the untransformed
     * inputs.
     */
@@ -436,11 +437,13 @@ static GLboolean r200_run_tcl_render( GLcontext *ctx,
 	 We only need to change compsel. */
       GLuint out_compsel = 0;
       GLuint vp_out = rmesa->curr_vp_hw->mesa_program.Base.OutputsWritten;
+#if 0
       /* can't handle other inputs, generic attribs etc. currently - should never arrive here */
       assert ((rmesa->curr_vp_hw->mesa_program.Base.InputsRead &
 	 ~(VERT_BIT_POS | VERT_BIT_NORMAL | VERT_BIT_COLOR0 | VERT_BIT_COLOR1 |
 	  VERT_BIT_FOG | VERT_BIT_TEX0 | VERT_BIT_TEX1 | VERT_BIT_TEX2 |
 	  VERT_BIT_TEX3 | VERT_BIT_TEX4 | VERT_BIT_TEX5)) == 0);
+#endif
       inputs |= rmesa->curr_vp_hw->mesa_program.Base.InputsRead;
       assert(vp_out & (1 << VERT_RESULT_HPOS));
       out_compsel = R200_OUTPUT_XYZW;
@@ -577,7 +580,7 @@ static void transition_to_hwtnl( GLcontext *ctx )
       rmesa->hw.ctx.cmd[CTX_PP_FOG_COLOR] &= ~R200_FOG_USE_MASK;
       rmesa->hw.ctx.cmd[CTX_PP_FOG_COLOR] |= R200_FOG_USE_VTX_FOG;
    }
-   
+
    R200_STATECHANGE( rmesa, vte );
    rmesa->hw.vte.cmd[VTE_SE_VTE_CNTL] &= ~(R200_VTX_XY_FMT|R200_VTX_Z_FMT);
    rmesa->hw.vte.cmd[VTE_SE_VTE_CNTL] |= R200_VTX_W0_FMT;
diff --git a/src/mesa/drivers/dri/r200/r200_texstate.c b/src/mesa/drivers/dri/r200/r200_texstate.c
index 397b27ae52..875d3bab73 100644
--- a/src/mesa/drivers/dri/r200/r200_texstate.c
+++ b/src/mesa/drivers/dri/r200/r200_texstate.c
@@ -1178,7 +1178,7 @@ static void import_tex_obj_state( r200ContextPtr rmesa,
 				  r200TexObjPtr texobj )
 {
 /* do not use RADEON_DB_STATE to avoid stale texture caches */
-   GLuint *cmd = &rmesa->hw.tex[unit].cmd[TEX_CMD_0];
+   int *cmd = &rmesa->hw.tex[unit].cmd[TEX_CMD_0];
 
    R200_STATECHANGE( rmesa, tex[unit] );
 
@@ -1199,7 +1199,7 @@ static void import_tex_obj_state( r200ContextPtr rmesa,
    }
 
    if (texobj->base.tObj->Target == GL_TEXTURE_CUBE_MAP) {
-      GLuint *cube_cmd = &rmesa->hw.cube[unit].cmd[CUBE_CMD_0];
+      int *cube_cmd = &rmesa->hw.cube[unit].cmd[CUBE_CMD_0];
       GLuint bytesPerFace = texobj->base.totalSize / 6;
       ASSERT(texobj->base.totalSize % 6 == 0);
 
diff --git a/src/mesa/drivers/dri/r200/r200_vertprog.c b/src/mesa/drivers/dri/r200/r200_vertprog.c
index 9ac7a96827..491701b796 100644
--- a/src/mesa/drivers/dri/r200/r200_vertprog.c
+++ b/src/mesa/drivers/dri/r200/r200_vertprog.c
@@ -404,6 +404,9 @@ static GLboolean r200_translate_vertex_program(GLcontext *ctx, struct r200_verte
    unsigned long hw_op;
    int dofogfix = 0;
    int fog_temp_i = 0;
+   int free_inputs;
+   int free_inputs_conv;
+   int array_count = 0;
 
    vp->native = GL_FALSE;
    vp->translated = GL_TRUE;
@@ -412,6 +415,7 @@ static GLboolean r200_translate_vertex_program(GLcontext *ctx, struct r200_verte
    if (mesa_vp->Base.NumInstructions == 0)
       return GL_FALSE;
 
+#if 0
    if ((mesa_vp->Base.InputsRead &
       ~(VERT_BIT_POS | VERT_BIT_NORMAL | VERT_BIT_COLOR0 | VERT_BIT_COLOR1 |
       VERT_BIT_FOG | VERT_BIT_TEX0 | VERT_BIT_TEX1 | VERT_BIT_TEX2 |
@@ -422,6 +426,7 @@ static GLboolean r200_translate_vertex_program(GLcontext *ctx, struct r200_verte
       }
       return GL_FALSE;
    }
+#endif
 
    if ((mesa_vp->Base.OutputsWritten &
       ~((1 << VERT_RESULT_HPOS) | (1 << VERT_RESULT_COL0) | (1 << VERT_RESULT_COL1) |
@@ -470,35 +475,87 @@ static GLboolean r200_translate_vertex_program(GLcontext *ctx, struct r200_verte
    else
       mesa_vp->Base.NumNativeParameters = 0;
 
-   for(i=0; i < VERT_ATTRIB_MAX; i++)
+   for(i = 0; i < VERT_ATTRIB_MAX; i++)
       vp->inputs[i] = -1;
+   free_inputs = 0x2ffd;
+
 /* fglrx uses fixed inputs as follows for conventional attribs.
-   generic attribs use non-fixed assignment, fglrx will always use the lowest attrib values available.
-   There are 12 generic attribs possible, corresponding to attrib 0, 2-11 and 13 in a hw vertex prog.
-   attr 1 and 12 are not available for generic attribs as those cannot be made vec4 (correspond to
-   vertex normal/weight)
+   generic attribs use non-fixed assignment, fglrx will always use the
+   lowest attrib values available. We'll just do the same.
+   There are 12 generic attribs possible, corresponding to attrib 0, 2-11
+   and 13 in a hw vertex prog.
+   attr 1 and 12 aren't used for generic attribs as those cannot be made vec4
+   (correspond to vertex normal/weight - maybe weight actually could be made vec4).
+   Additionally, not more than 12 arrays in total are possible I think.
    attr 0 is pos, R200_VTX_XY1|R200_VTX_Z1|R200_VTX_W1 in R200_SE_VTX_FMT_0
    attr 2-5 use colors 0-3 (R200_VTX_FP_RGBA << R200_VTX_COLOR_0/1/2/3_SHIFT in R200_SE_VTX_FMT_0)
    attr 6-11 use tex 0-5 (4 << R200_VTX_TEX0/1/2/3/4/5_COMP_CNT_SHIFT in R200_SE_VTX_FMT_1)
    attr 13 uses vtx1 pos (R200_VTX_XY1|R200_VTX_Z1|R200_VTX_W1 in R200_SE_VTX_FMT_0)
-   generic attribs would require some more work (dma regions, renaming). */
+*/
 
-/* may look different when using idx buf / input_route instead of se_vtx_fmt? */
-   vp->inputs[VERT_ATTRIB_POS] = 0;
-   vp->inputs[VERT_ATTRIB_WEIGHT] = 12;
-   vp->inputs[VERT_ATTRIB_NORMAL] = 1;
-   vp->inputs[VERT_ATTRIB_COLOR0] = 2;
-   vp->inputs[VERT_ATTRIB_COLOR1] = 3;
-   vp->inputs[VERT_ATTRIB_FOG] = 15;
-   vp->inputs[VERT_ATTRIB_TEX0] = 6;
-   vp->inputs[VERT_ATTRIB_TEX1] = 7;
-   vp->inputs[VERT_ATTRIB_TEX2] = 8;
-   vp->inputs[VERT_ATTRIB_TEX3] = 9;
-   vp->inputs[VERT_ATTRIB_TEX4] = 10;
-   vp->inputs[VERT_ATTRIB_TEX5] = 11;
 /* attr 4,5 and 13 are only used with generic attribs.
    Haven't seen attr 14 used, maybe that's for the hw pointsize vec1 (which is
    not possibe to use with vertex progs as it is lacking in vert prog specification) */
+/* may look different when using idx buf / input_route instead of se_vtx_fmt? */
+   if (mesa_vp->Base.InputsRead & VERT_BIT_POS) {
+      vp->inputs[VERT_ATTRIB_POS] = 0;
+      free_inputs &= ~(1 << 0);
+      array_count++;
+   }
+   if (mesa_vp->Base.InputsRead & VERT_BIT_WEIGHT) {
+      vp->inputs[VERT_ATTRIB_WEIGHT] = 12;
+      array_count++;
+   }
+   if (mesa_vp->Base.InputsRead & VERT_BIT_NORMAL) {
+      vp->inputs[VERT_ATTRIB_NORMAL] = 1;
+      array_count++;
+   }
+   if (mesa_vp->Base.InputsRead & VERT_BIT_COLOR0) {
+      vp->inputs[VERT_ATTRIB_COLOR0] = 2;
+      free_inputs &= ~(1 << 2);
+      array_count++;
+   }
+   if (mesa_vp->Base.InputsRead & VERT_BIT_COLOR1) {
+      vp->inputs[VERT_ATTRIB_COLOR1] = 3;
+      free_inputs &= ~(1 << 3);
+      array_count++;
+   }
+   if (mesa_vp->Base.InputsRead & VERT_BIT_FOG) {
+      vp->inputs[VERT_ATTRIB_FOG] = 15; array_count++;
+   }
+   for (i = VERT_ATTRIB_TEX0; i <= VERT_ATTRIB_TEX5; i++) {
+      if (mesa_vp->Base.InputsRead & (1 << i)) {
+	 vp->inputs[i] = i - VERT_ATTRIB_TEX0 + 6;
+	 free_inputs &= ~(1 << (i - VERT_ATTRIB_TEX0 + 6));
+	 array_count++;
+      }
+   }
+   free_inputs_conv = free_inputs;
+   /* using VERT_ATTRIB_TEX6/7 would be illegal */
+   /* completely ignore aliasing? */
+   for (i = VERT_ATTRIB_GENERIC0; i < VERT_ATTRIB_MAX; i++) {
+      int j;
+   /* completely ignore aliasing? */
+      if (mesa_vp->Base.InputsRead & (1 << i)) {
+	 array_count++;
+	 if (array_count > 12) {
+	    if (R200_DEBUG & DEBUG_FALLBACKS) {
+	       fprintf(stderr, "more than 12 attribs used in vert prog\n");
+	    }
+	    return GL_FALSE;
+	 }
+	 for (j = 0; j < 14; j++) {
+	    /* will always find one due to limited array_count */
+	    if (free_inputs & (1 << j)) {
+	       free_inputs &= ~(1 << j);
+	       vp->inputs[i] = j;
+	       vp->rev_inputs[j] = i;
+	       break;
+	    }
+	 }
+      }
+   }
+   vp->gen_inputs_mapped = free_inputs ^ free_inputs_conv;
 
    if (!(mesa_vp->Base.OutputsWritten & (1 << VERT_RESULT_HPOS))) {
       if (R200_DEBUG & DEBUG_FALLBACKS) {
@@ -506,6 +563,12 @@ static GLboolean r200_translate_vertex_program(GLcontext *ctx, struct r200_verte
       }
       return GL_FALSE;
    }
+   if (free_inputs & 1) {
+      if (R200_DEBUG & DEBUG_FALLBACKS) {
+	 fprintf(stderr, "can't handle vert prog without position input\n");
+      }
+      return GL_FALSE;
+   }
 
    o_inst = vp->instr;
    for (vpi = mesa_vp->Base.Instructions; vpi->Opcode != OPCODE_END; vpi++, o_inst++){
@@ -1145,6 +1208,9 @@ r200ProgramStringNotify(GLcontext *ctx, GLenum target, struct gl_program *prog)
       r200_translate_vertex_program(ctx, vp);
       rmesa->curr_vp_hw = NULL;
       break;
+   case GL_FRAGMENT_SHADER_ATI:
+      rmesa->afs_loaded = NULL;
+      break;
    }
    /* need this for tcl fallbacks */
    _tnl_program_string(ctx, target, prog);