Commit 45046af3 authored by Dave Airlie's avatar Dave Airlie
Browse files

Merge tag 'drm-misc-fixes-2024-02-29' of... 

Merge tag 'drm-misc-fixes-2024-02-29' of https://anongit.freedesktop.org/git/drm/drm-misc

 into drm-fixes

A reset fix for host1x, a resource leak fix and a probe fix for aux-hpd,
a use-after-free fix and a boot fix for a pmic_glink qcom driver in
drivers/soc, a fix for the simpledrm/tegra transition, a kunit fix for
the TTM tests, a font handling fix for fbcon, two allocation fixes and a
kunit test to cover them for drm/buddy

Signed-off-by: default avatarDave Airlie <airlied@redhat.com>

From: Maxime Ripard <mripard@redhat.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20240229-angelic-adorable-teal-fbfabb@houat
parents d206a76d c7070332

drivers/gpu/drm/Kconfig

+3 −2
Original line number Diff line number Diff line
@@ -199,7 +199,7 @@ config DRM_TTM 
config DRM_TTM_KUNIT_TEST

        tristate "KUnit tests for TTM" if !KUNIT_ALL_TESTS

        default n

        depends on DRM && KUNIT && MMU

        depends on DRM && KUNIT && MMU && (UML || COMPILE_TEST)

        select DRM_TTM

        select DRM_EXPORT_FOR_TESTS if m

        select DRM_KUNIT_TEST_HELPERS
@@ -207,7 +207,8 @@ config DRM_TTM_KUNIT_TEST 
        help

          Enables unit tests for TTM, a GPU memory manager subsystem used

          to manage memory buffers. This option is mostly useful for kernel

          developers.

          developers. It depends on (UML || COMPILE_TEST) since no other driver

          which uses TTM can be loaded while running the tests.



          If in doubt, say "N".

drivers/gpu/drm/bridge/aux-hpd-bridge.c

+55 −15
Original line number Diff line number Diff line
@@ -25,20 +25,18 @@ static void drm_aux_hpd_bridge_release(struct device *dev) 
	ida_free(&drm_aux_hpd_bridge_ida, adev->id);



	of_node_put(adev->dev.platform_data);

	of_node_put(adev->dev.of_node);



	kfree(adev);

}



static void drm_aux_hpd_bridge_unregister_adev(void *_adev)

static void drm_aux_hpd_bridge_free_adev(void *_adev)

{

	struct auxiliary_device *adev = _adev;



	auxiliary_device_delete(adev);

	auxiliary_device_uninit(adev);

	auxiliary_device_uninit(_adev);

}



/**

 * drm_dp_hpd_bridge_register - Create a simple HPD DisplayPort bridge

 * devm_drm_dp_hpd_bridge_alloc - allocate a HPD DisplayPort bridge

 * @parent: device instance providing this bridge

 * @np: device node pointer corresponding to this bridge instance

 *
@@ -46,11 +44,9 @@ static void drm_aux_hpd_bridge_unregister_adev(void *_adev) 
 * DRM_MODE_CONNECTOR_DisplayPort, which terminates the bridge chain and is

 * able to send the HPD events.

 *

 * Return: device instance that will handle created bridge or an error code

 * encoded into the pointer.

 * Return: bridge auxiliary device pointer or an error pointer

 */

struct device *drm_dp_hpd_bridge_register(struct device *parent,

					  struct device_node *np)

struct auxiliary_device *devm_drm_dp_hpd_bridge_alloc(struct device *parent, struct device_node *np)

{

	struct auxiliary_device *adev;

