/*
 * Copyright (c) 2016 Intel Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */

/**
 * @file
 * @brief Verify zephyr alert send/recv across different contexts
 */

/**
 * @brief Tests for the Alert kernel object
 * @defgroup kernel.alerts
 * @{
 */
#include <ztest.h>
#include <irq_offload.h>

#define TIMEOUT 100
#define STACK_SIZE 512
#define PENDING_MAX 2
#define SEM_INITIAL 0
#define SEM_LIMIT 1

K_SEM_DEFINE(sync_sema, SEM_INITIAL, SEM_LIMIT);

static int alert_handler0(struct k_alert *);
static int alert_handler1(struct k_alert *);

/**TESTPOINT: init via K_ALERT_DEFINE*/
K_ALERT_DEFINE(kalert_pending, alert_handler1, PENDING_MAX);
K_ALERT_DEFINE(kalert_consumed, alert_handler0, PENDING_MAX);

enum handle_type {
	HANDLER_IGNORE,
	HANDLER_DEFAULT,
	HANDLER_0,
	HANDLER_1
};

static K_THREAD_STACK_DEFINE(tstack, STACK_SIZE);
static K_THREAD_STACK_DEFINE(sync_tstack, STACK_SIZE);
__kernel struct k_thread tdata;
__kernel struct k_thread sync_tdata;
__kernel struct k_alert thread_alerts[4];
static struct k_alert *palert;
static enum handle_type htype;
static volatile u32_t handler_executed;
static volatile u32_t handler_val;


/*handlers*/
static int alert_handler0(struct k_alert *alt)
{
	handler_executed++;
	return 0;
}

static int alert_handler1(struct k_alert *alt)
{
	handler_executed++;
	return 1;
}

static void alert_send(void)
{
	/**TESTPOINT: alert send*/
	for (int i = 0; i < PENDING_MAX; i++) {
		k_alert_send(palert);
	}
}

static void alert_recv(void)
{
	int ret;

	switch (htype) {
	case HANDLER_0:
		zassert_equal(handler_executed, PENDING_MAX, NULL);
		/* Fall through */
	case HANDLER_IGNORE:
		ret = k_alert_recv(palert, TIMEOUT);
		zassert_equal(ret, -EAGAIN, NULL);
		break;
	case HANDLER_1:
		zassert_equal(handler_executed, PENDING_MAX, NULL);
		/* Fall through */
	case HANDLER_DEFAULT:
		for (int i = 0; i < PENDING_MAX; i++) {
			/**TESTPOINT: alert recv*/
			ret = k_alert_recv(palert, K_NO_WAIT);
			zassert_false(ret, NULL);
		}
		/**TESTPOINT: alert recv -EAGAIN*/
		ret = k_alert_recv(palert, TIMEOUT);
		zassert_equal(ret, -EAGAIN, NULL);
		/**TESTPOINT: alert recv -EBUSY*/
		ret = k_alert_recv(palert, K_NO_WAIT);
		zassert_equal(ret, -EBUSY, NULL);
	}
}

static void thread_entry(void *p1, void *p2, void *p3)
{
	alert_recv();
}

static void thread_alert(void)
{
	handler_executed = 0;
	/**TESTPOINT: thread-thread sync via alert*/
	k_tid_t tid = k_thread_create(&tdata, tstack, STACK_SIZE,
				      thread_entry, NULL, NULL, NULL,
				      K_PRIO_PREEMPT(0),
				      K_USER | K_INHERIT_PERMS,
				      0);
	alert_send();
	k_sleep(TIMEOUT);
	k_thread_abort(tid);
}

static void tisr_entry(void *p)
{
	alert_send();
}

static void sync_entry(void *p)
{
	k_alert_send(palert);
}

static void isr_alert(void)
{
	handler_executed = 0;
	/**TESTPOINT: thread-isr sync via alert*/
	irq_offload(tisr_entry, NULL);
	k_sleep(TIMEOUT);
	alert_recv();
}

/*test cases*/
void test_thread_alert_default(void)
{
	palert = &thread_alerts[HANDLER_DEFAULT];
	htype = HANDLER_DEFAULT;
	thread_alert();
}

