/*
 * 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 <stdint.h>

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

#include <nvgpu/types.h>

/*
 * Test if the passed type is signed. In the signed case this expression becomes
 *
 *   x = 0;
 *   y = x - 1 = -1
 *
 * And -1 < 0 will be true. In the unsigned case, we rely on wrap around. We
 * have the following
 *
 *   x = 0U
 *   y = x - 1 = ~0 (i.e <TYPE>_MAX)
 *
 * Thus the expression y < x is false.
 */
#define IS_SIGNED_TYPE(__type__)		\
	({					\
		__type__ x = (__type__)0;	\
		__type__ y = x - (__type__)1;	\
		y < x;				\
	})

/*
 * Ensure that our sized types are of the correct size. Assumes an 8bit byte of
 * course.
 */
static int sanity_test_sizes(struct unit_module *m,
			     struct gk20a *g, void *args)
{
	size_t size_u8  = sizeof(u8);
	size_t size_u16 = sizeof(u16);
	size_t size_u32 = sizeof(u32);
	size_t size_u64 = sizeof(u64);
	size_t size_s8  = sizeof(s8);
	size_t size_s16 = sizeof(s16);
	size_t size_s32 = sizeof(s32);
	size_t size_s64 = sizeof(s64);

	/* Unsigned. */
	if (size_u8 != 1U)
		unit_return_fail(m,
				 "sizeof(u8) != 1 byte! (Actual size: %zu)\n",
				 size_u8);
	if (size_u16 != 2U)
		unit_return_fail(m,
				 "sizeof(u16) != 2 bytes! (Actual size: %zu)\n",
				 size_u16);
	if (size_u32 != 4U)
		unit_return_fail(m,
				 "sizeof(u32) != 4 bytes! (Actual size: %zu)\n",
				 size_u32);
	if (size_u64 != 8U)
		unit_return_fail(m,
				 "sizeof(u64) != 8 bytes! (Actual size: %zu)\n",
				 size_u64);

	/* Signed. */
	if (size_s8 != 1U)
		unit_return_fail(m,
				 "sizeof(s8) != 1 byte! (Actual size: %zu)\n",
				 size_s8);
	if (size_s16 != 2U)
		unit_return_fail(m,
				 "sizeof(s16) != 2 bytes! (Actual size: %zu)\n",
				 size_s16);
	if (size_s32 != 4U)
		unit_return_fail(m,
				 "sizeof(s32) != 4 bytes! (Actual size: %zu)\n",
				 size_s32);
	if (size_s64 != 8U)
		unit_return_fail(m,
				 "sizeof(s64) != 8 bytes! (Actual size: %zu)\n",
				 size_s64);

	return UNIT_SUCCESS;
}

/*
 * Make sure that the signed types really are signed and that the unsigned types
 * really are not.
 */
static int sanity_test_signage(struct unit_module *m,
			       struct gk20a *g, void *args)
{

        if (!IS_SIGNED_TYPE(s8))
                unit_return_fail(m, "s8 is not signed!\n");
        if (!IS_SIGNED_TYPE(s16))
                unit_return_fail(m, "s16 is not signed!\n");
        if (!IS_SIGNED_TYPE(s32))
                unit_return_fail(m, "s32 is not signed!\n");
        if (!IS_SIGNED_TYPE(s64))
                unit_return_fail(m, "s64 is not signed!\n");

        if (IS_SIGNED_TYPE(u8))
                unit_return_fail(m, "u8 is signed!\n");
        if (IS_SIGNED_TYPE(u16))
                unit_return_fail(m, "u16 is signed!\n");
        if (IS_SIGNED_TYPE(u32))
                unit_return_fail(m, "u32 is signed!\n");
        if (IS_SIGNED_TYPE(u64))
                unit_return_fail(m, "u64 is signed!\n");

	return UNIT_SUCCESS;
}

/*
 * Ensure that a u64 can hold a pointer since in some places we use a u64 to
 * pass back a pointer value.
 */
static int sanity_test_ptr_in_u64(struct unit_module *m,
				  struct gk20a *g, void *args)
{
	if (sizeof(u64) < sizeof(uintptr_t))
		unit_return_fail(m,
			"u64 size (%zu b) less than pointer size (%zu b)",
			 sizeof(u64), sizeof(uintptr_t));

	return UNIT_SUCCESS;
}

static int sanity_test_endianness(struct unit_module *m,
				  struct gk20a *g, void *args)
{
	u32 i;
	u32 x = 0x12345678;
	u8  *ptr_x_u8  = (u8 *)&x;
	u16 *ptr_x_u16 = (u16 *)&x;

	/*
	 * Print what endianness we have. For now we have not explicitly decided
	 * to support one or the other, but this will have to be determined
	 * eventually.
	 *
	 * We have just been lucky so far.
	 */
	unit_info(m, "u32 x = 0x%x\n", x);
	for (i = 0; i < sizeof(u32) / sizeof(u16); i++) {
		unit_info(m, "  &x + %zu: 0x%04hx\n",
			  i * sizeof(u16), ptr_x_u16[i]);
	}

	unit_info(m, "u32 x = 0x%x\n", x);
	for (i = 0; i < sizeof(u32); i++) {
		unit_info(m, "  &x + %u: 0x%02hhx\n", i, ptr_x_u8[i]);
	}

	switch (ptr_x_u8[0]) {
	case 0x12:
		unit_info(m, "Machine endianness: big\n");
		break;
	case 0x78:
		unit_info(m, "Machine endianness: little\n");
		break;
	default:
		unit_return_fail(m, "Machine endianness: middle/unknown ??\n");
	}

	return UNIT_SUCCESS;
}

struct unit_module_test posix_env_tests[] = {
	UNIT_TEST(sizes,      sanity_test_sizes,   NULL),
	UNIT_TEST(signage,    sanity_test_signage, NULL),
	UNIT_TEST(endianness, sanity_test_endianness, NULL),
	UNIT_TEST(ptr_in_u64, sanity_test_ptr_in_u64, NULL),
};

UNIT_MODULE(posix_env, posix_env_tests, UNIT_PRIO_POSIX_TEST);