1 files changed, 374 insertions, 157 deletions

diff --git a/src/mesa/drivers/dri/r300/r300_draw.c b/src/mesa/drivers/dri/r300/r300_draw.c
index 9769ff5399..e9968f9ffe 100644
--- a/src/mesa/drivers/dri/r300/r300_draw.c
+++ b/src/mesa/drivers/dri/r300/r300_draw.c
@@ -31,6 +31,7 @@
 #include "main/state.h"
 #include "main/api_validate.h"
 #include "main/enums.h"
+#include "main/simple_list.h"
 
 #include "r300_reg.h"
 #include "r300_context.h"
@@ -38,6 +39,10 @@
 #include "r300_render.h"
 #include "r300_state.h"
 #include "r300_tex.h"
+#include "r300_cmdbuf.h"
+
+#include "radeon_buffer_objects.h"
+#include "radeon_common_context.h"
 
 #include "tnl/tnl.h"
 #include "tnl/t_vp_build.h"
@@ -45,32 +50,59 @@
 #include "swrast/swrast.h"
 #include "swrast_setup/swrast_setup.h"
 
-static void r300FixupIndexBuffer(GLcontext *ctx, const struct _mesa_index_buffer *mesa_ind_buf, struct gl_buffer_object **bo, GLuint *nr_bo)
+
+static int getTypeSize(GLenum type)
+{
+	switch (type) {
+		case GL_DOUBLE:
+			return sizeof(GLdouble);
+		case GL_FLOAT:
+			return sizeof(GLfloat);
+		case GL_INT:
+			return sizeof(GLint);
+		case GL_UNSIGNED_INT:
+			return sizeof(GLuint);
+		case GL_SHORT:
+			return sizeof(GLshort);
+		case GL_UNSIGNED_SHORT:
+			return sizeof(GLushort);
+		case GL_BYTE:
+			return sizeof(GLbyte);
+		case GL_UNSIGNED_BYTE:
+			return sizeof(GLubyte);
+		default:
+			assert(0);
+			return 0;
+	}
+}
+
+static void r300FixupIndexBuffer(GLcontext *ctx, const struct _mesa_index_buffer *mesa_ind_buf)
 {
 	r300ContextPtr r300 = R300_CONTEXT(ctx);
-	struct r300_index_buffer *ind_buf = &r300->ind_buf;
 	GLvoid *src_ptr;
+	GLuint *out;
+	int i;
+	GLboolean mapped_named_bo = GL_FALSE;
 
-	if (!mesa_ind_buf) {
-		ind_buf->ptr = NULL;
-		return;
-	}
-
-	ind_buf->count = mesa_ind_buf->count;
 	if (mesa_ind_buf->obj->Name && !mesa_ind_buf->obj->Pointer) {
-		bo[*nr_bo] = mesa_ind_buf->obj;
-		(*nr_bo)++;
 		ctx->Driver.MapBuffer(ctx, GL_ELEMENT_ARRAY_BUFFER, GL_READ_ONLY_ARB, mesa_ind_buf->obj);
+		mapped_named_bo = GL_TRUE;
 		assert(mesa_ind_buf->obj->Pointer != NULL);
 	}
 	src_ptr = ADD_POINTERS(mesa_ind_buf->obj->Pointer, mesa_ind_buf->ptr);
 
+	radeon_print(RADEON_FALLBACKS, RADEON_IMPORTANT,
+			"%s: Fixing index buffer format. type %d\n",
+			__func__, mesa_ind_buf->type);
+
 	if (mesa_ind_buf->type == GL_UNSIGNED_BYTE) {
+		GLuint size = sizeof(GLushort) * ((mesa_ind_buf->count + 1) & ~1);
 		GLubyte *in = (GLubyte *)src_ptr;
-		GLuint *out = _mesa_malloc(sizeof(GLushort) * ((mesa_ind_buf->count + 1) & ~1));
-		int i;
 
-		ind_buf->ptr = out;
+		radeonAllocDmaRegion(&r300->radeon, &r300->ind_buf.bo, &r300->ind_buf.bo_offset, size, 4);
+
+		assert(r300->ind_buf.bo->ptr != NULL);
+		out = (GLuint *)ADD_POINTERS(r300->ind_buf.bo->ptr, r300->ind_buf.bo_offset);
 
 		for (i = 0; i + 1 < mesa_ind_buf->count; i += 2) {
 			*out++ = in[i] | in[i + 1] << 16;
@@ -80,16 +112,16 @@ static void r300FixupIndexBuffer(GLcontext *ctx, const struct _mesa_index_buffer
 			*out++ = in[i];
 		}
 
-		ind_buf->free_needed = GL_TRUE;
-		ind_buf->is_32bit = GL_FALSE;
-	} else if (mesa_ind_buf->type == GL_UNSIGNED_SHORT) {
 #if MESA_BIG_ENDIAN
+	} else { /* if (mesa_ind_buf->type == GL_UNSIGNED_SHORT) */
 		GLushort *in = (GLushort *)src_ptr;
-		GLuint *out = _mesa_malloc(sizeof(GLushort) *
-					   ((mesa_ind_buf->count + 1) & ~1));
-		int i;
+		GLuint size = sizeof(GLushort) * ((mesa_ind_buf->count + 1) & ~1);
+
+		radeonAllocDmaRegion(&r300->radeon, &r300->ind_buf.bo,
+				     &r300->ind_buf.bo_offset, size, 4);
 
-		ind_buf->ptr = out;
+		assert(r300->ind_buf.bo->ptr != NULL);
+		out = (GLuint *)ADD_POINTERS(r300->ind_buf.bo->ptr, r300->ind_buf.bo_offset);
 
 		for (i = 0; i + 1 < mesa_ind_buf->count; i += 2) {
 			*out++ = in[i] | in[i + 1] << 16;
@@ -98,42 +130,61 @@ static void r300FixupIndexBuffer(GLcontext *ctx, const struct _mesa_index_buffer
 		if (i < mesa_ind_buf->count) {
 			*out++ = in[i];
 		}
-
-		ind_buf->free_needed = GL_TRUE;
-#else
-		ind_buf->ptr = src_ptr;
-		ind_buf->free_needed = GL_FALSE;
 #endif
-		ind_buf->is_32bit = GL_FALSE;
-	} else {
-		ind_buf->ptr = src_ptr;
-		ind_buf->free_needed = GL_FALSE;
-		ind_buf->is_32bit = GL_TRUE;
+	}
+
+	r300->ind_buf.is_32bit = GL_FALSE;
+	r300->ind_buf.count = mesa_ind_buf->count;
+
+	if (mapped_named_bo) {
+		ctx->Driver.UnmapBuffer(ctx, GL_ELEMENT_ARRAY_BUFFER, mesa_ind_buf->obj);
 	}
 }
 
-static int getTypeSize(GLenum type)
+
+static void r300SetupIndexBuffer(GLcontext *ctx, const struct _mesa_index_buffer *mesa_ind_buf)
 {
-	switch (type) {
-		case GL_DOUBLE:
-			return sizeof(GLdouble);
-		case GL_FLOAT:
-			return sizeof(GLfloat);
-		case GL_INT:
-			return sizeof(GLint);
-		case GL_UNSIGNED_INT:
-			return sizeof(GLuint);
-		case GL_SHORT:
-			return sizeof(GLshort);
-		case GL_UNSIGNED_SHORT:
-			return sizeof(GLushort);
-		case GL_BYTE:
-			return sizeof(GLbyte);
-		case GL_UNSIGNED_BYTE:
-			return sizeof(GLubyte);
-		default:
-			assert(0);
-			return 0;
+	r300ContextPtr r300 = R300_CONTEXT(ctx);
+
+	if (!mesa_ind_buf) {
+		r300->ind_buf.bo = NULL;
+		return;
+	}
+	radeon_print(RADEON_RENDER, RADEON_TRACE, "%s\n", __func__);
+
+#if MESA_BIG_ENDIAN
+	if (mesa_ind_buf->type == GL_UNSIGNED_INT) {
+#else
+	if (mesa_ind_buf->type != GL_UNSIGNED_BYTE) {
+#endif
+		const GLvoid *src_ptr;
+		GLvoid *dst_ptr;
+		GLboolean mapped_named_bo = GL_FALSE;
+
+		if (mesa_ind_buf->obj->Name && !mesa_ind_buf->obj->Pointer) {
+			ctx->Driver.MapBuffer(ctx, GL_ELEMENT_ARRAY_BUFFER, GL_READ_ONLY_ARB, mesa_ind_buf->obj);
+			assert(mesa_ind_buf->obj->Pointer != NULL);
+			mapped_named_bo = GL_TRUE;
+		}
+
+		src_ptr = ADD_POINTERS(mesa_ind_buf->obj->Pointer, mesa_ind_buf->ptr);
+
+		const GLuint size = mesa_ind_buf->count * getTypeSize(mesa_ind_buf->type);
+
+		radeonAllocDmaRegion(&r300->radeon, &r300->ind_buf.bo, &r300->ind_buf.bo_offset, size, 4);
+
+		assert(r300->ind_buf.bo->ptr != NULL);
+		dst_ptr = ADD_POINTERS(r300->ind_buf.bo->ptr, r300->ind_buf.bo_offset);
+		_mesa_memcpy(dst_ptr, src_ptr, size);
+
+		r300->ind_buf.is_32bit = (mesa_ind_buf->type == GL_UNSIGNED_INT);
+		r300->ind_buf.count = mesa_ind_buf->count;
+
+		if (mapped_named_bo) {
+			ctx->Driver.UnmapBuffer(ctx, GL_ELEMENT_ARRAY_BUFFER, mesa_ind_buf->obj);
+		}
+	} else {
+		r300FixupIndexBuffer(ctx, mesa_ind_buf);
 	}
 }
 
@@ -161,27 +212,123 @@ static int getTypeSize(GLenum type)
 	}						\
 } while (0)
 
-static void r300TranslateAttrib(GLcontext *ctx, GLuint attr, int count, const struct gl_client_array *input, struct gl_buffer_object **bo, GLuint *nr_bo)
+/**
+ * Convert attribute data type to float
+ * If the attribute uses named buffer object replace the bo with newly allocated bo
+ */
+static void r300ConvertAttrib(GLcontext *ctx, int count, const struct gl_client_array *input, struct vertex_attribute *attr)
 {
 	r300ContextPtr r300 = R300_CONTEXT(ctx);
-	struct r300_vertex_buffer *vbuf = &r300->vbuf;
-	struct vertex_attribute r300_attr;
-	const void *src_ptr;
-	GLenum type;
+	const GLvoid *src_ptr;
+	GLboolean mapped_named_bo = GL_FALSE;
+	GLfloat *dst_ptr;
 	GLuint stride;
 
+	stride = (input->StrideB == 0) ? getTypeSize(input->Type) * input->Size : input->StrideB;
+
+	/* Convert value for first element only */
+	if (input->StrideB == 0)
+		count = 1;
+
 	if (input->BufferObj->Name) {
 		if (!input->BufferObj->Pointer) {
-			bo[*nr_bo] = input->BufferObj;
-			(*nr_bo)++;
 			ctx->Driver.MapBuffer(ctx, GL_ARRAY_BUFFER, GL_READ_ONLY_ARB, input->BufferObj);
-			assert(input->BufferObj->Pointer != NULL);
+			mapped_named_bo = GL_TRUE;
 		}
 
 		src_ptr = ADD_POINTERS(input->BufferObj->Pointer, input->Ptr);
-	} else
+	} else {
 		src_ptr = input->Ptr;
+	}
+
+	radeonAllocDmaRegion(&r300->radeon, &attr->bo, &attr->bo_offset, sizeof(GLfloat) * input->Size * count, 32);
+	dst_ptr = (GLfloat *)ADD_POINTERS(attr->bo->ptr, attr->bo_offset);
+
+	radeon_print(RADEON_FALLBACKS, RADEON_IMPORTANT,
+			"%s: Converting vertex attributes, attribute data format %x,"
+			"stride %d, components %d\n"
+			, __FUNCTION__, input->Type
+			, stride, input->Size);
+
+	assert(src_ptr != NULL);
+
+	switch (input->Type) {
+		case GL_DOUBLE:
+			CONVERT(GLdouble, (GLfloat));
+			break;
+		case GL_UNSIGNED_INT:
+			CONVERT(GLuint, UINT_TO_FLOAT);
+			break;
+		case GL_INT:
+			CONVERT(GLint, INT_TO_FLOAT);
+			break;
+		case GL_UNSIGNED_SHORT:
+			CONVERT(GLushort, USHORT_TO_FLOAT);
+			break;
+		case GL_SHORT:
+			CONVERT(GLshort, SHORT_TO_FLOAT);
+			break;
+		case GL_UNSIGNED_BYTE:
+			assert(input->Format != GL_BGRA);
+			CONVERT(GLubyte, UBYTE_TO_FLOAT);
+			break;
+		case GL_BYTE:
+			CONVERT(GLbyte, BYTE_TO_FLOAT);
+			break;
+		default:
+			assert(0);
+			break;
+	}
+
+	if (mapped_named_bo) {
+		ctx->Driver.UnmapBuffer(ctx, GL_ARRAY_BUFFER, input->BufferObj);
+	}
+}
+
+static void r300AlignDataToDword(GLcontext *ctx, const struct gl_client_array *input, int count, struct vertex_attribute *attr)
+{
+	r300ContextPtr r300 = R300_CONTEXT(ctx);
+	const int dst_stride = (input->StrideB + 3) & ~3;
+	const int size = getTypeSize(input->Type) * input->Size * count;
+	GLboolean mapped_named_bo = GL_FALSE;
+
+	radeonAllocDmaRegion(&r300->radeon, &attr->bo, &attr->bo_offset, size, 32);
+
+	if (!input->BufferObj->Pointer) {
+		ctx->Driver.MapBuffer(ctx, GL_ARRAY_BUFFER, GL_READ_ONLY_ARB, input->BufferObj);
+		mapped_named_bo = GL_TRUE;
+	}
+
+	radeon_print(RADEON_FALLBACKS, RADEON_IMPORTANT, "%s. Vertex alignment doesn't match hw requirements.\n", __func__);
 
+	{
+		GLvoid *src_ptr = ADD_POINTERS(input->BufferObj->Pointer, input->Ptr);
+		GLvoid *dst_ptr = ADD_POINTERS(attr->bo->ptr, attr->bo_offset);
+		int i;
+
+		for (i = 0; i < count; ++i) {
+			_mesa_memcpy(dst_ptr, src_ptr, input->StrideB);
+			src_ptr += input->StrideB;
+			dst_ptr += dst_stride;
+		}
+	}
+
+	if (mapped_named_bo) {
+		ctx->Driver.UnmapBuffer(ctx, GL_ARRAY_BUFFER, input->BufferObj);
+	}
+
+	attr->stride = dst_stride;
+}
+
+static void r300TranslateAttrib(GLcontext *ctx, GLuint attr, int count, const struct gl_client_array *input)
+{
+	r300ContextPtr r300 = R300_CONTEXT(ctx);
+	struct r300_vertex_buffer *vbuf = &r300->vbuf;
+	struct vertex_attribute r300_attr;
+	GLenum type;
+	GLuint stride;
+
+	radeon_print(RADEON_RENDER, RADEON_TRACE, "%s\n", __func__);
 	stride = (input->StrideB == 0) ? getTypeSize(input->Type) * input->Size : input->StrideB;
 
 	if (input->Type == GL_DOUBLE || input->Type == GL_UNSIGNED_INT || input->Type == GL_INT ||
@@ -189,62 +336,29 @@ static void r300TranslateAttrib(GLcontext *ctx, GLuint attr, int count, const st
 	    getTypeSize(input->Type) != 4 ||
 #endif
 	    stride < 4) {
-		if (RADEON_DEBUG & DEBUG_FALLBACKS) {
-			fprintf(stderr, "%s: Converting vertex attributes, attribute data format %x,", __FUNCTION__, input->Type);
-			fprintf(stderr, "stride %d, components %d\n", stride, input->Size);
-		}
-
-		GLfloat *dst_ptr, *tmp;
-
-		/* Convert value for first element only */
-		if (input->StrideB == 0)
-			count = 1;
-
-		tmp = dst_ptr = _mesa_malloc(sizeof(GLfloat) * input->Size * count);
-
-		switch (input->Type) {
-			case GL_DOUBLE:
-				CONVERT(GLdouble, (GLfloat));
-				break;
-			case GL_UNSIGNED_INT:
-				CONVERT(GLuint, UINT_TO_FLOAT);
-				break;
-			case GL_INT:
-				CONVERT(GLint, INT_TO_FLOAT);
-				break;
-			case GL_UNSIGNED_SHORT:
-				CONVERT(GLushort, USHORT_TO_FLOAT);
-				break;
-			case GL_SHORT:
-				CONVERT(GLshort, SHORT_TO_FLOAT);
-				break;
-			case GL_UNSIGNED_BYTE:
-				assert(input->Format != GL_BGRA);
-				CONVERT(GLubyte, UBYTE_TO_FLOAT);
-				break;
-			case GL_BYTE:
-				CONVERT(GLbyte, BYTE_TO_FLOAT);
-				break;
-			default:
-				assert(0);
-				break;
-		}
 
 		type = GL_FLOAT;
-		r300_attr.free_needed = GL_TRUE;
-		r300_attr.data = tmp;
+
 		if (input->StrideB == 0) {
 			r300_attr.stride = 0;
 		} else {
 			r300_attr.stride = sizeof(GLfloat) * input->Size;
 		}
 		r300_attr.dwords = input->Size;
+		r300_attr.is_named_bo = GL_FALSE;
 	} else {
 		type = input->Type;
-		r300_attr.free_needed = GL_FALSE;
-		r300_attr.data = (GLvoid *)src_ptr;
-		r300_attr.stride = input->StrideB;
-		r300_attr.dwords = (getTypeSize(type) * input->Size  + 3)/ 4;
+		r300_attr.dwords = (getTypeSize(type) * input->Size + 3)/ 4;
+		if (!input->BufferObj->Name) {
+
+			if (input->StrideB == 0) {
+				r300_attr.stride = 0;
+			} else {
+				r300_attr.stride = (getTypeSize(type) * input->Size + 3) & ~3;
+			}
+
+			r300_attr.is_named_bo = GL_FALSE;
+		}
 	}
 
 	r300_attr.size = input->Size;
@@ -333,15 +447,15 @@ static void r300TranslateAttrib(GLcontext *ctx, GLuint attr, int count, const st
 	++vbuf->num_attribs;
 }
 
-static void r300SetVertexFormat(GLcontext *ctx, const struct gl_client_array *arrays[], int count, struct gl_buffer_object **bo, GLuint *nr_bo)
+static void r300SetVertexFormat(GLcontext *ctx, const struct gl_client_array *arrays[], int count)
 {
 	r300ContextPtr r300 = R300_CONTEXT(ctx);
 	struct r300_vertex_buffer *vbuf = &r300->vbuf;
-
+	radeon_print(RADEON_RENDER, RADEON_VERBOSE, "%s\n", __func__);
 	{
 		int i, tmp;
 
-		tmp = r300->selected_vp->Base->Base.InputsRead;
+		tmp = r300->selected_vp->code.InputsRead;
 		i = 0;
 		vbuf->num_attribs = 0;
 		while (tmp) {
@@ -351,7 +465,7 @@ static void r300SetVertexFormat(GLcontext *ctx, const struct gl_client_array *ar
 				++i;
 			}
 
-			r300TranslateAttrib(ctx, i, count, arrays[i], bo, nr_bo);
+			r300TranslateAttrib(ctx, i, count, arrays[i]);
 
 			tmp >>= 1;
 			++i;
@@ -361,45 +475,139 @@ static void r300SetVertexFormat(GLcontext *ctx, const struct gl_client_array *ar
 	r300SwitchFallback(ctx, R300_FALLBACK_AOS_LIMIT, vbuf->num_attribs > R300_MAX_AOS_ARRAYS);
 	if (r300->fallback)
 		return;
+}
 
-	{
-		int i;
+static void r300AllocDmaRegions(GLcontext *ctx, const struct gl_client_array *input[], int count)
+{
+	r300ContextPtr r300 = R300_CONTEXT(ctx);
+	struct r300_vertex_buffer *vbuf = &r300->vbuf;
+	GLuint stride;
+	int ret;
+	int i, index;
+	radeon_print(RADEON_RENDER, RADEON_VERBOSE,
+			"%s: count %d num_attribs %d\n",
+			__func__, count, vbuf->num_attribs);
+
+	for (index = 0; index < vbuf->num_attribs; index++) {
+		struct radeon_aos *aos = &r300->radeon.tcl.aos[index];
+		i = vbuf->attribs[index].element;
+
+		stride = (input[i]->StrideB == 0) ? getTypeSize(input[i]->Type) * input[i]->Size : input[i]->StrideB;
+
+		if (input[i]->Type == GL_DOUBLE || input[i]->Type == GL_UNSIGNED_INT || input[i]->Type == GL_INT ||
+#if MESA_BIG_ENDIAN
+				getTypeSize(input[i]->Type) != 4 ||
+#endif
+				stride < 4) {
 
-		for (i = 0; i < vbuf->num_attribs; i++) {
-			rcommon_emit_vector(ctx, &r300->radeon.tcl.aos[i],
-						vbuf->attribs[i].data, vbuf->attribs[i].dwords,
-						vbuf->attribs[i].stride, count);
+			r300ConvertAttrib(ctx, count, input[i], &vbuf->attribs[index]);
+		} else {
+			if (input[i]->BufferObj->Name) {
+				if (stride % 4 != 0) {
+					assert(((intptr_t) input[i]->Ptr) % input[i]->StrideB == 0);
+					r300AlignDataToDword(ctx, input[i], count, &vbuf->attribs[index]);
+					vbuf->attribs[index].is_named_bo = GL_FALSE;
+				} else {
+					vbuf->attribs[index].stride = input[i]->StrideB;
+					vbuf->attribs[index].bo_offset = (intptr_t) input[i]->Ptr;
+					vbuf->attribs[index].bo = get_radeon_buffer_object(input[i]->BufferObj)->bo;
+					vbuf->attribs[index].is_named_bo = GL_TRUE;
+				}
+			} else {
+
+				int size;
+				int local_count = count;
+				uint32_t *dst;
+
+				if (input[i]->StrideB == 0) {
+					size = getTypeSize(input[i]->Type) * input[i]->Size;
+					local_count = 1;
+				} else {
+					size = getTypeSize(input[i]->Type) * input[i]->Size * local_count;
+				}
+
+				radeonAllocDmaRegion(&r300->radeon, &vbuf->attribs[index].bo, &vbuf->attribs[index].bo_offset, size, 32);
+				assert(vbuf->attribs[index].bo->ptr != NULL);
+				dst = (uint32_t *)ADD_POINTERS(vbuf->attribs[index].bo->ptr, vbuf->attribs[index].bo_offset);
+				switch (vbuf->attribs[index].dwords) {
+					case 1: radeonEmitVec4(dst, input[i]->Ptr, input[i]->StrideB, local_count); break;
+					case 2: radeonEmitVec8(dst, input[i]->Ptr, input[i]->StrideB, local_count); break;
+					case 3: radeonEmitVec12(dst, input[i]->Ptr, input[i]->StrideB, local_count); break;
+					case 4: radeonEmitVec16(dst, input[i]->Ptr, input[i]->StrideB, local_count); break;
+					default: assert(0); break;
+				}
+
+			}
 		}
 
-		r300->radeon.tcl.aos_count = vbuf->num_attribs;
+		aos->count = vbuf->attribs[index].stride == 0 ? 1 : count;
+		aos->stride = vbuf->attribs[index].stride / sizeof(float);
+		aos->components = vbuf->attribs[index].dwords;
+		aos->bo = vbuf->attribs[index].bo;
+		aos->offset = vbuf->attribs[index].bo_offset;
+
+		if (vbuf->attribs[index].is_named_bo) {
+			radeon_cs_space_add_persistent_bo(r300->radeon.cmdbuf.cs, r300->vbuf.attribs[index].bo, RADEON_GEM_DOMAIN_GTT, 0);
+		}
 	}
+
+	r300->radeon.tcl.aos_count = vbuf->num_attribs;
+	ret = radeon_cs_space_check_with_bo(r300->radeon.cmdbuf.cs, first_elem(&r300->radeon.dma.reserved)->bo, RADEON_GEM_DOMAIN_GTT, 0);
+	r300SwitchFallback(ctx, R300_FALLBACK_INVALID_BUFFERS, ret);
+
 }
 
-static void r300FreeData(GLcontext *ctx, struct gl_buffer_object **bo, GLuint nr_bo)
+static void r300FreeData(GLcontext *ctx)
 {
+	/* Need to zero tcl.aos[n].bo and tcl.elt_dma_bo
+	 * to prevent double unref in radeonReleaseArrays
+	 * called during context destroy
+	 */
+	radeon_print(RADEON_RENDER, RADEON_VERBOSE, "%s\n", __func__);
+	r300ContextPtr r300 = R300_CONTEXT(ctx);
 	{
-		struct r300_vertex_buffer *vbuf = &R300_CONTEXT(ctx)->vbuf;
 		int i;
 
-		for (i = 0; i < vbuf->num_attribs; i++) {
-			if (vbuf->attribs[i].free_needed)
-				_mesa_free(vbuf->attribs[i].data);
+		for (i = 0; i < r300->vbuf.num_attribs; i++) {
+			if (!r300->vbuf.attribs[i].is_named_bo) {
+				radeon_bo_unref(r300->vbuf.attribs[i].bo);
+			}
+			r300->radeon.tcl.aos[i].bo = NULL;
 		}
 	}
 
 	{
-		struct r300_index_buffer *ind_buf = &R300_CONTEXT(ctx)->ind_buf;
-		if (ind_buf->free_needed)
-			_mesa_free(ind_buf->ptr);
+		if (r300->ind_buf.bo != NULL) {
+			radeon_bo_unref(r300->ind_buf.bo);
+		}
 	}
+}
 
-	{
-		int i;
+static GLuint r300PredictTryDrawPrimsSize(GLcontext *ctx, GLuint nr_prims)
+{
+	struct r300_context *r300 = R300_CONTEXT(ctx);
+	struct r300_vertex_buffer *vbuf = &r300->vbuf;
+	GLboolean flushed;
+	GLuint dwords;
+	GLuint state_size;
+
+	dwords = 2*CACHE_FLUSH_BUFSZ;
+	dwords += PRE_EMIT_STATE_BUFSZ;
+	dwords += (AOS_BUFSZ(vbuf->num_attribs)
+		+ SCISSORS_BUFSZ*2
+		+ FIREAOS_BUFSZ )*nr_prims;
+
+	state_size = radeonCountStateEmitSize(&r300->radeon);
+	flushed = rcommonEnsureCmdBufSpace(&r300->radeon,
+			dwords + state_size,
+			__FUNCTION__);
+	if (flushed)
+		dwords += radeonCountStateEmitSize(&r300->radeon);
+	else
+		dwords += state_size;
 
-		for (i = 0; i < nr_bo; ++i) {
-			ctx->Driver.UnmapBuffer(ctx, 0, bo[i]);
-		}
-	}
+	radeon_print(RADEON_RENDER, RADEON_VERBOSE, "%s: total prediction size is %d.\n", __FUNCTION__, dwords);
+	return dwords;
 }
 
 static GLboolean r300TryDrawPrims(GLcontext *ctx,
@@ -411,8 +619,10 @@ static GLboolean r300TryDrawPrims(GLcontext *ctx,
 					 GLuint max_index )
 {
 	struct r300_context *r300 = R300_CONTEXT(ctx);
-	struct gl_buffer_object *bo[VERT_ATTRIB_MAX+1];
-	GLuint i, nr_bo = 0;
+	GLuint i;
+
+	radeon_print(RADEON_RENDER, RADEON_NORMAL, "%s: %u (%d-%d) cs begin at %d\n",
+				__FUNCTION__, nr_prims, min_index, max_index, r300->radeon.cmdbuf.cs->cdw );
 
 	if (ctx->NewState)
 		_mesa_update_state( ctx );
@@ -424,23 +634,27 @@ static GLboolean r300TryDrawPrims(GLcontext *ctx,
 
 	r300SwitchFallback(ctx, R300_FALLBACK_INVALID_BUFFERS, !r300ValidateBuffers(ctx));
 
-	r300FixupIndexBuffer(ctx, ib, bo, &nr_bo);
-
-	/* ensure we have the cmd buf space in advance to cover
- 	 * the state + DMA AOS pointers */
-	rcommonEnsureCmdBufSpace(&r300->radeon,
-                           r300->radeon.hw.max_state_size + (50*sizeof(int)),
-                           __FUNCTION__);
-
-	r300SetVertexFormat(ctx, arrays, max_index + 1, bo, &nr_bo);
+	r300SetVertexFormat(ctx, arrays, max_index + 1);
 
 	if (r300->fallback)
 		return GL_FALSE;
 
-	r300SetupVAP(ctx, r300->selected_vp->Base->Base.InputsRead, r300->selected_vp->Base->Base.OutputsWritten);
+	r300SetupVAP(ctx, r300->selected_vp->code.InputsRead, r300->selected_vp->code.OutputsWritten);
 
 	r300UpdateShaderStates(r300);
 
+	/* ensure we have the cmd buf space in advance to cover
+	 * the state + DMA AOS pointers */
+	GLuint emit_end = r300PredictTryDrawPrimsSize(ctx, nr_prims)
+		+ r300->radeon.cmdbuf.cs->cdw;
+
+	r300SetupIndexBuffer(ctx, ib);
+
+	r300AllocDmaRegions(ctx, arrays, max_index + 1);
+
+	if (r300->fallback)
+		return GL_FALSE;
+
 	r300EmitCacheFlush(r300);
 	radeonEmitState(&r300->radeon);
 
@@ -450,9 +664,14 @@ static GLboolean r300TryDrawPrims(GLcontext *ctx,
 
 	r300EmitCacheFlush(r300);
 
-	radeonReleaseArrays(ctx, ~0);
+	r300FreeData(ctx);
 
-	r300FreeData(ctx, bo, nr_bo);
+	radeon_print(RADEON_RENDER, RADEON_VERBOSE, "%s: %u (%d-%d) cs ending at %d\n",
+			__FUNCTION__, nr_prims, min_index, max_index, r300->radeon.cmdbuf.cs->cdw );
+
+	if (emit_end < r300->radeon.cmdbuf.cs->cdw)
+		WARN_ONCE("Rendering was %d commands larger than predicted size."
+				" We might overflow  command buffer.\n", r300->radeon.cmdbuf.cs->cdw - emit_end);
 
 	return GL_TRUE;
 }
@@ -462,28 +681,26 @@ static void r300DrawPrims(GLcontext *ctx,
 			 const struct _mesa_prim *prim,
 			 GLuint nr_prims,
 			 const struct _mesa_index_buffer *ib,
+			 GLboolean index_bounds_valid,
 			 GLuint min_index,
 			 GLuint max_index)
 {
-	struct split_limits limits;
 	GLboolean retval;
 
-	if (ib)
-		limits.max_verts = 0xffffffff;
-	else
-		limits.max_verts = 65535;
-
-	limits.max_indices = 65535;
-	limits.max_vb_size = 1024*1024;
+	/* This check should get folded into just the places that
+	 * min/max index are really needed.
+	 */
+	if (!index_bounds_valid) {
+		vbo_get_minmax_index(ctx, prim, ib, &min_index, &max_index);
+	}
 
 	if (min_index) {
+		radeon_print(RADEON_FALLBACKS, RADEON_IMPORTANT,
+				"%s: Rebasing primitives. %p nr_prims %d min_index %u max_index %u\n",
+				__func__, prim, nr_prims, min_index, max_index);
 		vbo_rebase_prims( ctx, arrays, prim, nr_prims, ib, min_index, max_index, r300DrawPrims );
 		return;
 	}
-	if ((ib && ib->count > 65535)) {
-		vbo_split_prims (ctx, arrays, prim, nr_prims, ib, min_index, max_index, r300DrawPrims, &limits);
-		return;
-	}
 
 	/* Make an attempt at drawing */
 	retval = r300TryDrawPrims(ctx, arrays, prim, nr_prims, ib, min_index, max_index);