void test_thread_alert_ignore(void)
{
	palert = &thread_alerts[HANDLER_IGNORE];
	htype = HANDLER_IGNORE;
	thread_alert();
}

void test_thread_alert_consumed(void)
{
	/**TESTPOINT: alert handler return 0*/
	palert = &thread_alerts[HANDLER_0];
	htype = HANDLER_0;
	thread_alert();
}

void test_thread_alert_pending(void)
{
	/**TESTPOINT: alert handler return 1*/
	palert = &thread_alerts[HANDLER_1];
	htype = HANDLER_1;
	thread_alert();
}

void test_isr_alert_default(void)
{
	struct k_alert alert;

	/**TESTPOINT: init via k_alert_init*/
	k_alert_init(&alert, K_ALERT_DEFAULT, PENDING_MAX);

	/**TESTPOINT: alert handler default*/
	palert = &alert;
	htype = HANDLER_DEFAULT;
	isr_alert();
}

void test_isr_alert_ignore(void)
{
	/**TESTPOINT: alert handler ignore*/
	struct k_alert alert;

	/**TESTPOINT: init via k_alert_init*/
	k_alert_init(&alert, K_ALERT_IGNORE, PENDING_MAX);
	palert = &alert;
	htype = HANDLER_IGNORE;
	isr_alert();
}

void test_isr_alert_consumed(void)
{
	struct k_alert alert;

	/**TESTPOINT: init via k_alert_init*/
	k_alert_init(&alert, alert_handler0, PENDING_MAX);

	/**TESTPOINT: alert handler return 0*/
	palert = &alert;
	htype = HANDLER_0;
	isr_alert();
}

void test_isr_alert_pending(void)
{
	struct k_alert alert;

	/**TESTPOINT: init via k_alert_init*/
	k_alert_init(&alert, alert_handler1, PENDING_MAX);

	/**TESTPOINT: alert handler return 0*/
	palert = &alert;
	htype = HANDLER_1;
	isr_alert();
}

void test_thread_kinit_alert(void)
{
	palert = &kalert_consumed;
	htype = HANDLER_0;
	thread_alert();
	palert = &kalert_pending;
	htype = HANDLER_1;
	thread_alert();
}

void test_isr_kinit_alert(void)
{
	palert = &kalert_consumed;
	htype = HANDLER_0;
	isr_alert();
	palert = &kalert_pending;
	htype = HANDLER_1;
	isr_alert();
}


/**
 * @brief Test alert_recv(timeout)
 *
 * This test checks alert_recv(timeout) against the following cases:
 *  1. The current task times out while waiting for the event.
 *  2. There is already an event waiting (signalled from a task).
 *  3. The current task must wait on the event until it is signalled
 *     from either another task or an ISR.
 */
void test_thread_alert_timeout(void)
{
	/**TESTPOINT: alert handler ignore*/
	struct k_alert alert;
	int ret, i;

	/**TESTPOINT: init via k_alert_init*/
	k_alert_init(&alert, K_ALERT_DEFAULT, PENDING_MAX);

	palert = &alert;

	ret = k_alert_recv(&alert, TIMEOUT);

	zassert_equal(ret, -EAGAIN, NULL);

	k_alert_send(&alert);

	ret = k_alert_recv(&alert, TIMEOUT);

	zassert_equal(ret, 0, NULL);

	k_sem_give(&sync_sema);

	for (i = 0; i < 2; i++) {
		ret = k_alert_recv(&alert, TIMEOUT);

		zassert_equal(ret, 0, NULL);
	}
}

/**
 * @brief Test alert_recv() against different cases
 *
 * This test checks alert_recv(K_FOREVER) against
 * the following cases:
 *  1. There is already an event waiting (signalled from a task and ISR).
 *  2. The current task must wait on the event until it is signalled
 *     from either another task or an ISR.
 */
