/*
 * FreeRTOS Kernel V10.3.0
 * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of
 * this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 * the Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 * http://www.FreeRTOS.org
 * http://aws.amazon.com/freertos
 *
 * 1 tab == 4 spaces!
 */

/*
 * This demo file demonstrates how to send data between an ISR and a
 * co-routine.  A tick hook function is used to periodically pass data between
 * the RTOS tick and a set of 'hook' co-routines.
 *
 * hookNUM_HOOK_CO_ROUTINES co-routines are created.  Each co-routine blocks
 * to wait for a character to be received on a queue from the tick ISR, checks
 * to ensure the character received was that expected, then sends the number
 * back to the tick ISR on a different queue.
 *
 * The tick ISR checks the numbers received back from the 'hook' co-routines
 * matches the number previously sent.
 *
 * If at any time a queue function returns unexpectedly, or an incorrect value
 * is received either by the tick hook or a co-routine then an error is
 * latched.
 *
 * This demo relies on each 'hook' co-routine to execute between each
 * hookTICK_CALLS_BEFORE_POST tick interrupts.  This and the heavy use of
 * queues from within an interrupt may result in an error being detected on
 * slower targets simply due to timing.
 */

/* Scheduler includes. */
#include "FreeRTOS.h"
#include "croutine.h"
#include "queue.h"

/* Demo application includes. */
#include "crhook.h"

/* The number of 'hook' co-routines that are to be created. */
#define hookNUM_HOOK_CO_ROUTINES (4)

/* The number of times the tick hook should be called before a character is
posted to the 'hook' co-routines. */
#define hookTICK_CALLS_BEFORE_POST (500)

/* There should never be more than one item in any queue at any time. */
#define hookHOOK_QUEUE_LENGTH (1)

/* Don't block when initially posting to the queue. */
#define hookNO_BLOCK_TIME (0)

/* The priority relative to other co-routines (rather than tasks) that the
'hook' co-routines should take. */
#define mainHOOK_CR_PRIORITY (1)
/*-----------------------------------------------------------*/

/*
 * The co-routine function itself.
 */
static void prvHookCoRoutine(CoRoutineHandle_t xHandle, UBaseType_t uxIndex);

/*
 * The tick hook function.  This receives a number from each 'hook' co-routine
 * then sends a number to each co-routine.  An error is flagged if a send or
 * receive fails, or an unexpected number is received.
 */
void vApplicationTickHook(void);

/*-----------------------------------------------------------*/

/* Queues used to send data FROM a co-routine TO the tick hook function.
The hook functions received (Rx's) on these queues.  One queue per
'hook' co-routine. */
static QueueHandle_t xHookRxQueues[hookNUM_HOOK_CO_ROUTINES];

/* Queues used to send data FROM the tick hook TO a co-routine function.
The hood function transmits (Tx's) on these queues.  One queue per
'hook' co-routine. */
static QueueHandle_t xHookTxQueues[hookNUM_HOOK_CO_ROUTINES];

/* Set to true if an error is detected at any time. */
static BaseType_t xCoRoutineErrorDetected = pdFALSE;

/*-----------------------------------------------------------*/

void vStartHookCoRoutines(void)
{
	UBaseType_t uxIndex, uxValueToPost = 0;

	for (uxIndex = 0; uxIndex < hookNUM_HOOK_CO_ROUTINES; uxIndex++) {
		/* Create a queue to transmit to and receive from each 'hook'
		co-routine. */
		xHookRxQueues[uxIndex] = xQueueCreate(hookHOOK_QUEUE_LENGTH,
						      sizeof(UBaseType_t));
		xHookTxQueues[uxIndex] = xQueueCreate(hookHOOK_QUEUE_LENGTH,
						      sizeof(UBaseType_t));

		/* To start things off the tick hook function expects the queue it
		uses to receive data to contain a value.  */
		xQueueSend(xHookRxQueues[uxIndex], &uxValueToPost,
			   hookNO_BLOCK_TIME);

		/* Create the 'hook' co-routine itself. */
		xCoRoutineCreate(prvHookCoRoutine, mainHOOK_CR_PRIORITY,
				 uxIndex);
	}
}
/*-----------------------------------------------------------*/

static UBaseType_t uxCallCounter = 0, uxNumberToPost = 0;
void vApplicationTickHook(void)
{
	UBaseType_t uxReceivedNumber;
	BaseType_t xIndex, xCoRoutineWoken;

	/* Is it time to talk to the 'hook' co-routines again? */
	uxCallCounter++;
	if (uxCallCounter >= hookTICK_CALLS_BEFORE_POST) {
		uxCallCounter = 0;

		for (xIndex = 0; xIndex < hookNUM_HOOK_CO_ROUTINES; xIndex++) {
			xCoRoutineWoken = pdFALSE;
			if (crQUEUE_RECEIVE_FROM_ISR(
				    xHookRxQueues[xIndex], &uxReceivedNumber,
				    &xCoRoutineWoken) != pdPASS) {
				/* There is no reason why we would not expect the queue to
				contain a value. */
				xCoRoutineErrorDetected = pdTRUE;
			} else {
				/* Each queue used to receive data from the 'hook' co-routines
				should contain the number we last posted to the same co-routine. */
				if (uxReceivedNumber != uxNumberToPost) {
					xCoRoutineErrorDetected = pdTRUE;
				}

				/* Nothing should be blocked waiting to post to the queue. */
				if (xCoRoutineWoken != pdFALSE) {
					xCoRoutineErrorDetected = pdTRUE;
				}
			}
		}

		/* Start the next cycle by posting the next number onto each Tx queue. */
		uxNumberToPost++;

		for (xIndex = 0; xIndex < hookNUM_HOOK_CO_ROUTINES; xIndex++) {
			if (crQUEUE_SEND_FROM_ISR(xHookTxQueues[xIndex],
						  &uxNumberToPost,
						  pdFALSE) != pdTRUE) {
				/* Posting to the queue should have woken the co-routine that
				was blocked on the queue. */
				xCoRoutineErrorDetected = pdTRUE;
			}
		}
	}
}
/*-----------------------------------------------------------*/

static void prvHookCoRoutine(CoRoutineHandle_t xHandle, UBaseType_t uxIndex)
{
	static UBaseType_t uxReceivedValue[hookNUM_HOOK_CO_ROUTINES];
	BaseType_t xResult;

	/* Each co-routine MUST start with a call to crSTART(); */
	crSTART(xHandle);

	for (;;) {
		/* Wait to receive a value from the tick hook. */
		xResult = pdFAIL;
		crQUEUE_RECEIVE(xHandle, xHookTxQueues[uxIndex],
				&(uxReceivedValue[uxIndex]), portMAX_DELAY,
				&xResult);

		/* There is no reason why we should not have received something on
		the queue. */
		if (xResult != pdPASS) {
			xCoRoutineErrorDetected = pdTRUE;
		}

		/* Send the same number back to the idle hook so it can verify it. */
		xResult = pdFAIL;
		crQUEUE_SEND(xHandle, xHookRxQueues[uxIndex],
			     &(uxReceivedValue[uxIndex]), hookNO_BLOCK_TIME,
			     &xResult);
		if (xResult != pdPASS) {
			/* There is no reason why we should not have been able to post to
			the queue. */
			xCoRoutineErrorDetected = pdTRUE;
		}
	}

	/* Each co-routine MUST end with a call to crEND(). */
	crEND();
}
/*-----------------------------------------------------------*/

BaseType_t xAreHookCoRoutinesStillRunning(void)
{
	if (xCoRoutineErrorDetected) {
		return pdFALSE;
	} else {
		return pdTRUE;
	}
}