Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit d8da8665 authored by Alexandre Belloni's avatar Alexandre Belloni Committed by Shuah Khan (Samsung OSG)
Browse files

selftests: rtc: rework rtctest 



Rework rtctest to use the test harness to better handle skipping tests
(e.g. when alarms are not available). Also, it now handles timeout so it
will not block expecting an alarm that never comes.

Signed-off-by: default avatarAlexandre Belloni <alexandre.belloni@bootlin.com>
Signed-off-by: default avatarShuah Khan (Samsung OSG) <shuah@kernel.org>
parent a12ab9e1

tools/testing/selftests/rtc/rtctest.c

+191 −281
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/*

 *      Real Time Clock Driver Test/Example Program

 *

 *      Compile with:

 *		     gcc -s -Wall -Wstrict-prototypes rtctest.c -o rtctest

 *

 *      Copyright (C) 1996, Paul Gortmaker.

 *

 *      Released under the GNU General Public License, version 2,

 *      included herein by reference.

 * Real Time Clock Driver Test Program

 *

 * Copyright (c) 2018 Alexandre Belloni <alexandre.belloni@bootlin.com>

 */



#include <stdio.h>

#include <errno.h>

#include <fcntl.h>

#include <linux/rtc.h>

#include <stdio.h>

#include <stdlib.h>

#include <sys/ioctl.h>

#include <sys/time.h>

#include <sys/types.h>

#include <fcntl.h>

#include <time.h>

#include <unistd.h>

#include <stdlib.h>

#include <errno.h>



#ifndef ARRAY_SIZE

# define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))

#endif

#include "../kselftest_harness.h"



/*

 * This expects the new RTC class driver framework, working with

 * clocks that will often not be clones of what the PC-AT had.

 * Use the command line to specify another RTC if you need one.

 */

static const char default_rtc[] = "/dev/rtc0";

#define NUM_UIE 3

#define ALARM_DELTA 3



static struct rtc_time cutoff_dates[] = {

	{

		.tm_year = 70, /* 1970 -1900 */

		.tm_mday = 1,

	},

	/* signed time_t 19/01/2038 3:14:08 */

	{

		.tm_year = 138,

		.tm_mday = 19,

	},

	{

		.tm_year = 138,

		.tm_mday = 20,

	},

	{

		.tm_year = 199, /* 2099 -1900 */

		.tm_mday = 1,

	},

	{

		.tm_year = 200, /* 2100 -1900 */

		.tm_mday = 1,

	},

	/* unsigned time_t 07/02/2106 7:28:15*/

	{

		.tm_year = 205,

		.tm_mon = 1,

		.tm_mday = 7,

	},

	{

		.tm_year = 206,

		.tm_mon = 1,

		.tm_mday = 8,

	},

	/* signed time on 64bit in nanoseconds 12/04/2262 01:47:16*/

	{

		.tm_year = 362,

		.tm_mon = 3,

		.tm_mday = 12,

	},

