[i-g-t,6/9] lib/igt_vc4: Add helpers for converting linear to T-tiled XRGB buffers

Submitted by Paul Kocialkowski on Dec. 6, 2018, 2:11 p.m.

Details

Message ID 20181206141132.23349-7-paul.kocialkowski@bootlin.com
State New
Series "Chamelium VC4 plane testing, with T-tiled mode"
Headers show

Commit Message

Paul Kocialkowski Dec. 6, 2018, 2:11 p.m.
In order to integrate testing of T-tiled buffers, the easiest path is to
generate patterns (with the already-existing functions) in linear
buffers and convert them to T-tiled subsequently.

Add helpers to do that conversion, with a first helper that returns the
memory offset for a given position in a T-tiled buffer and a second
helper that uses it for converting between framebuffers.

Signed-off-by: Paul Kocialkowski <paul.kocialkowski@bootlin.com>
---
 lib/igt_vc4.c | 96 +++++++++++++++++++++++++++++++++++++++++++++++++++
 lib/igt_vc4.h |  4 +++
 2 files changed, 100 insertions(+)

Patch hide | download patch | download mbox

diff --git a/lib/igt_vc4.c b/lib/igt_vc4.c
index 16dfe67a..0b5124f3 100644
--- a/lib/igt_vc4.c
+++ b/lib/igt_vc4.c
@@ -34,6 +34,7 @@ 
 #include "drmtest.h"
 #include "igt_aux.h"
 #include "igt_core.h"
+#include "igt_fb.h"
 #include "igt_vc4.h"
 #include "ioctl_wrappers.h"
 #include "intel_reg.h"
@@ -176,3 +177,98 @@  bool igt_vc4_purgeable_bo(int fd, int handle, bool purgeable)
 
 	return arg.retained;
 }
+
+unsigned int igt_vc4_fb_t_tiled_convert(struct igt_fb *dst, struct igt_fb *src)
+{
+	unsigned int fb_id;
+	unsigned int i, j;
+	uint32_t *src_buf;
+	uint32_t *dst_buf;
+	size_t offset;
+
+	igt_assert(src->drm_format == DRM_FORMAT_XRGB8888);
+
+	fb_id = igt_create_fb(src->fd, src->width, src->height, src->drm_format,
+			      DRM_FORMAT_MOD_BROADCOM_VC4_T_TILED, dst);
+	igt_assert(fb_id > 0);
+
+	src_buf = igt_fb_map_buffer(src->fd, src);
+	igt_assert(src_buf);
+
+	dst_buf = igt_fb_map_buffer(dst->fd, dst);
+	igt_assert(dst_buf);
+
+	for (i = 0; i < src->height; i++) {
+		for (j = 0; j < src->width; j++) {
+			offset = igt_vc4_t_tiled_offset(src->width, src->height,
+							src->drm_format, j, i) / 4;
+			*(dst_buf + offset) = *(src_buf +
+						src->strides[0] / 4 * i + j);
+		}
+	}
+
+	igt_fb_unmap_buffer(src, src_buf);
+	igt_fb_unmap_buffer(dst, dst_buf);
+
+	return fb_id;
+}
+
+size_t igt_vc4_t_tiled_offset(size_t width, size_t height, size_t format,
+			      size_t x, size_t y)
+{
+	size_t t1k_map_even[4] = { 0, 3, 1, 2 };
+	size_t t1k_map_odd[4] = { 2, 1, 3, 0 };
+	size_t offset = 0;
+	size_t t4k_w, t4k_x, t4k_y;
+	size_t t1k_x, t1k_y;
+	size_t t64b_x, t64b_y;
+	size_t pix_x, pix_y;
+	unsigned int index;
+
+	igt_assert(format == DRM_FORMAT_XRGB8888);
+
+	/* Width in number of 4K tiles. */
+	t4k_w = ALIGN(width, 32) / 32;
+
+	/* X and y coordinates in number of 4K tiles (32x32). */
+	t4k_x = x / 32;
+	t4k_y = y / 32;
+
+	/* Increase offset to the beginning of the corresponding 4K tile. */
+	offset += t4k_y * t4k_w * 32 * 32;
+
+	/* X and Y coordinates in number of 1K tiles (16x16) within the 4K tile. */
+	t1k_x = (x % 32) / 16;
+	t1k_y = (y % 32) / 16;
+
+	index = 2 * t1k_y + t1k_x;
+
+	if (t4k_y % 2) {
+		/* Odd rows start from the right. */
+		offset += (t4k_w - t4k_x - 1) * 32 * 32;
+		offset += t1k_map_odd[index] * 16 * 16;
+	} else {
+		/* Even rows start from the left. */
+		offset += t4k_x * 32 * 32;
+		offset += t1k_map_even[index] * 16 * 16;
+	}
+
+	/* X and Y coordinates in number of 64 byte tiles (4x4) within the 1K tile. */
+	t64b_x = (x % 16) / 4;
+	t64b_y = (y % 16) / 4;
+
+	/* Increase offset to the beginning of the corresponding 64 byte tile. */
+	offset += t64b_y * 4 * 4 * 4 + t64b_x * 4 * 4;
+
+	/* X and Y coordinates in number of pixels within the 64 byte tile. */
+	pix_x = x % 4;
+	pix_y = y % 4;
+
+	/* Increase offset to the correct pixel. */
+	offset += pix_y * 4 + pix_x;
+
+	/* Multiply by the number of bytes per pixel for the format. */
+	offset *= 4;
+
+	return offset;
+}
diff --git a/lib/igt_vc4.h b/lib/igt_vc4.h
index ebc8a388..ab44f771 100644
--- a/lib/igt_vc4.h
+++ b/lib/igt_vc4.h
@@ -33,4 +33,8 @@  bool igt_vc4_purgeable_bo(int fd, int handle, bool purgeable);
 void igt_vc4_set_tiling(int fd, uint32_t handle, uint64_t modifier);
 uint64_t igt_vc4_get_tiling(int fd, uint32_t handle);
 
