[people/ms/u-boot.git] / test / dm / rtc.c

/*
 * Copyright (C) 2015 Google, Inc
 *
 * SPDX-License-Identifier:	GPL-2.0+
 * Written by Simon Glass <sjg@chromium.org>
 */

#include <common.h>
#include <dm.h>
#include <rtc.h>
#include <asm/io.h>
#include <asm/test.h>
#include <dm/test.h>
#include <test/ut.h>

/* Simple RTC sanity check */
static int dm_test_rtc_base(struct unit_test_state *uts)
{
	struct udevice *dev;

	ut_asserteq(-ENODEV, uclass_get_device_by_seq(UCLASS_RTC, 2, &dev));
	ut_assertok(uclass_get_device(UCLASS_RTC, 0, &dev));
	ut_assertok(uclass_get_device(UCLASS_RTC, 1, &dev));

	return 0;
}
DM_TEST(dm_test_rtc_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);

static void show_time(const char *msg, struct rtc_time *time)
{
	printf("%s: %02d/%02d/%04d %02d:%02d:%02d\n", msg,
	       time->tm_mday, time->tm_mon, time->tm_year,
	       time->tm_hour, time->tm_min, time->tm_sec);
}

static int cmp_times(struct rtc_time *expect, struct rtc_time *time, bool show)
{
	bool same;

	same = expect->tm_sec == time->tm_sec;
	same &= expect->tm_min == time->tm_min;
	same &= expect->tm_hour == time->tm_hour;
	same &= expect->tm_mday == time->tm_mday;
	same &= expect->tm_mon == time->tm_mon;
	same &= expect->tm_year == time->tm_year;
	if (!same && show) {
		show_time("expected", expect);
		show_time("actual", time);
	}

	return same ? 0 : -EINVAL;
}

/* Set and get the time */
static int dm_test_rtc_set_get(struct unit_test_state *uts)
{
	struct rtc_time now, time, cmp;
	struct udevice *dev, *emul;
	long offset, old_offset, old_base_time;

	ut_assertok(uclass_get_device(UCLASS_RTC, 0, &dev));
	ut_assertok(dm_rtc_get(dev, &now));

	ut_assertok(device_find_first_child(dev, &emul));
	ut_assert(emul != NULL);

	/* Tell the RTC to go into manual mode */
	old_offset = sandbox_i2c_rtc_set_offset(emul, false, 0);
	old_base_time = sandbox_i2c_rtc_get_set_base_time(emul, -1);

	memset(&time, '\0', sizeof(time));
	time.tm_mday = 25;
	time.tm_mon = 8;
	time.tm_year = 2004;
	time.tm_sec = 0;
	time.tm_min = 18;
	time.tm_hour = 18;
	ut_assertok(dm_rtc_set(dev, &time));

	memset(&cmp, '\0', sizeof(cmp));
	ut_assertok(dm_rtc_get(dev, &cmp));
	ut_assertok(cmp_times(&time, &cmp, true));

	/* Increment by 1 second */
	offset = sandbox_i2c_rtc_set_offset(emul, false, 0);
	sandbox_i2c_rtc_set_offset(emul, false, offset + 1);

	memset(&cmp, '\0', sizeof(cmp));
	ut_assertok(dm_rtc_get(dev, &cmp));
	ut_asserteq(1, cmp.tm_sec);

	/* Check against original offset */
	sandbox_i2c_rtc_set_offset(emul, false, old_offset);
	ut_assertok(dm_rtc_get(dev, &cmp));
	ut_assertok(cmp_times(&now, &cmp, true));

	/* Back to the original offset */
	sandbox_i2c_rtc_set_offset(emul, false, 0);
	memset(&cmp, '\0', sizeof(cmp));
	ut_assertok(dm_rtc_get(dev, &cmp));
	ut_assertok(cmp_times(&now, &cmp, true));

	/* Increment the base time by 1 emul */
	sandbox_i2c_rtc_get_set_base_time(emul, old_base_time + 1);
	memset(&cmp, '\0', sizeof(cmp));
	ut_assertok(dm_rtc_get(dev, &cmp));
	if (now.tm_sec == 59) {
		ut_asserteq(0, cmp.tm_sec);
	} else {
		ut_asserteq(now.tm_sec + 1, cmp.tm_sec);
	}

	old_offset = sandbox_i2c_rtc_set_offset(emul, true, 0);

	return 0;
}
DM_TEST(dm_test_rtc_set_get, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);

/* Reset the time */
static int dm_test_rtc_reset(struct unit_test_state *uts)
{
	struct rtc_time now;
	struct udevice *dev, *emul;
	long old_base_time, base_time;

	ut_assertok(uclass_get_device(UCLASS_RTC, 0, &dev));
	ut_assertok(dm_rtc_get(dev, &now));

	ut_assertok(device_find_first_child(dev, &emul));
	ut_assert(emul != NULL);

	old_base_time = sandbox_i2c_rtc_get_set_base_time(emul, 0);

	ut_asserteq(0, sandbox_i2c_rtc_get_set_base_time(emul, -1));

	/* Resetting the RTC should put he base time back to normal */
	ut_assertok(dm_rtc_reset(dev));
	base_time = sandbox_i2c_rtc_get_set_base_time(emul, -1);
	ut_asserteq(old_base_time, base_time);

	return 0;
}
DM_TEST(dm_test_rtc_reset, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);

