index : nvgpu.git	gpu-paging
	Tegra GPU Driver. Originally from nv-tegra.nvidia.com/linux-nvgpu.git.	Joshua J Bakita

summaryrefslogtreecommitdiffstats

log msg author committer range

	Commit message (Expand)	Author	Age
...
*	Revert "gpu: nvgpu: fix allocator_init() calls"	Bharat Nihalani	2016-12-27
*	gpu: nvgpu: Disable channel when writing syncpt id	Terje Bergstrom	2016-12-27
*	gpu: nvgpu: Expose preemption flags to user space	Terje Bergstrom	2016-12-27
*	gpu: nvgpu: gp10b: Use correct PBDMA sig	Terje Bergstrom	2016-12-27
*	gpu: nvgpu: fix allocator_init() calls	Deepak Nibade	2016-12-27
*	gpu:nvgpu: gp10b: update channel_setup_ramfc	Seshendra Gadagottu	2016-12-27
*	gpu: nvgpu: gp10b: add hwpm registers	Leonid Moiseichuk	2016-12-27
*	gpu: nvgpu: gp10b: Wait for preempted or empty	Terje Bergstrom	2016-12-27
*	gpu: nvgpu: gp10b: Fix PDE/PTE address handling	Terje Bergstrom	2016-12-27
*	Revert "Revert "gpu: nvgpu: gp10b part of new VA allocator""	Alex Waterman	2016-12-27
*	Revert "gpu: nvgpu: gp10b part of new VA allocator"	Terje Bergstrom	2016-12-27
*	gpu: nvgpu: gp10b part of new VA allocator	Alex Waterman	2016-12-27
*	gpu:nvgpu:gp10b: support secure gpccs changes	Vijayakumar	2016-12-27
*	gpu: nvgpu: gp10b: Define VPR allocator	Terje Bergstrom	2016-12-27
*	gpu: nvgpu: gp10b: Fix comptag index calculation	Terje Bergstrom	2016-12-27
*	gpu: nvgpu: gp10b: Enable new page table format	Terje Bergstrom	2016-12-27
*	gpu: nvgpu: gp10b: Fix caching attribute	Terje Bergstrom	2016-12-27
*	gpu: nvgpu: gp10b: Dynamic GfxP buffer size	Terje Bergstrom	2016-12-27
*	gpu: nvgpu: gp10b: Use betacb size from debugfs	Terje Bergstrom	2016-12-27
*	gpu: nvgpu: Implement syncpt protection	Terje Bergstrom	2016-12-27
*	gpu: nvgpu: gp10b: fix sparse warnings of static symbol	Deepak Nibade	2016-12-27
*	gpu: nvgpu: gp10b: Enable SMMU bypass	Terje Bergstrom	2016-12-27
*	gpu: nvgpu: gp10b: Gating reglist	Terje Bergstrom	2016-12-27
*	gpu: nvgpu: gp10b: Make page mapping scatter aware	Terje Bergstrom	2016-12-27
*	gpu: nvgpu: gp10b: update elpg sequencing value	Mahantesh Kumbar	2016-12-27
*	gpu: nvgpu: secure boot flag, default disabled	Mahantesh Kumbar	2016-12-27
*	gpu: nvgpu: gp10b:inherit gm20b acr init wpr func	Mahantesh Kumbar	2016-12-27
*	gpu: nvgpu: gp10b: Implement new page table format	Terje Bergstrom	2016-12-27
*	gpu: nvgpu: set zbc format field properly	Konsta Holtta	2016-12-27
*	gpu: nvgpu: gp10b: fix sparse warnings of static symbol	Deepak Nibade	2016-12-27
*	gpu: nvgpu: gp10b: Fix include path	Alex Van Brunt	2016-12-27
*	gpu: nvgpu: gp10b: Define compressible page size	Terje Bergstrom	2016-12-27
*	gpu: nvgpu: gp10b: Correct steady state CB size	Terje Bergstrom	2016-12-27
*	gpu: nvgpu: gp10b: Program stream id to LTC	Terje Bergstrom	2016-12-27
*	gpu: nvgpu: gp10b: Regenerate HW headers	Terje Bergstrom	2016-12-27
*	gpu: nvgpu: add get_iova_addr() for gp10b	Deepak Nibade	2016-12-27
*	include: uapi: nvgpu: add flag for IO coherence	Deepak Nibade	2016-12-27
*	gpu: nvgpu: gp10b: Do not clear compbit store size	Terje Bergstrom	2016-12-27
*	gpu: nvgpu: zbc: disable activity only from ioctl	Konsta Holtta	2016-12-27
*	gpu: nvgpu: accessor for memfmt exception	Deepak Nibade	2016-12-27
*	gpu: nvgpu: gp10b: Use mem_desc for buffers	Terje Bergstrom	2016-12-27
*	gpu: nvgpu: gp10b: Fix offset for preemption ptr	Terje Bergstrom	2016-12-27
*	gpu: nvgpu: gp10b: Use gp10b version of phys bits	Terje Bergstrom	2016-12-27
*	gpu: nvgpu: add exception registers to dump	Deepak Nibade	2016-12-27
*	gpu: nvgpu: gp10b: fix swdx_rm_spill size and pointer	Kirill Artamonov	2016-12-27
*	gpu: nvgpu: gp10b: Add replayable pagefault buffer	Seshendra Gadagottu	2016-12-27
*	gpu: nvgpu: gp10b: support for replayable faults	Seshendra Gadagottu	2016-12-27
*	gpu: nvgpu: gp10b: setup mm hw init	Seshendra Gadagottu	2016-12-27
*	gpu: nvgpu: gp10b: update fb headers	Seshendra Gadagottu	2016-12-27
*	gpu: nvgpu: gp10b: update headers	Seshendra Gadagottu	2016-12-27