+unsigned int igt_vc4_fb_t_tiled_convert(struct igt_fb *dst, struct igt_fb *src);
+size_t igt_vc4_t_tiled_offset(size_t width, size_t height, size_t format,
+			      size_t x, size_t y);
+
 #endif /* IGT_VC4_H */

Comments

Lyude Paul Dec. 6, 2018, 9:51 p.m.
One small nitpick

On Thu, 2018-12-06 at 15:11 +0100, Paul Kocialkowski wrote:
> In order to integrate testing of T-tiled buffers, the easiest path is to
> generate patterns (with the already-existing functions) in linear
> buffers and convert them to T-tiled subsequently.
> 
> Add helpers to do that conversion, with a first helper that returns the
> memory offset for a given position in a T-tiled buffer and a second
> helper that uses it for converting between framebuffers.
> 
> Signed-off-by: Paul Kocialkowski <paul.kocialkowski@bootlin.com>
> ---
>  lib/igt_vc4.c | 96 +++++++++++++++++++++++++++++++++++++++++++++++++++
>  lib/igt_vc4.h |  4 +++
>  2 files changed, 100 insertions(+)
> 
> diff --git a/lib/igt_vc4.c b/lib/igt_vc4.c
> index 16dfe67a..0b5124f3 100644
> --- a/lib/igt_vc4.c
> +++ b/lib/igt_vc4.c
> @@ -34,6 +34,7 @@
>  #include "drmtest.h"
>  #include "igt_aux.h"
>  #include "igt_core.h"
> +#include "igt_fb.h"
>  #include "igt_vc4.h"
>  #include "ioctl_wrappers.h"
>  #include "intel_reg.h"
> @@ -176,3 +177,98 @@ bool igt_vc4_purgeable_bo(int fd, int handle, bool
> purgeable)
>  
>  	return arg.retained;
>  }
> +
> +unsigned int igt_vc4_fb_t_tiled_convert(struct igt_fb *dst, struct igt_fb
> *src)
> +{
> +	unsigned int fb_id;
> +	unsigned int i, j;
> +	uint32_t *src_buf;
> +	uint32_t *dst_buf;
> +	size_t offset;
> +
> +	igt_assert(src->drm_format == DRM_FORMAT_XRGB8888);
> +
> +	fb_id = igt_create_fb(src->fd, src->width, src->height, src-
> >drm_format,
> +			      DRM_FORMAT_MOD_BROADCOM_VC4_T_TILED, dst);
> +	igt_assert(fb_id > 0);
> +
> +	src_buf = igt_fb_map_buffer(src->fd, src);
> +	igt_assert(src_buf);
> +
> +	dst_buf = igt_fb_map_buffer(dst->fd, dst);
> +	igt_assert(dst_buf);
> +
> +	for (i = 0; i < src->height; i++) {
> +		for (j = 0; j < src->width; j++) {
> +			offset = igt_vc4_t_tiled_offset(src->width, src-
> >height,
> +							src->drm_format, j, i)
> / 4;
> +			*(dst_buf + offset) = *(src_buf +
> +						src->strides[0] / 4 * i + j);
> +		}
> +	}
> +
> +	igt_fb_unmap_buffer(src, src_buf);
> +	igt_fb_unmap_buffer(dst, dst_buf);
> +
> +	return fb_id;
> +}
> +
> +size_t igt_vc4_t_tiled_offset(size_t width, size_t height, size_t format,
> +			      size_t x, size_t y)
> +{
> +	size_t t1k_map_even[4] = { 0, 3, 1, 2 };
> +	size_t t1k_map_odd[4] = { 2, 1, 3, 0 };
No need to specify the array size here, t1k_map_even[] and t1k_map_odd[]
should be fine. Also, these look like they probably should be const.

> +	size_t offset = 0;
> +	size_t t4k_w, t4k_x, t4k_y;
> +	size_t t1k_x, t1k_y;
> +	size_t t64b_x, t64b_y;
> +	size_t pix_x, pix_y;
> +	unsigned int index;
> +
> +	igt_assert(format == DRM_FORMAT_XRGB8888);
> +
> +	/* Width in number of 4K tiles. */
> +	t4k_w = ALIGN(width, 32) / 32;
> +
> +	/* X and y coordinates in number of 4K tiles (32x32). */
> +	t4k_x = x / 32;
> +	t4k_y = y / 32;
> +
> +	/* Increase offset to the beginning of the corresponding 4K tile. */
> +	offset += t4k_y * t4k_w * 32 * 32;
> +
> +	/* X and Y coordinates in number of 1K tiles (16x16) within the 4K
> tile. */
> +	t1k_x = (x % 32) / 16;
> +	t1k_y = (y % 32) / 16;
> +
> +	index = 2 * t1k_y + t1k_x;
> +
> +	if (t4k_y % 2) {
> +		/* Odd rows start from the right. */
> +		offset += (t4k_w - t4k_x - 1) * 32 * 32;
> +		offset += t1k_map_odd[index] * 16 * 16;
> +	} else {
> +		/* Even rows start from the left. */
> +		offset += t4k_x * 32 * 32;
> +		offset += t1k_map_even[index] * 16 * 16;
> +	}
> +
> +	/* X and Y coordinates in number of 64 byte tiles (4x4) within the 1K
> tile. */
> +	t64b_x = (x % 16) / 4;
> +	t64b_y = (y % 16) / 4;
> +
> +	/* Increase offset to the beginning of the corresponding 64 byte tile.
> */
> +	offset += t64b_y * 4 * 4 * 4 + t64b_x * 4 * 4;
> +
> +	/* X and Y coordinates in number of pixels within the 64 byte tile. */
> +	pix_x = x % 4;
> +	pix_y = y % 4;
> +
> +	/* Increase offset to the correct pixel. */
> +	offset += pix_y * 4 + pix_x;
> +
> +	/* Multiply by the number of bytes per pixel for the format. */
> +	offset *= 4;
> +
> +	return offset;
> +}
> diff --git a/lib/igt_vc4.h b/lib/igt_vc4.h
> index ebc8a388..ab44f771 100644
> --- a/lib/igt_vc4.h
> +++ b/lib/igt_vc4.h
> @@ -33,4 +33,8 @@ bool igt_vc4_purgeable_bo(int fd, int handle, bool
> purgeable);
>  void igt_vc4_set_tiling(int fd, uint32_t handle, uint64_t modifier);
>  uint64_t igt_vc4_get_tiling(int fd, uint32_t handle);
>  
> +unsigned int igt_vc4_fb_t_tiled_convert(struct igt_fb *dst, struct igt_fb
> *src);
> +size_t igt_vc4_t_tiled_offset(size_t width, size_t height, size_t format,
> +			      size_t x, size_t y);
> +
>  #endif /* IGT_VC4_H */
Paul Kocialkowski Dec. 7, 2018, 7:38 a.m.
Hi,