/* Check that two RTC devices can be used independently */
static int dm_test_rtc_dual(struct unit_test_state *uts)
{
	struct rtc_time now1, now2, cmp;
	struct udevice *dev1, *dev2;
	struct udevice *emul1, *emul2;
	long offset;

	ut_assertok(uclass_get_device(UCLASS_RTC, 0, &dev1));
	ut_assertok(dm_rtc_get(dev1, &now1));
	ut_assertok(uclass_get_device(UCLASS_RTC, 1, &dev2));
	ut_assertok(dm_rtc_get(dev2, &now2));

	ut_assertok(device_find_first_child(dev1, &emul1));
	ut_assert(emul1 != NULL);
	ut_assertok(device_find_first_child(dev2, &emul2));
	ut_assert(emul2 != NULL);

	offset = sandbox_i2c_rtc_set_offset(emul1, false, -1);
	sandbox_i2c_rtc_set_offset(emul2, false, offset + 1);
	memset(&cmp, '\0', sizeof(cmp));
	ut_assertok(dm_rtc_get(dev2, &cmp));
	ut_asserteq(-EINVAL, cmp_times(&now1, &cmp, false));

	memset(&cmp, '\0', sizeof(cmp));
	ut_assertok(dm_rtc_get(dev1, &cmp));
	ut_assertok(cmp_times(&now1, &cmp, true));

	return 0;
}
DM_TEST(dm_test_rtc_dual, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
Commit	Line	Data
47725114 SG	1	/*
	2	* Copyright (C) 2015 Google, Inc
	3	*
	4	* SPDX-License-Identifier: GPL-2.0+
	5	* Written by Simon Glass <sjg@chromium.org>
	6	*/
	7
	8	#include <common.h>
	9	#include <dm.h>
	10	#include <rtc.h>
	11	#include <asm/io.h>
47725114	12	#include <asm/test.h>
e721b882 JH	13	#include <dm/test.h>
e721b882 JH	14	#include <test/ut.h>
47725114 SG	15
47725114 SG	16	/* Simple RTC sanity check */
e721b882	17	static int dm_test_rtc_base(struct unit_test_state *uts)
47725114 SG	18	{
	19	struct udevice *dev;
	20
	21	ut_asserteq(-ENODEV, uclass_get_device_by_seq(UCLASS_RTC, 2, &dev));
	22	ut_assertok(uclass_get_device(UCLASS_RTC, 0, &dev));
	23	ut_assertok(uclass_get_device(UCLASS_RTC, 1, &dev));
	24
	25	return 0;
	26	}
	27	DM_TEST(dm_test_rtc_base, DM_TESTF_SCAN_PDATA \| DM_TESTF_SCAN_FDT);
	28
	29	static void show_time(const char msg, struct rtc_time time)
	30	{
	31	printf("%s: %02d/%02d/%04d %02d:%02d:%02d\n", msg,
	32	time->tm_mday, time->tm_mon, time->tm_year,
	33	time->tm_hour, time->tm_min, time->tm_sec);
	34	}
	35
	36	static int cmp_times(struct rtc_time expect, struct rtc_time time, bool show)
	37	{
	38	bool same;
	39
	40	same = expect->tm_sec == time->tm_sec;
	41	same &= expect->tm_min == time->tm_min;
	42	same &= expect->tm_hour == time->tm_hour;
	43	same &= expect->tm_mday == time->tm_mday;
	44	same &= expect->tm_mon == time->tm_mon;
	45	same &= expect->tm_year == time->tm_year;
	46	if (!same && show) {
	47	show_time("expected", expect);
	48	show_time("actual", time);
	49	}
	50
	51	return same ? 0 : -EINVAL;
	52	}
	53
	54	/* Set and get the time */
e721b882	55	static int dm_test_rtc_set_get(struct unit_test_state *uts)
47725114 SG	56	{
	57	struct rtc_time now, time, cmp;
	58	struct udevice dev, emul;
	59	long offset, old_offset, old_base_time;
	60
	61	ut_assertok(uclass_get_device(UCLASS_RTC, 0, &dev));
	62	ut_assertok(dm_rtc_get(dev, &now));
	63
	64	ut_assertok(device_find_first_child(dev, &emul));
	65	ut_assert(emul != NULL);
	66
	67	/* Tell the RTC to go into manual mode */
	68	old_offset = sandbox_i2c_rtc_set_offset(emul, false, 0);
	69	old_base_time = sandbox_i2c_rtc_get_set_base_time(emul, -1);
	70
	71	memset(&time, '\0', sizeof(time));
	72	time.tm_mday = 25;
	73	time.tm_mon = 8;
	74	time.tm_year = 2004;
	75	time.tm_sec = 0;
	76	time.tm_min = 18;
	77	time.tm_hour = 18;
	78	ut_assertok(dm_rtc_set(dev, &time));
	79
	80	memset(&cmp, '\0', sizeof(cmp));
	81	ut_assertok(dm_rtc_get(dev, &cmp));
	82	ut_assertok(cmp_times(&time, &cmp, true));
	83
	84	/* Increment by 1 second */
	85	offset = sandbox_i2c_rtc_set_offset(emul, false, 0);
	86	sandbox_i2c_rtc_set_offset(emul, false, offset + 1);
	87
	88	memset(&cmp, '\0', sizeof(cmp));
	89	ut_assertok(dm_rtc_get(dev, &cmp));
	90	ut_asserteq(1, cmp.tm_sec);
	91
	92	/* Check against original offset */
	93	sandbox_i2c_rtc_set_offset(emul, false, old_offset);
	94	ut_assertok(dm_rtc_get(dev, &cmp));
	95	ut_assertok(cmp_times(&now, &cmp, true));
	96
	97	/* Back to the original offset */
	98	sandbox_i2c_rtc_set_offset(emul, false, 0);
	99	memset(&cmp, '\0', sizeof(cmp));
	100	ut_assertok(dm_rtc_get(dev, &cmp));
	101	ut_assertok(cmp_times(&now, &cmp, true));
	102
	103	/* Increment the base time by 1 emul */
	104	sandbox_i2c_rtc_get_set_base_time(emul, old_base_time + 1);
	105	memset(&cmp, '\0', sizeof(cmp));
	106	ut_assertok(dm_rtc_get(dev, &cmp));
	107	if (now.tm_sec == 59) {
	108	ut_asserteq(0, cmp.tm_sec);
	109	} else {
	110	ut_asserteq(now.tm_sec + 1, cmp.tm_sec);
	111	}
	112
	113	old_offset = sandbox_i2c_rtc_set_offset(emul, true, 0);
	114
	115	return 0;
	116	}
	117	DM_TEST(dm_test_rtc_set_get, DM_TESTF_SCAN_PDATA \| DM_TESTF_SCAN_FDT);
	118
	119	/* Reset the time */
e721b882	120	static int dm_test_rtc_reset(struct unit_test_state *uts)
47725114 SG	121	{
	122	struct rtc_time now;
	123	struct udevice dev, emul;
	124	long old_base_time, base_time;
	125
	126	ut_assertok(uclass_get_device(UCLASS_RTC, 0, &dev));
	127	ut_assertok(dm_rtc_get(dev, &now));
	128
	129	ut_assertok(device_find_first_child(dev, &emul));
	130	ut_assert(emul != NULL);
	131
	132	old_base_time = sandbox_i2c_rtc_get_set_base_time(emul, 0);
	133
	134	ut_asserteq(0, sandbox_i2c_rtc_get_set_base_time(emul, -1));
	135
	136	/* Resetting the RTC should put he base time back to normal */
	137	ut_assertok(dm_rtc_reset(dev));
	138	base_time = sandbox_i2c_rtc_get_set_base_time(emul, -1);
	139	ut_asserteq(old_base_time, base_time);
	140
	141	return 0;
	142	}
	143	DM_TEST(dm_test_rtc_reset, DM_TESTF_SCAN_PDATA \| DM_TESTF_SCAN_FDT);
	144
	145	/* Check that two RTC devices can be used independently */
e721b882	146	static int dm_test_rtc_dual(struct unit_test_state *uts)
47725114 SG	147	{
	148	struct rtc_time now1, now2, cmp;
	149	struct udevice dev1, dev2;
	150	struct udevice emul1, emul2;
	151	long offset;
	152
	153	ut_assertok(uclass_get_device(UCLASS_RTC, 0, &dev1));
	154	ut_assertok(dm_rtc_get(dev1, &now1));
	155	ut_assertok(uclass_get_device(UCLASS_RTC, 1, &dev2));
	156	ut_assertok(dm_rtc_get(dev2, &now2));
	157
	158	ut_assertok(device_find_first_child(dev1, &emul1));
	159	ut_assert(emul1 != NULL);
	160	ut_assertok(device_find_first_child(dev2, &emul2));
	161	ut_assert(emul2 != NULL);
	162
	163	offset = sandbox_i2c_rtc_set_offset(emul1, false, -1);
	164	sandbox_i2c_rtc_set_offset(emul2, false, offset + 1);
	165	memset(&cmp, '\0', sizeof(cmp));
	166	ut_assertok(dm_rtc_get(dev2, &cmp));
	167	ut_asserteq(-EINVAL, cmp_times(&now1, &cmp, false));
	168
	169	memset(&cmp, '\0', sizeof(cmp));
	170	ut_assertok(dm_rtc_get(dev1, &cmp));
	171	ut_assertok(cmp_times(&now1, &cmp, true));
	172
	173	return 0;
	174	}
	175	DM_TEST(dm_test_rtc_dual, DM_TESTF_SCAN_PDATA \| DM_TESTF_SCAN_FDT);