• [prev]
• [next]

generated by cgit v1.2.2 (git 2.25.0) at 2024-10-29 20:28:25 -0400

/*
 * Copyright (c) 2018, NVIDIA CORPORATION.  All rights reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */

#include <stdlib.h>

#include <unit/io.h>
#include <unit/unit.h>

#include <nvgpu/posix/bitops.h>

#define NUM_WORDS 4

static unsigned long single_ulong_maps[] = {
	0UL,
	~0UL,
	0xff00ff00UL,
	0x00ff00ffUL,
	0xa5a5a5a5UL,
	0x0000ffffUL,
	0xffff0000UL,
	0x1UL,
	0x80000000UL,
	BIT(16),
};

/*
 * Can't fail - just some info prints.
 */
static int test_bitmap_info(struct unit_module *m, struct gk20a *g, void *args)
{
	unit_info(m, "sizeof(unsigned long) = %zu\n", sizeof(unsigned long));
	unit_info(m, "BITS_PER_LONG         = %lu\n", BITS_PER_LONG);

	return UNIT_SUCCESS;
}

static int test_ffs(struct unit_module *m, struct gk20a *g, void *args)
{
#define CHECK_FFS_WORD(w, answer)					\
	do {								\
		unsigned long ret = ffs(w);				\
									\
		if (ret != (answer))					\
			unit_return_fail(m,				\
					 "ffs(0x%016lx) = %lu "		\
					 "[expected %lu]\n",		\
					 w, ret, answer);		\
	} while (0)

	unsigned long i;

	CHECK_FFS_WORD(single_ulong_maps[0], BITS_PER_LONG - 1UL);
	CHECK_FFS_WORD(single_ulong_maps[1], 0UL);
	CHECK_FFS_WORD(single_ulong_maps[2], 8UL);
	CHECK_FFS_WORD(single_ulong_maps[3], 0UL);
	CHECK_FFS_WORD(single_ulong_maps[4], 0UL);
	CHECK_FFS_WORD(single_ulong_maps[5], 0UL);
	CHECK_FFS_WORD(single_ulong_maps[6], 16UL);
	CHECK_FFS_WORD(single_ulong_maps[7], 0UL);
	CHECK_FFS_WORD(single_ulong_maps[8], 31UL);
	CHECK_FFS_WORD(single_ulong_maps[9], 16UL);

#undef CHECK_FFS_WORD

	/*
	 * Also just test every bit to make sure we definitely cover all
	 * possible return values of the function.
	 */
	for (i = 0; i < BITS_PER_LONG; i++) {
		if (ffs(BIT(i)) != i)
			unit_return_fail(m, "ffs(1 << %lu) != %lu [%lu]!\n",
					 i, i, ffs(BIT(i)));
	}

	return UNIT_SUCCESS;
}

static int test_fls(struct unit_module *m, struct gk20a *g, void *args)
{
#define CHECK_FLS_WORD(w, answer)					\
	do {								\
		unsigned long ret = fls(w);				\
									\
		if (ret != (answer))					\
			unit_return_fail(m,				\
					 "fls(0x%016lx) = %lu "		\
					 "[expected = %lu]\n",		\
					 w, ret, answer);		\
	} while (0)

	unsigned long i;

	CHECK_FLS_WORD(single_ulong_maps[0], 0UL);
	CHECK_FLS_WORD(single_ulong_maps[1], BITS_PER_LONG - 1UL);
	CHECK_FLS_WORD(single_ulong_maps[2], 31UL);
	CHECK_FLS_WORD(single_ulong_maps[3], 23UL);
	CHECK_FLS_WORD(single_ulong_maps[4], 31UL);
	CHECK_FLS_WORD(single_ulong_maps[5], 15UL);
	CHECK_FLS_WORD(single_ulong_maps[6], 31UL);
	CHECK_FLS_WORD(single_ulong_maps[7], 0UL);
	CHECK_FLS_WORD(single_ulong_maps[8], 31UL);
	CHECK_FLS_WORD(single_ulong_maps[9], 16UL);

#undef CHECK_FLS_WORD

	for (i = 0; i < BITS_PER_LONG; i++) {
		if (fls(BIT(i)) != i)
			unit_return_fail(m, "fls(1 << %lu) != %lu! [%lu]\n",
					 i, i, fls(BIT(i)));
	}

	return UNIT_SUCCESS;
}

