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

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

 



On Friday 14 July 2017 03:03 AM, Paulo Zanoni wrote:

Em Sex, 2017-06-09 às 15:48 +0530, Praveen Paneri escreveu:

This patch adds Y-tiling support for igt_draw_rect function.

v2: Use helper function to get tile sizes (Ville)

v3: Moved igt_get_fb_tile_size() out of the for loop
 for better performance (Paulo)


For some reason I thought this series was using my original patch, but
I realized it's not:

https://patchwork.freedesktop.org/patch/72039/

Now that I read our past emails, I wonder that maybe I didn't send you
this specific patch of that series. I'm sorry for that. Obviously I'm
biased towards my version. Which one do you think is better? Would you
be willing to give my version a r-b, in case you think it's better?

Your version looks better. I will add my r-b and post it
Thanks
Praveen


Thanks,
Paulo




Signed-off-by: Praveen Paneri <praveen.paneri@xxxxxxxxx>
---
 lib/igt_draw.c | 139 ++++++++++++++++++++++++++++++++++++++---------
----------
 1 file changed, 94 insertions(+), 45 deletions(-)

diff --git a/lib/igt_draw.c b/lib/igt_draw.c
index 29aec85..2138bf7 100644
--- a/lib/igt_draw.c
+++ b/lib/igt_draw.c
@@ -136,32 +136,45 @@ 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)
+static int linear_x_y_to_tiled_pos(int fd, int x, int y, uint32_t
stride, int swizzle,
+				   int bpp, int tiling, uint32_t
tile_width,
+				   uint32_t tile_height)
 {
-	int x_tile_size, y_tile_size;
-	int x_tile_n, y_tile_n, x_tile_off, y_tile_off;
-	int line_size, tile_size;
+	uint32_t tile_size;
+	int tile_x, tile_y; /* Co-ordinates of the tile holding the
pixel */
+	int tile_x_off, tile_y_off; /* pixel position inside the
tile */
 	int tile_n, tile_off;
-	int tiled_pos, tiles_per_line;
+	int line_size, tiles_per_line;
+	int tiled_pos;
 	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;
+	tile_size = tile_width * tile_height;
+	tiles_per_line = line_size / tile_width;

-	y_tile_n = y / y_tile_size;
-	y_tile_off = y % y_tile_size;
+	tile_y = y / tile_height;
+	tile_y_off = y % tile_height;

-	x_tile_n = (x * pixel_size) / x_tile_size;
-	x_tile_off = (x * pixel_size) % x_tile_size;
+	tile_x = (x * pixel_size) / tile_width;
+	tile_x_off = (x * pixel_size) % tile_width;

-	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;
+	tile_n = tile_y * tiles_per_line + tile_x;
+
+	if (tiling == I915_TILING_X ) {
+		tile_off = tile_y_off * tile_width + tile_x_off;
+	} else { /* (tiling == I915_TILING_Y ) */
+		int x_oword_n, x_oword_off;
+		int oword_size = 16;
+
+		/* computation inside the tile */
+		x_oword_n = tile_x_off / oword_size;
+		x_oword_off = tile_x_off % oword_size;
+		tile_off = x_oword_n * tile_height * oword_size
+			   + tile_y_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;
@@ -169,34 +182,48 @@ 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)
+static void tiled_pos_to_x_y_linear(int fd, int tiled_pos, uint32_t
stride,
+				    int swizzle, int bpp, int *x,
int *y,
+				    int tiling, uint32_t tile_width,
+				    uint32_t tile_height)
 {
-	int tile_n, tile_off, tiles_per_line, line_size;
-	int x_tile_off, y_tile_off;
-	int x_tile_n, y_tile_n;
-	int x_tile_size, y_tile_size, tile_size;
+	uint32_t tile_size;
+	int tile_x, tile_y; /* Co-ordinates of the tile holding the
pixel */
+	int tile_x_off, tile_y_off; /* pixel position inside the
tile */
+	int tile_n, tile_off;
+	int line_size, tiles_per_line;
 	int pixel_size = bpp / 8;

 	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;
+	tile_size = tile_width * tile_height;
+	tiles_per_line = line_size / tile_width;

 	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_x = tile_n % tiles_per_line;
+	tile_y = tile_n / tiles_per_line;
+
+	if (tiling == I915_TILING_X ) {
+
+		tile_y_off = tile_off / tile_width;
+		tile_x_off = tile_off % tile_width;
+	} else {
+		int x_oword_n, x_oword_off;
+		int oword_size = 16;
+
+		x_oword_n = tile_off / (oword_size * tile_height);
+		x_oword_off = tile_off % oword_size;

-	x_tile_n = tile_n % tiles_per_line;
-	y_tile_n = tile_n / tiles_per_line;
+		tile_x_off = x_oword_n * oword_size + x_oword_off;
+		tile_y_off = (tile_off - x_oword_n * oword_size *
tile_height)
+			     / oword_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_x * tile_width + tile_x_off) / pixel_size;
+	*y = tile_y * tile_height + tile_y_off;
 }

 static void set_pixel(void *_ptr, int index, uint32_t color, int
bpp)
@@ -224,15 +251,21 @@ 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)
+static void draw_rect_ptr_tiled(int fd, void *ptr, uint32_t stride,
int swizzle,
+				struct rect *rect, uint32_t color,
int bpp,
+				int tiling)
 {
 	int x, y, pos;
+	uint32_t tile_width, tile_height;
+
+	igt_get_fb_tile_size(fd,
(uint64_t)igt_fb_tiling_to_mod(tiling), bpp,
+			&tile_width, &tile_height);

 	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);
