1 files changed, 155 insertions, 105 deletions

diff --git a/src/mesa/drivers/dri/nouveau/nv04_surface.c b/src/mesa/drivers/dri/nouveau/nv04_surface.c
index 0d40349345..e3febf7d2f 100644
--- a/src/mesa/drivers/dri/nouveau/nv04_surface.c
+++ b/src/mesa/drivers/dri/nouveau/nv04_surface.c
@@ -198,9 +198,9 @@ nv04_surface_copy_swizzle(GLcontext *ctx,
 			  int w, int h)
 {
 	struct nouveau_channel *chan = context_chan(ctx);
-	struct nouveau_screen *screen = to_nouveau_context(ctx)->screen;
-	struct nouveau_grobj *swzsurf = screen->swzsurf;
-	struct nouveau_grobj *sifm = screen->sifm;
+	struct nouveau_hw_state *hw = &to_nouveau_context(ctx)->hw;
+	struct nouveau_grobj *swzsurf = hw->swzsurf;
+	struct nouveau_grobj *sifm = hw->sifm;
 	struct nouveau_bo_context *bctx = context_bctx(ctx, SURFACE);
 	const unsigned bo_flags = NOUVEAU_BO_VRAM | NOUVEAU_BO_GART;
 	/* Max width & height may not be the same on all HW, but must be POT */
@@ -216,8 +216,8 @@ nv04_surface_copy_swizzle(GLcontext *ctx,
 
         /* If area is too large to copy in one shot we must copy it in
 	 * POT chunks to meet alignment requirements */
-	assert(sub_w == w || _mesa_is_pow_two(sub_w));
-	assert(sub_h == h || _mesa_is_pow_two(sub_h));
+	assert(sub_w == w || _mesa_is_pow_two(w));
+	assert(sub_h == h || _mesa_is_pow_two(h));
 
 	nouveau_bo_marko(bctx, sifm, NV03_SCALED_IMAGE_FROM_MEMORY_DMA_IMAGE,
 			 src->bo, bo_flags | NOUVEAU_BO_RD);
@@ -239,8 +239,6 @@ nv04_surface_copy_swizzle(GLcontext *ctx,
 
 		for (x = 0; x < w; x += sub_w) {
 			sub_w = MIN2(sub_w, w - x);
-			/* Must be 64-byte aligned */
-			assert(!(dst->offset & 63));
 
 			MARK_RING(chan, 15, 1);
 
@@ -277,14 +275,14 @@ nv04_surface_copy_swizzle(GLcontext *ctx,
 
 static void
 nv04_surface_copy_m2mf(GLcontext *ctx,
-			  struct nouveau_surface *dst,
-			  struct nouveau_surface *src,
-			  int dx, int dy, int sx, int sy,
-			  int w, int h)
+		       struct nouveau_surface *dst,
+		       struct nouveau_surface *src,
+		       int dx, int dy, int sx, int sy,
+		       int w, int h)
 {
 	struct nouveau_channel *chan = context_chan(ctx);
-	struct nouveau_screen *screen = to_nouveau_context(ctx)->screen;
-	struct nouveau_grobj *m2mf = screen->m2mf;
+	struct nouveau_hw_state *hw = &to_nouveau_context(ctx)->hw;
+	struct nouveau_grobj *m2mf = hw->m2mf;
 	struct nouveau_bo_context *bctx = context_bctx(ctx, SURFACE);
 	const unsigned bo_flags = NOUVEAU_BO_VRAM | NOUVEAU_BO_GART;
 	unsigned dst_offset = dst->offset + dy * dst->pitch + dx * dst->cpp;
@@ -323,6 +321,82 @@ nv04_surface_copy_m2mf(GLcontext *ctx,
 		FIRE_RING(chan);
 }
 
+typedef unsigned (*get_offset_t)(struct nouveau_surface *s,
+				 unsigned x, unsigned y);
+
+static unsigned
+get_linear_offset(struct nouveau_surface *s, unsigned x, unsigned y)
+{
+	return x * s->cpp + y * s->pitch;
+}
+
+static unsigned
+get_swizzled_offset(struct nouveau_surface *s, unsigned x, unsigned y)
+{
+	unsigned k = log2i(MIN2(s->width, s->height));
+
+	unsigned u = (x & 0x001) << 0 |
+		(x & 0x002) << 1 |
+		(x & 0x004) << 2 |
+		(x & 0x008) << 3 |
+		(x & 0x010) << 4 |
+		(x & 0x020) << 5 |
+		(x & 0x040) << 6 |
+		(x & 0x080) << 7 |
+		(x & 0x100) << 8 |
+		(x & 0x200) << 9 |
+		(x & 0x400) << 10 |
+		(x & 0x800) << 11;
+
+	unsigned v = (y & 0x001) << 1 |
+		(y & 0x002) << 2 |
+		(y & 0x004) << 3 |
+		(y & 0x008) << 4 |
+		(y & 0x010) << 5 |
+		(y & 0x020) << 6 |
+		(y & 0x040) << 7 |
+		(y & 0x080) << 8 |
+		(y & 0x100) << 9 |
+		(y & 0x200) << 10 |
+		(y & 0x400) << 11 |
+		(y & 0x800) << 12;
+
+	return s->cpp * (((u | v) & ~(~0 << 2*k)) |
+			 (x & (~0 << k)) << k |
+			 (y & (~0 << k)) << k);
+}
+
+static void
+nv04_surface_copy_cpu(GLcontext *ctx,
+		      struct nouveau_surface *dst,
+		      struct nouveau_surface *src,
+		      int dx, int dy, int sx, int sy,
+		      int w, int h)
+{
+	int x, y;
+	get_offset_t get_dst = (dst->layout == SWIZZLED ?
+				get_swizzled_offset : get_linear_offset);
+	get_offset_t get_src = (src->layout == SWIZZLED ?
+				get_swizzled_offset : get_linear_offset);
+	void *dp, *sp;
+
+	nouveau_bo_map(dst->bo, NOUVEAU_BO_WR);
+	nouveau_bo_map(src->bo, NOUVEAU_BO_RD);
+
+	dp = dst->bo->map + dst->offset;
+	sp = src->bo->map + src->offset;
+
+	for (y = 0; y < h; y++) {
+		for (x = 0; x < w; x++) {
+			memcpy(dp + get_dst(dst, dx + x, dy + y),
+			       sp + get_src(src, sx + x, sy + y), dst->cpp);
+		}
+	}
+
+	nouveau_bo_unmap(src->bo);
+	nouveau_bo_unmap(dst->bo);
+}
+
 void
 nv04_surface_copy(GLcontext *ctx,
 		  struct nouveau_surface *dst,
@@ -330,16 +404,22 @@ nv04_surface_copy(GLcontext *ctx,
 		  int dx, int dy, int sx, int sy,
 		  int w, int h)
 {
-	/* Setup transfer to swizzle the texture to vram if needed */
-        if (src->layout != SWIZZLED &&
-	    dst->layout == SWIZZLED &&
-	    dst->width > 2 && dst->height > 1) {
-		nv04_surface_copy_swizzle(ctx, dst, src,
-					  dx, dy, sx, sy, w, h);
+	/* Linear texture copy. */
+	if ((src->layout == LINEAR && dst->layout == LINEAR) ||
+	    dst->width <= 2 || dst->height <= 1) {
+		nv04_surface_copy_m2mf(ctx, dst, src, dx, dy, sx, sy, w, h);
+		return;
+	}
+
+	/* Swizzle using sifm+swzsurf. */
+        if (src->layout == LINEAR && dst->layout == SWIZZLED &&
+	    dst->cpp != 1 && !(dst->offset & 63)) {
+		nv04_surface_copy_swizzle(ctx, dst, src, dx, dy, sx, sy, w, h);
 		return;
 	}
 
-	nv04_surface_copy_m2mf(ctx, dst, src, dx, dy, sx, sy, w, h);
+	/* Fallback to CPU copy. */
+	nv04_surface_copy_cpu(ctx, dst, src, dx, dy, sx, sy, w, h);
 }
 
 void
@@ -349,10 +429,10 @@ nv04_surface_fill(GLcontext *ctx,
 		  int dx, int dy, int w, int h)
 {
 	struct nouveau_channel *chan = context_chan(ctx);
-	struct nouveau_screen *screen = to_nouveau_context(ctx)->screen;
-	struct nouveau_grobj *surf2d = screen->surf2d;
-	struct nouveau_grobj *patt = screen->patt;
-	struct nouveau_grobj *rect = screen->rect;
+	struct nouveau_hw_state *hw = &to_nouveau_context(ctx)->hw;
+	struct nouveau_grobj *surf2d = hw->surf2d;
+	struct nouveau_grobj *patt = hw->patt;
+	struct nouveau_grobj *rect = hw->rect;
 	unsigned bo_flags = NOUVEAU_BO_VRAM | NOUVEAU_BO_GART;
 
 	MARK_RING (chan, 19, 4);
@@ -369,7 +449,7 @@ nv04_surface_fill(GLcontext *ctx,
 	BEGIN_RING(chan, patt, NV04_IMAGE_PATTERN_COLOR_FORMAT, 1);
 	OUT_RING  (chan, rect_format(dst->format));
 	BEGIN_RING(chan, patt, NV04_IMAGE_PATTERN_MONOCHROME_COLOR1, 1);
-	OUT_RING  (chan, mask | ~0 << (8 * dst->cpp));
+	OUT_RING  (chan, mask | ~0ll << (8 * dst->cpp));
 
 	BEGIN_RING(chan, rect, NV04_GDI_RECTANGLE_TEXT_COLOR_FORMAT, 1);
 	OUT_RING  (chan, rect_format(dst->format));
@@ -385,80 +465,78 @@ nv04_surface_fill(GLcontext *ctx,
 }
 
 void
-nv04_surface_takedown(struct nouveau_screen *screen)
+nv04_surface_takedown(GLcontext *ctx)
 {
-	nouveau_grobj_free(&screen->swzsurf);
-	nouveau_grobj_free(&screen->sifm);
-	nouveau_grobj_free(&screen->rect);
-	nouveau_grobj_free(&screen->rop);
-	nouveau_grobj_free(&screen->patt);
-	nouveau_grobj_free(&screen->surf2d);
-	nouveau_grobj_free(&screen->m2mf);
-	nouveau_notifier_free(&screen->ntfy);
+	struct nouveau_hw_state *hw = &to_nouveau_context(ctx)->hw;
+
+	nouveau_grobj_free(&hw->swzsurf);
+	nouveau_grobj_free(&hw->sifm);
+	nouveau_grobj_free(&hw->rect);
+	nouveau_grobj_free(&hw->rop);
+	nouveau_grobj_free(&hw->patt);
+	nouveau_grobj_free(&hw->surf2d);
+	nouveau_grobj_free(&hw->m2mf);
+	nouveau_notifier_free(&hw->ntfy);
 }
 
 GLboolean
-nv04_surface_init(struct nouveau_screen *screen)
+nv04_surface_init(GLcontext *ctx)
 {
-	struct nouveau_channel *chan = screen->chan;
-	const unsigned chipset = screen->device->chipset;
+	struct nouveau_channel *chan = context_chan(ctx);
+	struct nouveau_hw_state *hw = &to_nouveau_context(ctx)->hw;
 	unsigned handle = 0x88000000, class;
 	int ret;
 
 	/* Notifier object. */
-	ret = nouveau_notifier_alloc(chan, handle++, 1, &screen->ntfy);
+	ret = nouveau_notifier_alloc(chan, handle++, 1, &hw->ntfy);
 	if (ret)
 		goto fail;
 
 	/* Memory to memory format. */
 	ret = nouveau_grobj_alloc(chan, handle++, NV04_MEMORY_TO_MEMORY_FORMAT,
-				  &screen->m2mf);
+				  &hw->m2mf);
 	if (ret)
 		goto fail;
 
-	BEGIN_RING(chan, screen->m2mf, NV04_MEMORY_TO_MEMORY_FORMAT_DMA_NOTIFY, 1);
-	OUT_RING  (chan, screen->ntfy->handle);
+	BEGIN_RING(chan, hw->m2mf, NV04_MEMORY_TO_MEMORY_FORMAT_DMA_NOTIFY, 1);
+	OUT_RING  (chan, hw->ntfy->handle);
 
 	/* Context surfaces 2D. */
-	if (chan->device->chipset < 0x10)
+	if (context_chipset(ctx) < 0x10)
 		class = NV04_CONTEXT_SURFACES_2D;
 	else
 		class = NV10_CONTEXT_SURFACES_2D;
 
-	ret = nouveau_grobj_alloc(chan, handle++, class, &screen->surf2d);
+	ret = nouveau_grobj_alloc(chan, handle++, class, &hw->surf2d);
 	if (ret)
 		goto fail;
 
 	/* Raster op. */
-	ret = nouveau_grobj_alloc(chan, handle++, NV03_CONTEXT_ROP,
-				  &screen->rop);
+	ret = nouveau_grobj_alloc(chan, handle++, NV03_CONTEXT_ROP, &hw->rop);
 	if (ret)
 		goto fail;
 
-	BEGIN_RING(chan, screen->rop, NV03_CONTEXT_ROP_DMA_NOTIFY, 1);
-	OUT_RING  (chan, screen->ntfy->handle);
+	BEGIN_RING(chan, hw->rop, NV03_CONTEXT_ROP_DMA_NOTIFY, 1);
+	OUT_RING  (chan, hw->ntfy->handle);
 
-	BEGIN_RING(chan, screen->rop, NV03_CONTEXT_ROP_ROP, 1);
+	BEGIN_RING(chan, hw->rop, NV03_CONTEXT_ROP_ROP, 1);
 	OUT_RING  (chan, 0xca); /* DPSDxax in the GDI speech. */
 
 	/* Image pattern. */
 	ret = nouveau_grobj_alloc(chan, handle++, NV04_IMAGE_PATTERN,
-				  &screen->patt);
+				  &hw->patt);
 	if (ret)
 		goto fail;
 
-	BEGIN_RING(chan, screen->patt,
-		   NV04_IMAGE_PATTERN_DMA_NOTIFY, 1);
-	OUT_RING  (chan, screen->ntfy->handle);
+	BEGIN_RING(chan, hw->patt, NV04_IMAGE_PATTERN_DMA_NOTIFY, 1);
+	OUT_RING  (chan, hw->ntfy->handle);
 
-	BEGIN_RING(chan, screen->patt,
-		   NV04_IMAGE_PATTERN_MONOCHROME_FORMAT, 3);
+	BEGIN_RING(chan, hw->patt, NV04_IMAGE_PATTERN_MONOCHROME_FORMAT, 3);
 	OUT_RING  (chan, NV04_IMAGE_PATTERN_MONOCHROME_FORMAT_LE);
 	OUT_RING  (chan, NV04_IMAGE_PATTERN_MONOCHROME_SHAPE_8X8);
 	OUT_RING  (chan, NV04_IMAGE_PATTERN_PATTERN_SELECT_MONO);
 
-	BEGIN_RING(chan, screen->patt,
-		   NV04_IMAGE_PATTERN_MONOCHROME_COLOR0, 4);
+	BEGIN_RING(chan, hw->patt, NV04_IMAGE_PATTERN_MONOCHROME_COLOR0, 4);
 	OUT_RING  (chan, 0);
 	OUT_RING  (chan, 0);
 	OUT_RING  (chan, ~0);
@@ -466,75 +544,47 @@ nv04_surface_init(struct nouveau_screen *screen)
 
 	/* GDI rectangle text. */
 	ret = nouveau_grobj_alloc(chan, handle++, NV04_GDI_RECTANGLE_TEXT,
-				  &screen->rect);
+				  &hw->rect);
 	if (ret)
 		goto fail;
 
-	BEGIN_RING(chan, screen->rect, NV04_GDI_RECTANGLE_TEXT_DMA_NOTIFY, 1);
-	OUT_RING  (chan, screen->ntfy->handle);
-	BEGIN_RING(chan, screen->rect, NV04_GDI_RECTANGLE_TEXT_SURFACE, 1);
-	OUT_RING  (chan, screen->surf2d->handle);
-	BEGIN_RING(chan, screen->rect, NV04_GDI_RECTANGLE_TEXT_ROP, 1);
-	OUT_RING  (chan, screen->rop->handle);
-	BEGIN_RING(chan, screen->rect, NV04_GDI_RECTANGLE_TEXT_PATTERN, 1);
-	OUT_RING  (chan, screen->patt->handle);
+	BEGIN_RING(chan, hw->rect, NV04_GDI_RECTANGLE_TEXT_DMA_NOTIFY, 1);
+	OUT_RING  (chan, hw->ntfy->handle);
+	BEGIN_RING(chan, hw->rect, NV04_GDI_RECTANGLE_TEXT_SURFACE, 1);
+	OUT_RING  (chan, hw->surf2d->handle);
+	BEGIN_RING(chan, hw->rect, NV04_GDI_RECTANGLE_TEXT_ROP, 1);
+	OUT_RING  (chan, hw->rop->handle);
+	BEGIN_RING(chan, hw->rect, NV04_GDI_RECTANGLE_TEXT_PATTERN, 1);
+	OUT_RING  (chan, hw->patt->handle);
 
-	BEGIN_RING(chan, screen->rect, NV04_GDI_RECTANGLE_TEXT_OPERATION, 1);
+	BEGIN_RING(chan, hw->rect, NV04_GDI_RECTANGLE_TEXT_OPERATION, 1);
 	OUT_RING  (chan, NV04_GDI_RECTANGLE_TEXT_OPERATION_ROP_AND);
-	BEGIN_RING(chan, screen->rect,
+	BEGIN_RING(chan, hw->rect,
 		   NV04_GDI_RECTANGLE_TEXT_MONOCHROME_FORMAT, 1);
 	OUT_RING  (chan, NV04_GDI_RECTANGLE_TEXT_MONOCHROME_FORMAT_LE);
 
 	/* Swizzled surface. */
-	switch (chan->device->chipset & 0xf0) {
-	case 0x00:
-	case 0x10:
+	if (context_chipset(ctx) < 0x20)
 		class = NV04_SWIZZLED_SURFACE;
-		break;
-	case 0x20:
+	else
 		class = NV20_SWIZZLED_SURFACE;
-		break;
-	case 0x30:
-		class = NV30_SWIZZLED_SURFACE;
-		break;
-	case 0x40:
-	case 0x60:
-		class = NV40_SWIZZLED_SURFACE;
-		break;
-	default:
-		/* Famous last words: this really can't happen.. */
-		assert(0);
-		break;
-	}
 
-	ret = nouveau_grobj_alloc(chan, handle++, class, &screen->swzsurf);
+	ret = nouveau_grobj_alloc(chan, handle++, class, &hw->swzsurf);
 	if (ret)
 		goto fail;
 
 	/* Scaled image from memory. */
-	switch (chan->device->chipset & 0xf0) {
-	case 0x10:
-	case 0x20:
-		class = NV10_SCALED_IMAGE_FROM_MEMORY;
-		break;
-	case 0x30:
-		class = NV30_SCALED_IMAGE_FROM_MEMORY;
-		break;
-	case 0x40:
-	case 0x60:
-		class = NV40_SCALED_IMAGE_FROM_MEMORY;
-		break;
-	default:
+	if  (context_chipset(ctx) < 0x10)
 		class = NV04_SCALED_IMAGE_FROM_MEMORY;
-		break;
-	}
+	else
+		class = NV10_SCALED_IMAGE_FROM_MEMORY;
 
-	ret = nouveau_grobj_alloc(chan, handle++, class, &screen->sifm);
+	ret = nouveau_grobj_alloc(chan, handle++, class, &hw->sifm);
 	if (ret)
 		goto fail;
 
-	if (chipset >= 0x10) {
-		BEGIN_RING(chan, screen->sifm,
+	if (context_chipset(ctx) >= 0x10) {
+		BEGIN_RING(chan, hw->sifm,
 			   NV05_SCALED_IMAGE_FROM_MEMORY_COLOR_CONVERSION, 1);
 		OUT_RING(chan, NV05_SCALED_IMAGE_FROM_MEMORY_COLOR_CONVERSION_TRUNCATE);
 	}
@@ -542,6 +592,6 @@ nv04_surface_init(struct nouveau_screen *screen)
 	return GL_TRUE;
 
 fail:
-	nv04_surface_takedown(screen);
+	nv04_surface_takedown(ctx);
 	return GL_FALSE;
 }