static int test_ffz(struct unit_module *m, struct gk20a *g, void *args)
{
	unsigned long i;

	/*
	 * Since ffz(w) is implemented as ffs(~w) this does less extensive
	 * testing; but it should still cover every line of ffs().
	 */

	for (i = 0; i < BITS_PER_LONG; i++) {
		if (ffz(~BIT(i)) != i)
			unit_return_fail(m, "ffz(~(1 << %lu)) != %lu! [%lu]\n",
					 i, i, ffz(BIT(i)));
	}

	return UNIT_SUCCESS;
}

struct test_find_bit_args {
	bool find_zeros;
};

static struct test_find_bit_args first_bit_args = {
	.find_zeros = false
};

static struct test_find_bit_args first_zero_args = {
	.find_zeros = true
};

static int test_find_first_bit(struct unit_module *m,
			       struct gk20a *g, void *__args)
{
	struct test_find_bit_args *args = __args;
	unsigned long words[NUM_WORDS];
	unsigned long word_idx, bit_idx;
	unsigned long (*finder_function)(const unsigned long *, unsigned long);
	unsigned long result;

	if (args->find_zeros)
		finder_function = find_first_zero_bit;
	else
		finder_function = find_first_bit;

	/*
	 * First test: verify that the size parameter works. We only need the
	 * first word for this.
	 */
	words[0] = ~0xffffUL;
	if (args->find_zeros)
		words[0] = 0xffff;

	if (finder_function(words, 8UL) != 8UL)
		unit_return_fail(m,
				 "find_first_%s(0x%lx, 8) -> %lu [WRONG]\n",
				 args->find_zeros ? "zero_bit" : "bit",
				 words[0], finder_function(words, 8UL));

	if (finder_function(words, 20UL) != 16UL)
		unit_return_fail(m,
				 "find_first_%s(0x%lx, 16) -> %lu [WRONG]\n",
				 args->find_zeros ? "zero_bit" : "bit",
				 words[0], finder_function(words, 20UL));

	/*
	 * Now make sure that for full/empty bitmap find_next_*() returns
	 * the size parameter.
	 */
	memset(words, args->find_zeros ? 0xff : 0x00, sizeof(words));
	result = finder_function(words, NUM_WORDS * BITS_PER_LONG);
	if (result != NUM_WORDS * BITS_PER_LONG)
		unit_return_fail(m, "find_first_%s() failed with empty map\n",
				 args->find_zeros ? "zero_bit" : "bit");

	/*
	 * Third test: set (or zero) the entire bitmap and incrementally clear
	 * bits. Check that we are correct even with multiple words.
	 */

	memset(words, args->find_zeros ? 0x00 : 0xff, sizeof(words));
	for (word_idx = 0; word_idx < NUM_WORDS; word_idx++) {
		for (bit_idx = 0; bit_idx < BITS_PER_LONG; bit_idx++) {
			unsigned long check =
				(word_idx * BITS_PER_LONG) + bit_idx;
			unsigned long answer =
				finder_function(words,
						NUM_WORDS * BITS_PER_LONG);

			if (answer != check)
				unit_return_fail(m,
						 "find_first_%s loop: "
						 "word_idx = %lu bit_idx = %lu "
						 "-> %lu [WRONG]\n",
						 args->find_zeros ? "zero_bit" : "bit",
						 word_idx, bit_idx, answer);

			/*
			 * Now set/clear this bit in preparation for the next
			 * test.
			 */
			if (args->find_zeros)
				words[word_idx] |= BIT(bit_idx);
			else
				words[word_idx] &= ~BIT(bit_idx);
		}
	}

	return UNIT_SUCCESS;
}

/*
 * Note: the find_first_bit() test also effectively tests the underlying
 * find_next_bit() code since find_first_bit() is just find_next_bit()
 * with a 0 start.
 */

static int test_find_next_bit(struct unit_module *m,
			      struct gk20a *g, void *__args)
{
	unsigned long words[NUM_WORDS];
	unsigned long i, result;