	int ret;
@@ -74,18 +70,62 @@ struct device *drm_dp_hpd_bridge_register(struct device *parent, 


	ret = auxiliary_device_init(adev);

	if (ret) {

		of_node_put(adev->dev.platform_data);

		of_node_put(adev->dev.of_node);

		ida_free(&drm_aux_hpd_bridge_ida, adev->id);

		kfree(adev);

		return ERR_PTR(ret);

	}



	ret = auxiliary_device_add(adev);

	if (ret) {

		auxiliary_device_uninit(adev);

	ret = devm_add_action_or_reset(parent, drm_aux_hpd_bridge_free_adev, adev);

	if (ret)

		return ERR_PTR(ret);



	return adev;

}

EXPORT_SYMBOL_GPL(devm_drm_dp_hpd_bridge_alloc);



static void drm_aux_hpd_bridge_del_adev(void *_adev)

{

	auxiliary_device_delete(_adev);

}



/**

 * devm_drm_dp_hpd_bridge_add - register a HDP DisplayPort bridge

 * @dev: struct device to tie registration lifetime to

 * @adev: bridge auxiliary device to be registered

 *

 * Returns: zero on success or a negative errno

 */

int devm_drm_dp_hpd_bridge_add(struct device *dev, struct auxiliary_device *adev)

{

	int ret;



	ret = auxiliary_device_add(adev);

	if (ret)

		return ret;



	return devm_add_action_or_reset(dev, drm_aux_hpd_bridge_del_adev, adev);

}

EXPORT_SYMBOL_GPL(devm_drm_dp_hpd_bridge_add);



/**

 * drm_dp_hpd_bridge_register - allocate and register a HDP DisplayPort bridge

 * @parent: device instance providing this bridge

 * @np: device node pointer corresponding to this bridge instance

 *

 * Return: device instance that will handle created bridge or an error pointer

 */

struct device *drm_dp_hpd_bridge_register(struct device *parent, struct device_node *np)

{

	struct auxiliary_device *adev;

	int ret;



	adev = devm_drm_dp_hpd_bridge_alloc(parent, np);

	if (IS_ERR(adev))

		return ERR_CAST(adev);



	ret = devm_add_action_or_reset(parent, drm_aux_hpd_bridge_unregister_adev, adev);

	ret = devm_drm_dp_hpd_bridge_add(parent, adev);

	if (ret)

		return ERR_PTR(ret);

drivers/gpu/drm/drm_buddy.c

+15 −1
Original line number Diff line number Diff line
@@ -332,6 +332,7 @@ alloc_range_bias(struct drm_buddy *mm, 
		 u64 start, u64 end,

		 unsigned int order)

{

	u64 req_size = mm->chunk_size << order;

	struct drm_buddy_block *block;

	struct drm_buddy_block *buddy;

	LIST_HEAD(dfs);
@@ -367,6 +368,15 @@ alloc_range_bias(struct drm_buddy *mm, 
		if (drm_buddy_block_is_allocated(block))

			continue;



		if (block_start < start || block_end > end) {

			u64 adjusted_start = max(block_start, start);

			u64 adjusted_end = min(block_end, end);



			if (round_down(adjusted_end + 1, req_size) <=

			    round_up(adjusted_start, req_size))

				continue;

		}



		if (contains(start, end, block_start, block_end) &&

		    order == drm_buddy_block_order(block)) {

			/*
@@ -761,8 +771,12 @@ int drm_buddy_alloc_blocks(struct drm_buddy *mm, 
		return -EINVAL;



	/* Actual range allocation */

	if (start + size == end)

	if (start + size == end) {

		if (!IS_ALIGNED(start | end, min_block_size))

			return -EINVAL;



		return __drm_buddy_alloc_range(mm, start, size, NULL, blocks);

	}



	original_size = size;

	original_min_size = min_block_size;

drivers/gpu/drm/tegra/drm.c

+20 −3
Original line number Diff line number Diff line
@@ -1243,9 +1243,26 @@ static int host1x_drm_probe(struct host1x_device *dev) 


	drm_mode_config_reset(drm);



	/*

	 * Only take over from a potential firmware framebuffer if any CRTCs

	 * have been registered. This must not be a fatal error because there

	 * are other accelerators that are exposed via this driver.

	 *

	 * Another case where this happens is on Tegra234 where the display

	 * hardware is no longer part of the host1x complex, so this driver

	 * will not expose any modesetting features.

	 */

	if (drm->mode_config.num_crtc > 0) {

		err = drm_aperture_remove_framebuffers(&tegra_drm_driver);

		if (err < 0)

			goto hub;

	} else {

		/*

		 * Indicate to userspace that this doesn't expose any display

		 * capabilities.

		 */

		drm->driver_features &= ~(DRIVER_MODESET | DRIVER_ATOMIC);

	}



	err = drm_dev_register(drm, 0);

	if (err < 0)

drivers/gpu/drm/tests/drm_buddy_test.c

+218 −0
Original line number Diff line number Diff line
@@ -14,11 +14,216 @@ 


#include "../lib/drm_random.h"



static unsigned int random_seed;



static inline u64 get_size(int order, u64 chunk_size)

{

	return (1 << order) * chunk_size;

}



static void drm_test_buddy_alloc_range_bias(struct kunit *test)

{

	u32 mm_size, ps, bias_size, bias_start, bias_end, bias_rem;

	DRM_RND_STATE(prng, random_seed);

	unsigned int i, count, *order;

	struct drm_buddy mm;

	LIST_HEAD(allocated);



	bias_size = SZ_1M;

	ps = roundup_pow_of_two(prandom_u32_state(&prng) % bias_size);

	ps = max(SZ_4K, ps);

	mm_size = (SZ_8M-1) & ~(ps-1); /* Multiple roots */



	kunit_info(test, "mm_size=%u, ps=%u\n", mm_size, ps);



	KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_init(&mm, mm_size, ps),

			       "buddy_init failed\n");



	count = mm_size / bias_size;

	order = drm_random_order(count, &prng);

	KUNIT_EXPECT_TRUE(test, order);



	/*

	 * Idea is to split the address space into uniform bias ranges, and then

	 * in some random order allocate within each bias, using various

	 * patterns within. This should detect if allocations leak out from a

	 * given bias, for example.

	 */



	for (i = 0; i < count; i++) {

		LIST_HEAD(tmp);

		u32 size;



		bias_start = order[i] * bias_size;

		bias_end = bias_start + bias_size;

		bias_rem = bias_size;



		/* internal round_up too big */

		KUNIT_ASSERT_TRUE_MSG(test,

				      drm_buddy_alloc_blocks(&mm, bias_start,

							     bias_end, bias_size + ps, bias_size,

							     &allocated,

							     DRM_BUDDY_RANGE_ALLOCATION),

				      "buddy_alloc failed with bias(%x-%x), size=%u, ps=%u\n",

				      bias_start, bias_end, bias_size, bias_size);



		/* size too big */

		KUNIT_ASSERT_TRUE_MSG(test,

				      drm_buddy_alloc_blocks(&mm, bias_start,

							     bias_end, bias_size + ps, ps,

							     &allocated,

							     DRM_BUDDY_RANGE_ALLOCATION),

				      "buddy_alloc didn't fail with bias(%x-%x), size=%u, ps=%u\n",

				      bias_start, bias_end, bias_size + ps, ps);



		/* bias range too small for size */

		KUNIT_ASSERT_TRUE_MSG(test,

				      drm_buddy_alloc_blocks(&mm, bias_start + ps,

							     bias_end, bias_size, ps,

							     &allocated,

							     DRM_BUDDY_RANGE_ALLOCATION),

				      "buddy_alloc didn't fail with bias(%x-%x), size=%u, ps=%u\n",

				      bias_start + ps, bias_end, bias_size, ps);



		/* bias misaligned */

		KUNIT_ASSERT_TRUE_MSG(test,

				      drm_buddy_alloc_blocks(&mm, bias_start + ps,

							     bias_end - ps,

							     bias_size >> 1, bias_size >> 1,

							     &allocated,

							     DRM_BUDDY_RANGE_ALLOCATION),

				      "buddy_alloc h didn't fail with bias(%x-%x), size=%u, ps=%u\n",

				      bias_start + ps, bias_end - ps, bias_size >> 1, bias_size >> 1);



		/* single big page */

		KUNIT_ASSERT_FALSE_MSG(test,

				       drm_buddy_alloc_blocks(&mm, bias_start,

							      bias_end, bias_size, bias_size,

							      &tmp,

							      DRM_BUDDY_RANGE_ALLOCATION),

				       "buddy_alloc i failed with bias(%x-%x), size=%u, ps=%u\n",

				       bias_start, bias_end, bias_size, bias_size);

		drm_buddy_free_list(&mm, &tmp);



		/* single page with internal round_up */

		KUNIT_ASSERT_FALSE_MSG(test,

				       drm_buddy_alloc_blocks(&mm, bias_start,

							      bias_end, ps, bias_size,

							      &tmp,

							      DRM_BUDDY_RANGE_ALLOCATION),

				       "buddy_alloc failed with bias(%x-%x), size=%u, ps=%u\n",

				       bias_start, bias_end, ps, bias_size);

		drm_buddy_free_list(&mm, &tmp);



		/* random size within */

		size = max(round_up(prandom_u32_state(&prng) % bias_rem, ps), ps);

		if (size)

			KUNIT_ASSERT_FALSE_MSG(test,

					       drm_buddy_alloc_blocks(&mm, bias_start,

								      bias_end, size, ps,

								      &tmp,

								      DRM_BUDDY_RANGE_ALLOCATION),

					       "buddy_alloc failed with bias(%x-%x), size=%u, ps=%u\n",

					       bias_start, bias_end, size, ps);



		bias_rem -= size;

		/* too big for current avail */

		KUNIT_ASSERT_TRUE_MSG(test,

				      drm_buddy_alloc_blocks(&mm, bias_start,

							     bias_end, bias_rem + ps, ps,

							     &allocated,

							     DRM_BUDDY_RANGE_ALLOCATION),

				      "buddy_alloc didn't fail with bias(%x-%x), size=%u, ps=%u\n",

				      bias_start, bias_end, bias_rem + ps, ps);



		if (bias_rem) {

			/* random fill of the remainder */

			size = max(round_up(prandom_u32_state(&prng) % bias_rem, ps), ps);

			size = max(size, ps);



			KUNIT_ASSERT_FALSE_MSG(test,

					       drm_buddy_alloc_blocks(&mm, bias_start,

								      bias_end, size, ps,

								      &allocated,

								      DRM_BUDDY_RANGE_ALLOCATION),

					       "buddy_alloc failed with bias(%x-%x), size=%u, ps=%u\n",

					       bias_start, bias_end, size, ps);

			/*

			 * Intentionally allow some space to be left

			 * unallocated, and ideally not always on the bias

			 * boundaries.

			 */

			drm_buddy_free_list(&mm, &tmp);

		} else {

			list_splice_tail(&tmp, &allocated);

		}

	}



	kfree(order);

	drm_buddy_free_list(&mm, &allocated);

	drm_buddy_fini(&mm);



	/*

	 * Something more free-form. Idea is to pick a random starting bias

	 * range within the address space and then start filling it up. Also

	 * randomly grow the bias range in both directions as we go along. This

	 * should give us bias start/end which is not always uniform like above,

	 * and in some cases will require the allocator to jump over already

	 * allocated nodes in the middle of the address space.

	 */



	KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_init(&mm, mm_size, ps),

			       "buddy_init failed\n");



	bias_start = round_up(prandom_u32_state(&prng) % (mm_size - ps), ps);

	bias_end = round_up(bias_start + prandom_u32_state(&prng) % (mm_size - bias_start), ps);

	bias_end = max(bias_end, bias_start + ps);

	bias_rem = bias_end - bias_start;



	do {

		u32 size = max(round_up(prandom_u32_state(&prng) % bias_rem, ps), ps);



		KUNIT_ASSERT_FALSE_MSG(test,

				       drm_buddy_alloc_blocks(&mm, bias_start,

							      bias_end, size, ps,

							      &allocated,

							      DRM_BUDDY_RANGE_ALLOCATION),

				       "buddy_alloc failed with bias(%x-%x), size=%u, ps=%u\n",

				       bias_start, bias_end, size);

		bias_rem -= size;



		/*

		 * Try to randomly grow the bias range in both directions, or

		 * only one, or perhaps don't grow at all.

		 */

		do {

			u32 old_bias_start = bias_start;

			u32 old_bias_end = bias_end;



			if (bias_start)

				bias_start -= round_up(prandom_u32_state(&prng) % bias_start, ps);

			if (bias_end != mm_size)

				bias_end += round_up(prandom_u32_state(&prng) % (mm_size - bias_end), ps);



			bias_rem += old_bias_start - bias_start;

			bias_rem += bias_end - old_bias_end;

		} while (!bias_rem && (bias_start || bias_end != mm_size));

	} while (bias_rem);



	KUNIT_ASSERT_EQ(test, bias_start, 0);

	KUNIT_ASSERT_EQ(test, bias_end, mm_size);

	KUNIT_ASSERT_TRUE_MSG(test,

			      drm_buddy_alloc_blocks(&mm, bias_start, bias_end,

						     ps, ps,

						     &allocated,

						     DRM_BUDDY_RANGE_ALLOCATION),

			      "buddy_alloc passed with bias(%x-%x), size=%u\n",

			      bias_start, bias_end, ps);



	drm_buddy_free_list(&mm, &allocated);

	drm_buddy_fini(&mm);

}



static void drm_test_buddy_alloc_contiguous(struct kunit *test)

{

	const unsigned long ps = SZ_4K, mm_size = 16 * 3 * SZ_4K;
@@ -362,17 +567,30 @@ static void drm_test_buddy_alloc_limit(struct kunit *test) 
	drm_buddy_fini(&mm);

}



static int drm_buddy_suite_init(struct kunit_suite *suite)

{

	while (!random_seed)

		random_seed = get_random_u32();



	kunit_info(suite, "Testing DRM buddy manager, with random_seed=0x%x\n",

		   random_seed);



	return 0;

}



static struct kunit_case drm_buddy_tests[] = {

	KUNIT_CASE(drm_test_buddy_alloc_limit),

	KUNIT_CASE(drm_test_buddy_alloc_optimistic),

	KUNIT_CASE(drm_test_buddy_alloc_pessimistic),

	KUNIT_CASE(drm_test_buddy_alloc_pathological),

	KUNIT_CASE(drm_test_buddy_alloc_contiguous),

	KUNIT_CASE(drm_test_buddy_alloc_range_bias),

	{}

};



static struct kunit_suite drm_buddy_test_suite = {

	.name = "drm_buddy",

	.suite_init = drm_buddy_suite_init,

	.test_cases = drm_buddy_tests,

};