On Thu, 2018-12-06 at 16:51 -0500, Lyude Paul wrote:
> One small nitpick
> 
> On Thu, 2018-12-06 at 15:11 +0100, Paul Kocialkowski wrote:
> > In order to integrate testing of T-tiled buffers, the easiest path is to
> > generate patterns (with the already-existing functions) in linear
> > buffers and convert them to T-tiled subsequently.
> > 
> > Add helpers to do that conversion, with a first helper that returns the
> > memory offset for a given position in a T-tiled buffer and a second
> > helper that uses it for converting between framebuffers.
> > 
> > Signed-off-by: Paul Kocialkowski <paul.kocialkowski@bootlin.com>
> > ---
> >  lib/igt_vc4.c | 96 +++++++++++++++++++++++++++++++++++++++++++++++++++
> >  lib/igt_vc4.h |  4 +++
> >  2 files changed, 100 insertions(+)
> > 
> > diff --git a/lib/igt_vc4.c b/lib/igt_vc4.c
> > index 16dfe67a..0b5124f3 100644
> > --- a/lib/igt_vc4.c
> > +++ b/lib/igt_vc4.c
> > @@ -34,6 +34,7 @@
> >  #include "drmtest.h"
> >  #include "igt_aux.h"
> >  #include "igt_core.h"
> > +#include "igt_fb.h"
> >  #include "igt_vc4.h"
> >  #include "ioctl_wrappers.h"
> >  #include "intel_reg.h"
> > @@ -176,3 +177,98 @@ bool igt_vc4_purgeable_bo(int fd, int handle, bool
> > purgeable)
> >  
> >  	return arg.retained;
> >  }
> > +
> > +unsigned int igt_vc4_fb_t_tiled_convert(struct igt_fb *dst, struct igt_fb
> > *src)
> > +{
> > +	unsigned int fb_id;
> > +	unsigned int i, j;
> > +	uint32_t *src_buf;
> > +	uint32_t *dst_buf;
> > +	size_t offset;
> > +
> > +	igt_assert(src->drm_format == DRM_FORMAT_XRGB8888);
> > +
> > +	fb_id = igt_create_fb(src->fd, src->width, src->height, src-
> > > drm_format,
> > +			      DRM_FORMAT_MOD_BROADCOM_VC4_T_TILED, dst);
> > +	igt_assert(fb_id > 0);
> > +
> > +	src_buf = igt_fb_map_buffer(src->fd, src);
> > +	igt_assert(src_buf);
> > +
> > +	dst_buf = igt_fb_map_buffer(dst->fd, dst);
> > +	igt_assert(dst_buf);
> > +
> > +	for (i = 0; i < src->height; i++) {
> > +		for (j = 0; j < src->width; j++) {
> > +			offset = igt_vc4_t_tiled_offset(src->width, src-
> > > height,
> > +							src->drm_format, j, i)
> > / 4;
> > +			*(dst_buf + offset) = *(src_buf +
> > +						src->strides[0] / 4 * i + j);
> > +		}
> > +	}
> > +
> > +	igt_fb_unmap_buffer(src, src_buf);
> > +	igt_fb_unmap_buffer(dst, dst_buf);
> > +
> > +	return fb_id;
> > +}
> > +
> > +size_t igt_vc4_t_tiled_offset(size_t width, size_t height, size_t format,
> > +			      size_t x, size_t y)
> > +{
> > +	size_t t1k_map_even[4] = { 0, 3, 1, 2 };
> > +	size_t t1k_map_odd[4] = { 2, 1, 3, 0 };
> No need to specify the array size here, t1k_map_even[] and t1k_map_odd[]
> should be fine. Also, these look like they probably should be const.

Definitely, I will make these changes in v2!

Cheers,

Paul

> > +	size_t offset = 0;
> > +	size_t t4k_w, t4k_x, t4k_y;
> > +	size_t t1k_x, t1k_y;
> > +	size_t t64b_x, t64b_y;
> > +	size_t pix_x, pix_y;
> > +	unsigned int index;
> > +
> > +	igt_assert(format == DRM_FORMAT_XRGB8888);
> > +
> > +	/* Width in number of 4K tiles. */
> > +	t4k_w = ALIGN(width, 32) / 32;
> > +
> > +	/* X and y coordinates in number of 4K tiles (32x32). */
> > +	t4k_x = x / 32;
> > +	t4k_y = y / 32;
> > +
> > +	/* Increase offset to the beginning of the corresponding 4K tile. */
> > +	offset += t4k_y * t4k_w * 32 * 32;
> > +
> > +	/* X and Y coordinates in number of 1K tiles (16x16) within the 4K
> > tile. */
> > +	t1k_x = (x % 32) / 16;
> > +	t1k_y = (y % 32) / 16;
> > +
> > +	index = 2 * t1k_y + t1k_x;
> > +
> > +	if (t4k_y % 2) {
> > +		/* Odd rows start from the right. */
> > +		offset += (t4k_w - t4k_x - 1) * 32 * 32;
> > +		offset += t1k_map_odd[index] * 16 * 16;
> > +	} else {
> > +		/* Even rows start from the left. */
> > +		offset += t4k_x * 32 * 32;
> > +		offset += t1k_map_even[index] * 16 * 16;
> > +	}
> > +
> > +	/* X and Y coordinates in number of 64 byte tiles (4x4) within the 1K
> > tile. */
> > +	t64b_x = (x % 16) / 4;
> > +	t64b_y = (y % 16) / 4;
> > +
> > +	/* Increase offset to the beginning of the corresponding 64 byte tile.
> > */
> > +	offset += t64b_y * 4 * 4 * 4 + t64b_x * 4 * 4;
> > +
> > +	/* X and Y coordinates in number of pixels within the 64 byte tile. */
> > +	pix_x = x % 4;
> > +	pix_y = y % 4;
> > +
> > +	/* Increase offset to the correct pixel. */
> > +	offset += pix_y * 4 + pix_x;
> > +
> > +	/* Multiply by the number of bytes per pixel for the format. */
> > +	offset *= 4;
> > +
> > +	return offset;
> > +}
> > diff --git a/lib/igt_vc4.h b/lib/igt_vc4.h
> > index ebc8a388..ab44f771 100644
> > --- a/lib/igt_vc4.h
> > +++ b/lib/igt_vc4.h
> > @@ -33,4 +33,8 @@ bool igt_vc4_purgeable_bo(int fd, int handle, bool
> > purgeable);
> >  void igt_vc4_set_tiling(int fd, uint32_t handle, uint64_t modifier);
> >  uint64_t igt_vc4_get_tiling(int fd, uint32_t handle);
> >  
> > +unsigned int igt_vc4_fb_t_tiled_convert(struct igt_fb *dst, struct igt_fb
> > *src);
> > +size_t igt_vc4_t_tiled_offset(size_t width, size_t height, size_t format,
> > +			      size_t x, size_t y);
> > +
> >  #endif /* IGT_VC4_H */