	/*
	 * Fully unset list. Should always return size.
	 */
	memset(words, 0x00, sizeof(words));
	for (i = 0; i < NUM_WORDS * BITS_PER_LONG; i++) {
		result = find_next_bit(words, NUM_WORDS * BITS_PER_LONG, i);

		if (result != NUM_WORDS * BITS_PER_LONG)
			unit_return_fail(m, "Fail: empty map (%lu)\n", i);
	}

	/*
	 * Use a fully set list but increment the offset.
	 */
	memset(words, 0xff, sizeof(words));
	for (i = 0; i < NUM_WORDS * BITS_PER_LONG; i++) {
		unsigned long first =
			find_next_bit(words, NUM_WORDS * BITS_PER_LONG, i);

		if (first != i)
			unit_return_fail(m,
					 "Fail: first = %lu; should be %lu\n",
					 first, i);
	}

	/*
	 * Start > n should return n.
	 */
#define TEST_START_GREATER_THAN_N(m, map, n, start)			\
	do {								\
		if (find_next_bit(map, n, start) != n)			\
			unit_return_fail(m,				\
					 "Start not greater than N ?? "	\
					 "start=%lu, N=%lu\n",		\
					 start, n);			\
	} while (0)

	TEST_START_GREATER_THAN_N(m, words, BITS_PER_LONG, BITS_PER_LONG + 1);
	TEST_START_GREATER_THAN_N(m, words, 32UL, 64UL);
	TEST_START_GREATER_THAN_N(m, words,
				  BITS_PER_LONG * 2, (BITS_PER_LONG * 2) + 1);
	TEST_START_GREATER_THAN_N(m, words, 0UL, 1UL);
	TEST_START_GREATER_THAN_N(m, words, 0UL, BITS_PER_LONG * 2);
	TEST_START_GREATER_THAN_N(m, words, 0UL, BITS_PER_LONG * NUM_WORDS + 1);

#undef TEST_START_GREATER_THAN_N

	return UNIT_SUCCESS;
}

#define TEST_BITMAP_SIZE (BITS_PER_LONG * 4)
/*
 * 32/64 bit invarient.
 */
static DECLARE_BITMAP(bmap_all_zeros, TEST_BITMAP_SIZE) =
{
	0x0UL, 0x0UL, 0x0UL, 0x0UL
};
static DECLARE_BITMAP(bmap_all_ones, TEST_BITMAP_SIZE) =
{
	~0x0UL, ~0x0UL, ~0x0UL, ~0x0UL
};

static int test_find_zero_area(struct unit_module *m,
			       struct gk20a *g, void *unused)
{
#define FAIL_MSG "Fail: bmap-test='%s' (i=%lu)\n"
#define FAIL_MSG_EX "Fail: bmap-test='%s' (i=%lu, j=%lu)\n"
	unsigned long i, j, result;
	unsigned long words[NUM_WORDS];

	for (i = 0; i < TEST_BITMAP_SIZE; i++) {
		result = bitmap_find_next_zero_area_off(bmap_all_zeros,
							TEST_BITMAP_SIZE,
							i,
							TEST_BITMAP_SIZE - i,
							0, 0);
		if (result != i)
			unit_return_fail(m, FAIL_MSG,
					 "all_zeros: alloc-to-end", i);

		result = bitmap_find_next_zero_area_off(bmap_all_zeros,
							TEST_BITMAP_SIZE,
							i,
							1,
							0, 0);
		if (result != i)
			unit_return_fail(m, FAIL_MSG,
					 "all_zeros: alloc-one-bit", i);

		result = bitmap_find_next_zero_area_off(bmap_all_zeros,
							TEST_BITMAP_SIZE,
							0,
							TEST_BITMAP_SIZE - i,
							0, 0);
		if (result != 0)
			unit_return_fail(m, FAIL_MSG,
					 "all_zeros: alloc-i-bits-at-0", i);
	}

	/*
	 * For the all ones bit map not a single alloc should succeed. We can
	 * just iterate through them all and make sure they all fail.
	 */
	for (i = 0; i < TEST_BITMAP_SIZE; i++) {
		for (j = 0; j < (TEST_BITMAP_SIZE - i); j++) {
			result = bitmap_find_next_zero_area_off(bmap_all_ones,
							TEST_BITMAP_SIZE,
							i,
							j,
							0, 0);
			if (result != TEST_BITMAP_SIZE)
				unit_return_fail(m, FAIL_MSG_EX,
						 "all_ones: failed", i, j);
		}
	}

	/*
	 * Alternating nibbles (4 bits). Make sure we don't start searching from
	 * too high in the bitmap since that will cause failures that are
	 * actually valid. This keeps the logic in the below loop a little more
	 * simple.
	 */