+			pos = linear_x_y_to_tiled_pos(fd, x, y,
stride, swizzle,
+						      bpp, tiling,
tile_width,
+						      tile_height);
 			set_pixel(ptr, pos, color, bpp);
 		}
 	}
@@ -259,8 +292,12 @@ static void draw_rect_mmap_cpu(int fd, struct
buf_data *buf, struct rect *rect,
 		draw_rect_ptr_linear(ptr, buf->stride, rect, color,
buf->bpp);
 		break;
 	case I915_TILING_X:
-		draw_rect_ptr_tiled(ptr, buf->stride, swizzle, rect,
color,
-				    buf->bpp);
+		draw_rect_ptr_tiled(fd, ptr, buf->stride, swizzle,
rect, color,
+				    buf->bpp, tiling);
+		break;
+	case I915_TILING_Y:
+		draw_rect_ptr_tiled(fd, ptr, buf->stride, swizzle,
rect, color,
+				    buf->bpp, tiling);
 		break;
 	default:
 		igt_assert(false);
@@ -309,8 +346,12 @@ static void draw_rect_mmap_wc(int fd, struct
buf_data *buf, struct rect *rect,
 		draw_rect_ptr_linear(ptr, buf->stride, rect, color,
buf->bpp);
 		break;
 	case I915_TILING_X:
-		draw_rect_ptr_tiled(ptr, buf->stride, swizzle, rect,
color,
-				    buf->bpp);
+		draw_rect_ptr_tiled(fd, ptr, buf->stride, swizzle,
rect, color,
+				    buf->bpp, tiling);
+		break;
+	case I915_TILING_Y:
+		draw_rect_ptr_tiled(fd, ptr, buf->stride, swizzle,
rect, color,
+				    buf->bpp, tiling);
 		break;
 	default:
 		igt_assert(false);
@@ -338,7 +379,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;
@@ -347,6 +388,7 @@ static void draw_rect_pwrite_tiled(int fd, struct
buf_data *buf,
 	bool flush_tmp = false;
 	int tmp_start_pos = 0;
 	int pixels_written = 0;
+	uint32_t tile_width, tile_height;

 	/* We didn't implement suport for the older tiling methods
yet. */
 	igt_require(intel_gen(intel_get_drm_devid(fd)) >= 5);
@@ -360,9 +402,13 @@ static void draw_rect_pwrite_tiled(int fd,
struct buf_data *buf,
 	for (i = 0; i < tmp_size; i++)
 		set_pixel(tmp, i, color, buf->bpp);

+	igt_get_fb_tile_size(fd,
(uint64_t)igt_fb_tiling_to_mod(tiling),
+			     buf->bpp, &tile_width, &tile_height);
+
 	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);
+		tiled_pos_to_x_y_linear(fd, tiled_pos, buf->stride,
swizzle,
+					buf->bpp, &x, &y, tiling,
tile_width,
+					tile_height);

 		if (x >= rect->x && x < rect->x + rect->w &&
 		    y >= rect->y && y < rect->y + rect->h) {
@@ -399,7 +445,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);

_______________________________________________
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