[J-u-boot.git] / test / time_ut.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright (c) 2015 Google, Inc
 * Written by Simon Glass <[email protected]>
 */

#include <common.h>
#include <command.h>
#include <errno.h>
#include <time.h>
#include <linux/delay.h>

static int test_get_timer(void)
{
	ulong base, start, next, diff;
	int iter;

	base = get_timer(0);
	start = get_timer(0);
	for (iter = 0; iter < 10; iter++) {
		do {
			next = get_timer(0);
		} while (start == next);

		if (start + 1 != next) {
			printf("%s: iter=%d, start=%lu, next=%lu, expected a difference of 1\n",
			       __func__, iter, start, next);
			return -EINVAL;
		}
		start++;
	}

	/*
	 * Check that get_timer(base) matches our elapsed time, allowing that
	 * an extra millisecond may have passed.
	 */
	diff = get_timer(base);
	if (diff != iter && diff != iter + 1) {
		printf("%s: expected get_timer(base) to match elapsed time: diff=%lu, expected=%d\n",
		       __func__, diff, iter);
			return -EINVAL;
	}

	return 0;
}

static int test_timer_get_us(void)
{
	ulong prev, next, min = 1000000;
	long delta;
	int iter;

	/* Find the minimum delta we can measure, in microseconds */
	prev = timer_get_us();
	for (iter = 0; iter < 100; ) {
		next = timer_get_us();
		if (next != prev) {
			delta = next - prev;
			if (delta < 0) {
				printf("%s: timer_get_us() went backwards from %lu to %lu\n",
				       __func__, prev, next);
				return -EINVAL;
			} else if (delta != 0) {
				if (delta < min)
					min = delta;
				prev = next;
				iter++;
			}
		}
	}

	if (min != 1) {
		printf("%s: Minimum microsecond delta should be 1 but is %lu\n",
		       __func__, min);
		return -EINVAL;
	}

	return 0;
}

static int test_time_comparison(void)
{
	ulong start_us, end_us, delta_us;
	long error;
	ulong start;

	start = get_timer(0);
	start_us = timer_get_us();
	while (get_timer(start) < 1000)
		;
	end_us = timer_get_us();
	delta_us = end_us - start_us;
	error = delta_us - 1000000;
	printf("%s: Microsecond time for 1 second: %lu, error = %ld\n",
	       __func__, delta_us, error);
	if (abs(error) > 1000)
		return -EINVAL;

	return 0;
}

static int test_udelay(void)
{
	long error;
	ulong start, delta;
	int iter;

	start = get_timer(0);
	for (iter = 0; iter < 1000; iter++)
		udelay(1000);
	delta = get_timer(start);
	error = delta - 1000;
	printf("%s: Delay time for 1000 udelay(1000): %lu ms, error = %ld\n",
	       __func__, delta, error);
	if (abs(error) > 100)
		return -EINVAL;

	return 0;
}

int do_ut_time(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
	int ret = 0;

	ret |= test_get_timer();
	ret |= test_timer_get_us();
	ret |= test_time_comparison();
	ret |= test_udelay();

	printf("Test %s\n", ret ? "failed" : "passed");

	return ret ? CMD_RET_FAILURE : CMD_RET_SUCCESS;
}
Commit	Line	Data
83d290c5	1	// SPDX-License-Identifier: GPL-2.0+
8271f5d4 SG	2	/*
	3	* Copyright (c) 2015 Google, Inc
	4	* Written by Simon Glass <[email protected]>
8271f5d4 SG	5	*/
	6
	7	#include <common.h>
	8	#include <command.h>
	9	#include <errno.h>
1045315d	10	#include <time.h>
c05ed00a	11	#include <linux/delay.h>
8271f5d4 SG	12
	13	static int test_get_timer(void)
	14	{
	15	ulong base, start, next, diff;
	16	int iter;
	17
	18	base = get_timer(0);
	19	start = get_timer(0);
	20	for (iter = 0; iter < 10; iter++) {
	21	do {
	22	next = get_timer(0);
	23	} while (start == next);
	24
	25	if (start + 1 != next) {
	26	printf("%s: iter=%d, start=%lu, next=%lu, expected a difference of 1\n",
	27	__func__, iter, start, next);
	28	return -EINVAL;
	29	}
	30	start++;
	31	}
	32
	33	/*
	34	* Check that get_timer(base) matches our elapsed time, allowing that
	35	* an extra millisecond may have passed.
	36	*/
	37	diff = get_timer(base);
	38	if (diff != iter && diff != iter + 1) {
	39	printf("%s: expected get_timer(base) to match elapsed time: diff=%lu, expected=%d\n",
	40	__func__, diff, iter);
	41	return -EINVAL;
	42	}
	43
	44	return 0;
	45	}
	46
	47	static int test_timer_get_us(void)
	48	{
	49	ulong prev, next, min = 1000000;
	50	long delta;
	51	int iter;
	52
	53	/* Find the minimum delta we can measure, in microseconds */
	54	prev = timer_get_us();
	55	for (iter = 0; iter < 100; ) {
	56	next = timer_get_us();
	57	if (next != prev) {
	58	delta = next - prev;
	59	if (delta < 0) {
	60	printf("%s: timer_get_us() went backwards from %lu to %lu\n",
	61	__func__, prev, next);
	62	return -EINVAL;
	63	} else if (delta != 0) {
	64	if (delta < min)
	65	min = delta;
	66	prev = next;
	67	iter++;
	68	}
	69	}
	70	}
	71
	72	if (min != 1) {
	73	printf("%s: Minimum microsecond delta should be 1 but is %lu\n",
	74	__func__, min);
	75	return -EINVAL;
76	}
77
78	return 0;
79	}
80
81	static int test_time_comparison(void)
82	{
83	ulong start_us, end_us, delta_us;
84	long error;
85	ulong start;
86
87	start = get_timer(0);
88	start_us = timer_get_us();
89	while (get_timer(start) < 1000)
90	;
91	end_us = timer_get_us();
92	delta_us = end_us - start_us;
93	error = delta_us - 1000000;
94	printf("%s: Microsecond time for 1 second: %lu, error = %ld\n",
95	__func__, delta_us, error);
96	if (abs(error) > 1000)
97	return -EINVAL;
98
99	return 0;
100	}
101
102	static int test_udelay(void)
103	{
104	long error;
105	ulong start, delta;
106	int iter;
107
108	start = get_timer(0);
109	for (iter = 0; iter < 1000; iter++)
110	udelay(1000);
111	delta = get_timer(start);
112	error = delta - 1000;
113	printf("%s: Delay time for 1000 udelay(1000): %lu ms, error = %ld\n",
114	__func__, delta, error);
115	if (abs(error) > 100)
116	return -EINVAL;
117
118	return 0;
119	}
120
09140113	121	int do_ut_time(struct cmd_tbl cmdtp, int flag, int argc, char const argv[])
8271f5d4 SG	122	{
	123	int ret = 0;
	124
	125	ret \|= test_get_timer();
	126	ret \|= test_timer_get_us();
	127	ret \|= test_time_comparison();
	128	ret \|= test_udelay();
	129
	130	printf("Test %s\n", ret ? "failed" : "passed");
	131
	132	return ret ? CMD_RET_FAILURE : CMD_RET_SUCCESS;
	133	}