	{

		.tm_year = 362, /* 2262 -1900 */

		.tm_mon = 3,

		.tm_mday = 13,

	},

static char *rtc_file = "/dev/rtc0";



FIXTURE(rtc) {

	int fd;

};



static int compare_dates(struct rtc_time *a, struct rtc_time *b)

{

	if (a->tm_year != b->tm_year ||

	    a->tm_mon != b->tm_mon ||

	    a->tm_mday != b->tm_mday ||

	    a->tm_hour != b->tm_hour ||

	    a->tm_min != b->tm_min ||

	    ((b->tm_sec - a->tm_sec) > 1))

		return 1;

FIXTURE_SETUP(rtc) {

	self->fd = open(rtc_file, O_RDONLY);

	ASSERT_NE(-1, self->fd);

}



	return 0;

FIXTURE_TEARDOWN(rtc) {

	close(self->fd);

}



int main(int argc, char **argv)

{

	int i, fd, retval, irqcount = 0, dangerous = 0;

	unsigned long data;

TEST_F(rtc, date_read) {

	int rc;

	struct rtc_time rtc_tm;

	const char *rtc = default_rtc;



	switch (argc) {

	case 3:

		if (*argv[2] == 'd')

			dangerous = 1;

	case 2:

		rtc = argv[1];

		/* FALLTHROUGH */

	case 1:

		break;

	default:

		fprintf(stderr, "usage:  rtctest [rtcdev] [d]\n");

		return 1;

	}



	fd = open(rtc, O_RDONLY);

	/* Read the RTC time/date */

	rc = ioctl(self->fd, RTC_RD_TIME, &rtc_tm);

	ASSERT_NE(-1, rc);



	if (fd ==  -1) {

		perror(rtc);

		exit(errno);

	TH_LOG("Current RTC date/time is %02d/%02d/%02d %02d:%02d:%02d.",

	       rtc_tm.tm_mday, rtc_tm.tm_mon + 1, rtc_tm.tm_year + 1900,

	       rtc_tm.tm_hour, rtc_tm.tm_min, rtc_tm.tm_sec);

}



	fprintf(stderr, "\n\t\t\tRTC Driver Test Example.\n\n");

TEST_F(rtc, uie_read) {

	int i, rc, irq = 0;

	unsigned long data;



	/* Turn on update interrupts (one per second) */

	retval = ioctl(fd, RTC_UIE_ON, 0);

	if (retval == -1) {

		if (errno == EINVAL) {

			fprintf(stderr,

				"\n...Update IRQs not supported.\n");

			goto test_READ;

		}

		perror("RTC_UIE_ON ioctl");

		exit(errno);

	/* Turn on update interrupts */

	rc = ioctl(self->fd, RTC_UIE_ON, 0);

	if (rc == -1) {

		ASSERT_EQ(EINVAL, errno);

		TH_LOG("skip update IRQs not supported.");

		return;

	}



	fprintf(stderr, "Counting 5 update (1/sec) interrupts from reading %s:",

			rtc);

	fflush(stderr);

	for (i=1; i<6; i++) {

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

		/* This read will block */

		retval = read(fd, &data, sizeof(unsigned long));

		if (retval == -1) {

			perror("read");

			exit(errno);

		rc = read(self->fd, &data, sizeof(data));

		ASSERT_NE(-1, rc);

		irq++;

	}

		fprintf(stderr, " %d",i);

		fflush(stderr);

		irqcount++;



	EXPECT_EQ(NUM_UIE, irq);



	rc = ioctl(self->fd, RTC_UIE_OFF, 0);

	ASSERT_NE(-1, rc);

}



	fprintf(stderr, "\nAgain, from using select(2) on /dev/rtc:");

	fflush(stderr);

	for (i=1; i<6; i++) {

		struct timeval tv = {5, 0};     /* 5 second timeout on select */

TEST_F(rtc, uie_select) {

	int i, rc, irq = 0;

	unsigned long data;



	/* Turn on update interrupts */

	rc = ioctl(self->fd, RTC_UIE_ON, 0);

	if (rc == -1) {

		ASSERT_EQ(EINVAL, errno);

		TH_LOG("skip update IRQs not supported.");

		return;

	}



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

		struct timeval tv = { .tv_sec = 2 };

		fd_set readfds;



		FD_ZERO(&readfds);

		FD_SET(fd, &readfds);

		FD_SET(self->fd, &readfds);

		/* The select will wait until an RTC interrupt happens. */

		retval = select(fd+1, &readfds, NULL, NULL, &tv);

		if (retval == -1) {

		        perror("select");

		        exit(errno);

		}

		/* This read won't block unlike the select-less case above. */

		retval = read(fd, &data, sizeof(unsigned long));

		if (retval == -1) {

		        perror("read");

		        exit(errno);

		}

		fprintf(stderr, " %d",i);

		fflush(stderr);

		irqcount++;

	}

		rc = select(self->fd + 1, &readfds, NULL, NULL, &tv);

		ASSERT_NE(-1, rc);

		ASSERT_NE(0, rc);



	/* Turn off update interrupts */

	retval = ioctl(fd, RTC_UIE_OFF, 0);

	if (retval == -1) {

		perror("RTC_UIE_OFF ioctl");

		exit(errno);

		/* This read won't block */

		rc = read(self->fd, &data, sizeof(unsigned long));

		ASSERT_NE(-1, rc);

		irq++;

	}



test_READ:

	/* Read the RTC time/date */

	retval = ioctl(fd, RTC_RD_TIME, &rtc_tm);

	if (retval == -1) {

		perror("RTC_RD_TIME ioctl");

		exit(errno);

	EXPECT_EQ(NUM_UIE, irq);



	rc = ioctl(self->fd, RTC_UIE_OFF, 0);

	ASSERT_NE(-1, rc);

}



	fprintf(stderr, "\n\nCurrent RTC date/time is %d-%d-%d, %02d:%02d:%02d.\n",

		rtc_tm.tm_mday, rtc_tm.tm_mon + 1, rtc_tm.tm_year + 1900,

		rtc_tm.tm_hour, rtc_tm.tm_min, rtc_tm.tm_sec);

TEST_F(rtc, alarm_alm_set) {

	struct timeval tv = { .tv_sec = ALARM_DELTA + 2 };

	unsigned long data;

	struct rtc_time tm;

	fd_set readfds;

	time_t secs, new;

	int rc;



	/* Set the alarm to 5 sec in the future, and check for rollover */

	rtc_tm.tm_sec += 5;

	if (rtc_tm.tm_sec >= 60) {

		rtc_tm.tm_sec %= 60;

		rtc_tm.tm_min++;

	}

	if (rtc_tm.tm_min == 60) {

		rtc_tm.tm_min = 0;

		rtc_tm.tm_hour++;

	}

	if (rtc_tm.tm_hour == 24)

		rtc_tm.tm_hour = 0;



	retval = ioctl(fd, RTC_ALM_SET, &rtc_tm);

	if (retval == -1) {

		if (errno == EINVAL) {

			fprintf(stderr,

				"\n...Alarm IRQs not supported.\n");

			goto test_DATE;

		}

	rc = ioctl(self->fd, RTC_RD_TIME, &tm);

	ASSERT_NE(-1, rc);



		perror("RTC_ALM_SET ioctl");

		exit(errno);

	}

	secs = timegm((struct tm *)&tm) + ALARM_DELTA;

	gmtime_r(&secs, (struct tm *)&tm);



	/* Read the current alarm settings */

	retval = ioctl(fd, RTC_ALM_READ, &rtc_tm);

	if (retval == -1) {

		if (errno == EINVAL) {

			fprintf(stderr,

					"\n...EINVAL reading current alarm setting.\n");

			goto test_DATE;

		}

		perror("RTC_ALM_READ ioctl");

		exit(errno);

	rc = ioctl(self->fd, RTC_ALM_SET, &tm);

	if (rc == -1) {

		ASSERT_EQ(EINVAL, errno);

		TH_LOG("skip alarms are not supported.");

		return;

	}



	fprintf(stderr, "Alarm time now set to %02d:%02d:%02d.\n",

		rtc_tm.tm_hour, rtc_tm.tm_min, rtc_tm.tm_sec);

	rc = ioctl(self->fd, RTC_ALM_READ, &tm);

	ASSERT_NE(-1, rc);



	TH_LOG("Alarm time now set to %02d:%02d:%02d.",

	       tm.tm_hour, tm.tm_min, tm.tm_sec);



	/* Enable alarm interrupts */

	retval = ioctl(fd, RTC_AIE_ON, 0);

	if (retval == -1) {

		if (errno == EINVAL || errno == EIO) {

			fprintf(stderr,

				"\n...Alarm IRQs not supported.\n");

			goto test_DATE;

		}

	rc = ioctl(self->fd, RTC_AIE_ON, 0);

	ASSERT_NE(-1, rc);



		perror("RTC_AIE_ON ioctl");

		exit(errno);

	}

	FD_ZERO(&readfds);

	FD_SET(self->fd, &readfds);



	fprintf(stderr, "Waiting 5 seconds for alarm...");

	fflush(stderr);

	/* This blocks until the alarm ring causes an interrupt */

	retval = read(fd, &data, sizeof(unsigned long));

	if (retval == -1) {

		perror("read");

		exit(errno);

	}

	irqcount++;

	fprintf(stderr, " okay. Alarm rang.\n");

	rc = select(self->fd + 1, &readfds, NULL, NULL, &tv);

	ASSERT_NE(-1, rc);

	EXPECT_NE(0, rc);



	/* Disable alarm interrupts */

	retval = ioctl(fd, RTC_AIE_OFF, 0);

	if (retval == -1) {

		perror("RTC_AIE_OFF ioctl");

		exit(errno);

	}

	rc = ioctl(self->fd, RTC_AIE_OFF, 0);

	ASSERT_NE(-1, rc);



test_DATE:

	if (!dangerous)

		goto done;

	if (rc == 0)

		return;



	fprintf(stderr, "\nTesting problematic dates\n");

	rc = read(self->fd, &data, sizeof(unsigned long));

	ASSERT_NE(-1, rc);

	TH_LOG("data: %lx", data);



	for (i = 0; i < ARRAY_SIZE(cutoff_dates); i++) {

		struct rtc_time current;

	rc = ioctl(self->fd, RTC_RD_TIME, &tm);

	ASSERT_NE(-1, rc);



		/* Write the new date in RTC */

		retval = ioctl(fd, RTC_SET_TIME, &cutoff_dates[i]);

		if (retval == -1) {

			perror("RTC_SET_TIME ioctl");

			close(fd);

			exit(errno);

	new = timegm((struct tm *)&tm);

	ASSERT_EQ(new, secs);

}



		/* Read back */

		retval = ioctl(fd, RTC_RD_TIME, &current);

		if (retval == -1) {

			perror("RTC_RD_TIME ioctl");

			exit(errno);

		}

TEST_F(rtc, alarm_wkalm_set) {

	struct timeval tv = { .tv_sec = ALARM_DELTA + 2 };

	struct rtc_wkalrm alarm = { 0 };

	struct rtc_time tm;

	unsigned long data;

	fd_set readfds;

	time_t secs, new;

	int rc;



		if(compare_dates(&cutoff_dates[i], &current)) {

			fprintf(stderr,"Setting date %d failed\n",

			        cutoff_dates[i].tm_year + 1900);

			goto done;

		}

	rc = ioctl(self->fd, RTC_RD_TIME, &alarm.time);

	ASSERT_NE(-1, rc);



		cutoff_dates[i].tm_sec += 5;

	secs = timegm((struct tm *)&alarm.time) + ALARM_DELTA;

	gmtime_r(&secs, (struct tm *)&alarm.time);



		/* Write the new alarm in RTC */

		retval = ioctl(fd, RTC_ALM_SET, &cutoff_dates[i]);

		if (retval == -1) {

			perror("RTC_ALM_SET ioctl");

			close(fd);

			exit(errno);

		}

	alarm.enabled = 1;



		/* Read back */

		retval = ioctl(fd, RTC_ALM_READ, &current);

		if (retval == -1) {

			perror("RTC_ALM_READ ioctl");

			exit(errno);

	rc = ioctl(self->fd, RTC_WKALM_SET, &alarm);

	if (rc == -1) {

		ASSERT_EQ(EINVAL, errno);

		TH_LOG("skip alarms are not supported.");

		return;

	}



		if(compare_dates(&cutoff_dates[i], &current)) {

			fprintf(stderr,"Setting alarm %d failed\n",

			        cutoff_dates[i].tm_year + 1900);

			goto done;

	rc = ioctl(self->fd, RTC_WKALM_RD, &alarm);

	ASSERT_NE(-1, rc);



	TH_LOG("Alarm time now set to %02d/%02d/%02d %02d:%02d:%02d.",

	       alarm.time.tm_mday, alarm.time.tm_mon + 1,

	       alarm.time.tm_year + 1900, alarm.time.tm_hour,

	       alarm.time.tm_min, alarm.time.tm_sec);



	FD_ZERO(&readfds);

	FD_SET(self->fd, &readfds);



	rc = select(self->fd + 1, &readfds, NULL, NULL, &tv);

	ASSERT_NE(-1, rc);

	EXPECT_NE(0, rc);



	rc = read(self->fd, &data, sizeof(unsigned long));

	ASSERT_NE(-1, rc);



	rc = ioctl(self->fd, RTC_RD_TIME, &tm);

	ASSERT_NE(-1, rc);



	new = timegm((struct tm *)&tm);

	ASSERT_EQ(new, secs);

}



		fprintf(stderr, "Setting year %d is OK \n",

			cutoff_dates[i].tm_year + 1900);

static void __attribute__((constructor))

__constructor_order_last(void)

{

	if (!__constructor_order)

		__constructor_order = _CONSTRUCTOR_ORDER_BACKWARD;

}

done:

	fprintf(stderr, "\n\n\t\t\t *** Test complete ***\n");



	close(fd);

int main(int argc, char **argv)

{

	switch (argc) {

	case 2:

		rtc_file = argv[1];

		/* FALLTHROUGH */

	case 1:

		break;

	default:

		fprintf(stderr, "usage: %s [rtcdev]\n", argv[0]);

		return 1;

	}



	return 0;

	return test_harness_run(argc, argv);

}