void test_thread_alert_wait(void)
{
	/**TESTPOINT: alert handler ignore*/
	struct k_alert alert;
	int ret, i;

	/**TESTPOINT: init via k_alert_init*/
	k_alert_init(&alert, K_ALERT_DEFAULT, PENDING_MAX);

	palert = &alert;

	k_alert_send(&alert);

	ret = k_alert_recv(&alert, K_FOREVER);

	zassert_equal(ret, 0, NULL);

	irq_offload(sync_entry, NULL);

	ret = k_alert_recv(&alert, K_FOREVER);

	zassert_equal(ret, 0, NULL);

	k_sem_give(&sync_sema);

	for (i = 0; i < 2; i++) {
		ret = k_alert_recv(&alert, K_FOREVER);

		zassert_equal(ret, 0, NULL);
	}
}

int event_handler(struct k_alert *alt)
{
	return handler_val;
}

/**
 * @brief Test thread alert handler
 *
 * This test checks that the event handler is set up properly when
 * alert_event_handler_set() is called.  It shows that event handlers
 * are tied to the specified event and that the return value from the
 * handler affects whether the event wakes a task waiting upon that
 * event.
 */
void test_thread_alert_handler(void)
{
	/**TESTPOINT: alert handler ignore*/
	struct k_alert alert;
	int ret;

	/**TESTPOINT: init via k_alert_init*/
	k_alert_init(&alert, event_handler, PENDING_MAX);

	palert = &alert;

	k_sem_give(&sync_sema);

	ret = k_alert_recv(&alert, TIMEOUT);

	zassert_equal(ret, -EAGAIN, NULL);

	k_sem_give(&sync_sema);

	ret = k_alert_recv(&alert, TIMEOUT);

	zassert_equal(ret, 0, NULL);
}


/**
 * Signal various events to a waiting task
 */
void signal_task(void *p1, void *p2, void *p3)
{
	k_sem_init(&sync_sema, 0, 1);

	k_sem_take(&sync_sema, K_FOREVER);
	k_alert_send(palert);
	irq_offload(sync_entry, NULL);

	k_sem_take(&sync_sema, K_FOREVER);
	k_alert_send(palert);
	irq_offload(sync_entry, NULL);

	k_sem_take(&sync_sema, K_FOREVER);
	handler_val = 0;
	k_alert_send(palert);

	k_sem_take(&sync_sema, K_FOREVER);
	handler_val = 1;
	k_alert_send(palert);
}

/*test case main entry*/
void test_main(void)
{
	k_thread_access_grant(k_current_get(), &kalert_pending,
			      &kalert_consumed, &tdata, &tstack,
			      &thread_alerts[HANDLER_DEFAULT],
			      &thread_alerts[HANDLER_IGNORE],
			      &thread_alerts[HANDLER_0],
			      &thread_alerts[HANDLER_1], NULL);

	k_alert_init(&thread_alerts[HANDLER_DEFAULT], K_ALERT_DEFAULT,
		     PENDING_MAX);
	k_alert_init(&thread_alerts[HANDLER_IGNORE], K_ALERT_IGNORE,
		     PENDING_MAX);
	k_alert_init(&thread_alerts[HANDLER_0], alert_handler0, PENDING_MAX);
	k_alert_init(&thread_alerts[HANDLER_1], alert_handler1, PENDING_MAX);

	/**TESTPOINT: thread-thread sync via alert*/
	k_thread_create(&sync_tdata, sync_tstack, STACK_SIZE,
				      signal_task, NULL, NULL, NULL,
				      K_PRIO_PREEMPT(0), 0, 0);

	ztest_test_suite(alert_api,
			 ztest_unit_test(test_thread_alert_timeout),
			 ztest_unit_test(test_thread_alert_wait),
			 ztest_unit_test(test_thread_alert_handler),
			 ztest_user_unit_test(test_thread_alert_default),
			 ztest_user_unit_test(test_thread_alert_ignore),
			 ztest_user_unit_test(test_thread_alert_consumed),
			 ztest_user_unit_test(test_thread_alert_pending),
			 ztest_unit_test(test_isr_alert_default),
			 ztest_unit_test(test_isr_alert_ignore),
			 ztest_unit_test(test_isr_alert_consumed),
			 ztest_unit_test(test_isr_alert_pending),
			 ztest_user_unit_test(test_thread_kinit_alert),
			 ztest_unit_test(test_isr_kinit_alert));
	ztest_run_test_suite(alert_api);
}
/**
 * @}
 */