[PATCH 2/4] lib/igt_draw: Add Y-tiling support

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



This patch adds Y-tiling support for igt_draw_rect function.

Change-Id: I139e9773b7df286febe9ffa3dce358df079dac14
Signed-off-by: Praveen Paneri <praveen.paneri@xxxxxxxxx>
---
 lib/igt_draw.c | 148 ++++++++++++++++++++++++++++++++++++++++++---------------
 1 file changed, 110 insertions(+), 38 deletions(-)

diff --git a/lib/igt_draw.c b/lib/igt_draw.c
index 3afb827..29a725f 100644
--- a/lib/igt_draw.c
+++ b/lib/igt_draw.c
@@ -137,7 +137,7 @@ static int swizzle_addr(int addr, int swizzle)
 /* It's all in "pixel coordinates", so make sure you multiply/divide by the bpp
  * if you need to. */
 static int linear_x_y_to_tiled_pos(int x, int y, uint32_t stride, int swizzle,
-				   int bpp)
+				   int bpp, int tiling)
 {
 	int x_tile_size, y_tile_size;
 	int x_tile_n, y_tile_n, x_tile_off, y_tile_off;
@@ -146,23 +146,54 @@ static int linear_x_y_to_tiled_pos(int x, int y, uint32_t stride, int swizzle,
 	int tiled_pos, tiles_per_line;
 	int pixel_size = bpp / 8;
 
-	line_size = stride;
-	x_tile_size = 512;
-	y_tile_size = 8;
-	tile_size = x_tile_size * y_tile_size;
-	tiles_per_line = line_size / x_tile_size;
-
-	y_tile_n = y / y_tile_size;
-	y_tile_off = y % y_tile_size;
-
-	x_tile_n = (x * pixel_size) / x_tile_size;
-	x_tile_off = (x * pixel_size) % x_tile_size;
-
-	tile_n = y_tile_n * tiles_per_line + x_tile_n;
-	tile_off = y_tile_off * x_tile_size + x_tile_off;
-	tiled_pos = tile_n * tile_size + tile_off;
-
-	tiled_pos = swizzle_addr(tiled_pos, swizzle);
+	if (tiling == I915_TILING_X ) {
+		line_size = stride;
+		x_tile_size = 512;
+		y_tile_size = 8;
+		tile_size = x_tile_size * y_tile_size;
+		tiles_per_line = line_size / x_tile_size;
+
+		y_tile_n = y / y_tile_size;
+		y_tile_off = y % y_tile_size;
+
+		x_tile_n = (x * pixel_size) / x_tile_size;
+		x_tile_off = (x * pixel_size) % x_tile_size;
+
+		tile_n = y_tile_n * tiles_per_line + x_tile_n;
+		tile_off = y_tile_off * x_tile_size + x_tile_off;
+		tiled_pos = tile_n * tile_size + tile_off;
+
+		tiled_pos = swizzle_addr(tiled_pos, swizzle);
+	} else {
+		int x_oword_n, x_oword_off;
+		int oword_size;
+
+		/* Y-tile arrangement */
+		line_size = stride;
+		oword_size = 16;
+		x_tile_size = 128;
+		y_tile_size = 32;
+		tile_size = x_tile_size * y_tile_size;
+		tiles_per_line = line_size / x_tile_size;
+
+		y_tile_n = y / y_tile_size;
+		y_tile_off = y % y_tile_size;
+
+		x_tile_n = (x * pixel_size) / x_tile_size;
+		x_tile_off = (x * pixel_size) % x_tile_size;
+
+		tile_n = y_tile_n * tiles_per_line + x_tile_n;
+
+		/* computation inside the tile */
+		x_oword_n = x_tile_off / oword_size;
+		x_oword_off = x_tile_off % oword_size;
+		tile_off = x_oword_n * y_tile_size * oword_size
+			   + y_tile_off * oword_size
+			   + x_oword_off;
+		tiled_pos = tile_n * tile_size + tile_off;
+
+		tiled_pos = swizzle_addr(tiled_pos, swizzle);
+	}
 
 	return tiled_pos / pixel_size;
 }
@@ -170,7 +201,8 @@ static int linear_x_y_to_tiled_pos(int x, int y, uint32_t stride, int swizzle,
 /* It's all in "pixel coordinates", so make sure you multiply/divide by the bpp
  * if you need to. */
 static void tiled_pos_to_x_y_linear(int tiled_pos, uint32_t stride,
-				    int swizzle, int bpp, int *x, int *y)
+				    int swizzle, int bpp, int *x, int *y,
+				    int tiling)
 {
 	int tile_n, tile_off, tiles_per_line, line_size;
 	int x_tile_off, y_tile_off;
@@ -181,22 +213,50 @@ static void tiled_pos_to_x_y_linear(int tiled_pos, uint32_t stride,
 	tiled_pos = swizzle_addr(tiled_pos, swizzle);
 
 	line_size = stride;
-	x_tile_size = 512;
-	y_tile_size = 8;
-	tile_size = x_tile_size * y_tile_size;
-	tiles_per_line = line_size / x_tile_size;
+	if (tiling == I915_TILING_X ) {
+		x_tile_size = 512;
+		y_tile_size = 8;
+		tile_size = x_tile_size * y_tile_size;
+		tiles_per_line = line_size / x_tile_size;
+
+		tile_n = tiled_pos / tile_size;
+		tile_off = tiled_pos % tile_size;
+
+		y_tile_off = tile_off / x_tile_size;
+		x_tile_off = tile_off % x_tile_size;
 
-	tile_n = tiled_pos / tile_size;
-	tile_off = tiled_pos % tile_size;
+		x_tile_n = tile_n % tiles_per_line;
+		y_tile_n = tile_n / tiles_per_line;
+
+		*x = (x_tile_n * x_tile_size + x_tile_off) / pixel_size;
+		*y = y_tile_n * y_tile_size + y_tile_off;
+	} else {
+		int x_oword_n, x_oword_off;
+		int oword_size;
 
-	y_tile_off = tile_off / x_tile_size;
-	x_tile_off = tile_off % x_tile_size;
+		oword_size = 16;
+		x_tile_size = 128;
+		y_tile_size = 32;
+		tile_size = x_tile_size * y_tile_size;
+		tiles_per_line = line_size / x_tile_size;
 
-	x_tile_n = tile_n % tiles_per_line;
-	y_tile_n = tile_n / tiles_per_line;
+		tile_n = tiled_pos / tile_size;
+		tile_off = tiled_pos % tile_size;
 
-	*x = (x_tile_n * x_tile_size + x_tile_off) / pixel_size;
-	*y = y_tile_n * y_tile_size + y_tile_off;
+		x_tile_n = tile_n % tiles_per_line;
+		y_tile_n = tile_n / tiles_per_line;
+
+		x_oword_n = tile_off / (oword_size * y_tile_size);
+		x_oword_off = tile_off % oword_size;
+
+		x_tile_off = x_oword_n * oword_size + x_oword_off;
+		y_tile_off = (tile_off - x_oword_n * oword_size * y_tile_size)
+			     / oword_size;
+
+		*x = (x_tile_n * x_tile_size + x_tile_off) / pixel_size;
+		*y = y_tile_n * y_tile_size + y_tile_off;
+
+	}
 }
 
 static void set_pixel(void *_ptr, int index, uint32_t color, int bpp)
@@ -225,14 +285,15 @@ static void draw_rect_ptr_linear(void *ptr, uint32_t stride,
 }
 
 static void draw_rect_ptr_tiled(void *ptr, uint32_t stride, int swizzle,
-				struct rect *rect, uint32_t color, int bpp)
+				struct rect *rect, uint32_t color, int bpp,
+				int tiling)
 {
 	int x, y, pos;
 
 	for (y = rect->y; y < rect->y + rect->h; y++) {
 		for (x = rect->x; x < rect->x + rect->w; x++) {
 			pos = linear_x_y_to_tiled_pos(x, y, stride, swizzle,
-						      bpp);
+						      bpp, tiling);
 			set_pixel(ptr, pos, color, bpp);
 		}
 	}
@@ -260,7 +321,11 @@ static void draw_rect_mmap_cpu(int fd, struct buf_data *buf, struct rect *rect,
 		break;
 	case I915_TILING_X:
 		draw_rect_ptr_tiled(ptr, buf->stride, swizzle, rect, color,
-				    buf->bpp);
+				    buf->bpp, tiling);
+		break;
+	case I915_TILING_Y:
+		draw_rect_ptr_tiled(ptr, buf->stride, swizzle, rect, color,
+				    buf->bpp, tiling);
 		break;
 	default:
 		igt_assert(false);
@@ -310,7 +375,11 @@ static void draw_rect_mmap_wc(int fd, struct buf_data *buf, struct rect *rect,
 		break;
 	case I915_TILING_X:
 		draw_rect_ptr_tiled(ptr, buf->stride, swizzle, rect, color,
-				    buf->bpp);
+				    buf->bpp, tiling);
+		break;
+	case I915_TILING_Y:
+		draw_rect_ptr_tiled(ptr, buf->stride, swizzle, rect, color,
+				    buf->bpp, tiling);
 		break;
 	default:
 		igt_assert(false);
@@ -338,7 +407,7 @@ static void draw_rect_pwrite_untiled(int fd, struct buf_data *buf,
 
 static void draw_rect_pwrite_tiled(int fd, struct buf_data *buf,
 				   struct rect *rect, uint32_t color,
-				   uint32_t swizzle)
+				   uint32_t swizzle, int tiling)
 {
 	int i;
 	int tiled_pos, x, y, pixel_size;
@@ -362,7 +431,7 @@ static void draw_rect_pwrite_tiled(int fd, struct buf_data *buf,
 
 	for (tiled_pos = 0; tiled_pos < buf->size; tiled_pos += pixel_size) {
 		tiled_pos_to_x_y_linear(tiled_pos, buf->stride, swizzle,
-					buf->bpp, &x, &y);
+					buf->bpp, &x, &y, tiling);
 
 		if (x >= rect->x && x < rect->x + rect->w &&
 		    y >= rect->y && y < rect->y + rect->h) {
@@ -399,7 +468,10 @@ static void draw_rect_pwrite(int fd, struct buf_data *buf,
 		draw_rect_pwrite_untiled(fd, buf, rect, color);
 		break;
 	case I915_TILING_X:
-		draw_rect_pwrite_tiled(fd, buf, rect, color, swizzle);
+		draw_rect_pwrite_tiled(fd, buf, rect, color, swizzle, tiling);
+		break;
+	case I915_TILING_Y:
+		draw_rect_pwrite_tiled(fd, buf, rect, color, swizzle, tiling);
 		break;
 	default:
 		igt_assert(false);
-- 
1.9.1

_______________________________________________
Intel-gfx mailing list
Intel-gfx@xxxxxxxxxxxxxxxxxxxxx
https://lists.freedesktop.org/mailman/listinfo/intel-gfx




[Index of Archives]     [Linux USB Devel]     [Linux Audio Users]     [Yosemite News]     [Linux Kernel]     [Linux SCSI]
  Powered by Linux