// SPDX-License-Identifier: GPL-2.0
/*
 * This test covers the functionality of userspace-driven ALSA timers. Such timers
 * are purely virtual (so they don't directly depend on the hardware), and they could be
 * created and triggered by userspace applications.
 *
 * Author: Ivan Orlov <ivan.orlov0322@gmail.com>
 */
#include "kselftest_harness.h"
#include <sound/asound.h>
#include <unistd.h>
#include <fcntl.h>
#include <limits.h>
#include <sys/ioctl.h>
#include <stdlib.h>
#include <pthread.h>
#include <string.h>
#include <errno.h>

#define FRAME_RATE 8000
#define PERIOD_SIZE 4410
#define UTIMER_DEFAULT_ID -1
#define UTIMER_DEFAULT_FD -1
#define NANO 1000000000ULL
#define TICKS_COUNT 10
#define TICKS_RECORDING_DELTA 5
#define TIMER_OUTPUT_BUF_LEN 1024
#define TIMER_FREQ_SEC 1
#define RESULT_PREFIX_LEN strlen("Total ticks count: ")

enum timer_app_event {
	TIMER_APP_STARTED,
	TIMER_APP_RESULT,
	TIMER_NO_EVENT,
};

FIXTURE(timer_f) {
	struct snd_timer_uinfo *utimer_info;
};

FIXTURE_SETUP(timer_f) {
	int timer_dev_fd;

	if (geteuid())
		SKIP(return, "This test needs root to run!");

	self->utimer_info = calloc(1, sizeof(*self->utimer_info));
	ASSERT_NE(NULL, self->utimer_info);

	/* Resolution is the time the period of frames takes in nanoseconds */
	self->utimer_info->resolution = (NANO / FRAME_RATE * PERIOD_SIZE);

	timer_dev_fd = open("/dev/snd/timer", O_RDONLY);
	ASSERT_GE(timer_dev_fd, 0);

	if (ioctl(timer_dev_fd, SNDRV_TIMER_IOCTL_CREATE, self->utimer_info) < 0) {
		int err = errno;

		close(timer_dev_fd);
		if (err == ENOTTY || err == ENXIO)
			SKIP(return, "CONFIG_SND_UTIMER not enabled");
		ASSERT_EQ(err, 0);
	}
	ASSERT_GE(self->utimer_info->fd, 0);

	close(timer_dev_fd);
}

FIXTURE_TEARDOWN(timer_f) {
	close(self->utimer_info->fd);
	free(self->utimer_info);
}

static void *ticking_func(void *data)
{
	int i;
	int *fd = (int *)data;

	for (i = 0; i < TICKS_COUNT; i++) {
		/* Well, trigger the timer! */
		ioctl(*fd, SNDRV_TIMER_IOCTL_TRIGGER, NULL);
		sleep(TIMER_FREQ_SEC);
	}

	return NULL;
}

static enum timer_app_event parse_timer_output(const char *s)
{
	if (strstr(s, "Timer has started"))
		return TIMER_APP_STARTED;
	if (strstr(s, "Total ticks count"))
		return TIMER_APP_RESULT;

	return TIMER_NO_EVENT;
}

static int parse_timer_result(const char *s)
{
	char *end;
	long d;

	d = strtol(s + RESULT_PREFIX_LEN, &end, 10);
	if (end == s + RESULT_PREFIX_LEN)
		return -1;

	return d;
}

/*
 * This test triggers the timer and counts ticks at the same time. The amount
 * of the timer trigger calls should be equal to the amount of ticks received.
 */
TEST_F(timer_f, utimer) {
	char command[64];
	pthread_t ticking_thread;
	int total_ticks = 0;
	FILE *rfp;
	char *buf = malloc(TIMER_OUTPUT_BUF_LEN);

	ASSERT_NE(buf, NULL);

	/* The timeout should be the ticks interval * count of ticks + some delta */
	sprintf(command, "./global-timer %d %d %d", SNDRV_TIMER_GLOBAL_UDRIVEN,
		self->utimer_info->id, TICKS_COUNT * TIMER_FREQ_SEC + TICKS_RECORDING_DELTA);

	rfp = popen(command, "r");
	while (fgets(buf, TIMER_OUTPUT_BUF_LEN, rfp)) {
		buf[TIMER_OUTPUT_BUF_LEN - 1] = 0;
		switch (parse_timer_output(buf)) {
		case TIMER_APP_STARTED:
			/* global-timer waits for timer to trigger, so start the ticking thread */
			pthread_create(&ticking_thread, NULL, ticking_func,
				       &self->utimer_info->fd);
			break;
		case TIMER_APP_RESULT:
			total_ticks = parse_timer_result(buf);
			break;
		case TIMER_NO_EVENT:
			break;
		}
	}
	pthread_join(ticking_thread, NULL);
	ASSERT_EQ(total_ticks, TICKS_COUNT);
	pclose(rfp);
	free(buf);
}

TEST(wrong_timers_test) {
	int timer_dev_fd;
	int utimer_fd;
	struct snd_timer_uinfo wrong_timer = {
		.resolution = 0,
		.id = UTIMER_DEFAULT_ID,
		.fd = UTIMER_DEFAULT_FD,
	};

	timer_dev_fd = open("/dev/snd/timer", O_RDONLY);
	ASSERT_GE(timer_dev_fd, 0);

	utimer_fd = ioctl(timer_dev_fd, SNDRV_TIMER_IOCTL_CREATE, &wrong_timer);
	ASSERT_LT(utimer_fd, 0);
	/* Check that id was not updated */
	ASSERT_EQ(wrong_timer.id, UTIMER_DEFAULT_ID);

	/* Test the NULL as an argument is processed correctly */
	ASSERT_LT(ioctl(timer_dev_fd, SNDRV_TIMER_IOCTL_CREATE, NULL), 0);

	close(timer_dev_fd);
}

TEST_HARNESS_MAIN