#include "chip.h"
#include "board.h"
#include "sema.h"

static SemaphoreHandle_t gate_mutex[SEMA_GATE_MAX] = {0};
static QueueHandle_t gate_status[SEMA_GATE_MAX] = {0};

static sema_gate_state_e sema_gate_status(sema_gate_e gate)
{
	if (gate >= SEMA_GATE_MAX)
		return pdFAIL;
	return (sema_gate_state_e)(rSemaGate(gate)&0x3);
}

static int sema_gate_lock(sema_gate_e gate)
{
	int ret = 1;

	rSemaGate(gate) = (LOCAL_CPx + 1);
	if (sema_gate_status(gate) != (sema_gate_state_e)(LOCAL_CPx + 1)) {
		ret = 0;
	}
	return ret;
}

static int sema_gate_unlock(sema_gate_e gate)
{
	int ret = 1;

	rSemaGate(gate) = SEMA_GATE_S_UNLOCK;
	if (sema_gate_status(gate) != SEMA_GATE_S_FREE) {
		ret = 0;
	}

	return ret;
}

static void sema_int_enable(sema_gate_e gate, int enable)
{
	if (enable) {
		rSemaCPINE(gate / 32) |= ( 1<< (gate % 32));
	} else {
		rSemaCPINE(gate / 32) &= ~( 1<< (gate % 32));
	}
}

static void sema_clear_int_flag(void)
{
	rSemaIRQCLR = 0x1;
}


static int sema_get_int_flag(sema_gate_e gate)
{
	return (rSemaCPINTFLG(gate / 32)  & (1 << (gate % 32)))? 1 : 0;
}


static void sema_reset_gate(sema_gate_e gate, int all_gate)
{
	unsigned int gate_n = gate;
	if (all_gate) {
		gate_n = 64;
	}

	rSemaRSTGT = (gate_n << 8) | 0xe2;
	rSemaRSTGT = (gate_n << 8) | 0x1d;
}

static void sema_reset_int_notify(sema_gate_e gate, int all_gate)
{
	unsigned int gate_n = gate;
	if (all_gate) {
		gate_n = 64;
	}

	rSemaRSTNTF = (gate_n << 8) | 0x47;
	rSemaRSTNTF = (gate_n << 8) | 0xb8;
}

void sema_int_handler(void *param)
{
	int i;

	for (i=0; i<SEMA_GATE_MAX; i++) {
		if (sema_get_int_flag((sema_gate_e)i)) {
			if (sema_gate_lock((sema_gate_e)i)) {
				xQueueSendFromISR(gate_status[i], NULL, 0);
			}
		}
	}
}

int sema_take(sema_gate_e gate, TickType_t xTicksToWait)
{
	int ret = pdPASS;

	if (gate >= SEMA_GATE_MAX)
		return pdFAIL;

	if (xSemaphoreTake(gate_mutex[gate], xTicksToWait) != pdPASS) {
		return pdFAIL;
	}

	sema_int_enable(gate, 1);
	xQueueReset(gate_status[gate]);
	while (!sema_gate_lock(gate)) {
		ret = xQueueReceive(gate_status[gate], NULL, (xTicksToWait > 0)?1:0);
		if (ret == pdPASS)
			break;
		if (xTicksToWait > 0)
			xTicksToWait--;
		if (xTicksToWait == 0)
			break;
	}
	sema_int_enable(gate, 0);

	if (ret != pdPASS) {
		if (sema_gate_status(gate) == (sema_gate_state_e)(LOCAL_CPx + 1))
			ret = pdPASS;
	}

	if (ret != pdPASS) {
		xSemaphoreGive(gate_mutex[gate]);
	}

	return ret;
}

int sema_give(sema_gate_e gate)
{
	int ret = pdPASS;
	if (gate >= SEMA_GATE_MAX)
		return pdFAIL;

	ret = sema_gate_unlock(gate);
	if (!uxSemaphoreGetCount(gate_mutex[gate])) {
		xSemaphoreGive(gate_mutex[gate]);
	}
	return ret;
}

void sema_init(void)
{
	int i;

	//sema_reset_gate(0, 1);
	//sema_reset_int_notify(0, 1);

	for (i=0; i<SEMA_GATE_MAX; i++) {
		gate_mutex[i] = xSemaphoreCreateMutex();
		gate_status[i] = xQueueCreate(1, 0);
	}

	request_irq(SEMA_IRQn, 0,sema_int_handler,NULL);

	/*
		获取后会导致mcu无法访问，若访问需要cpu端释放，且mcu端需获取模块锁后才能正常访问；
		除一些特定的应用场景外，例如：CRC模块，对模块的访问需要动态获取；
		其他模块建议固定在一端访问，若需要核心间信息交互，可通过mailbox实现；
	*/

	//fixed config
	sema_take(SEMA_GATE_SYS, portMAX_DELAY);
	sema_take(SEMA_GATE_GBUS, portMAX_DELAY);
	sema_take(SEMA_GATE_VBUS, portMAX_DELAY);
	sema_take(SEMA_GATE_CHBUS, portMAX_DELAY);
	sema_take(SEMA_GATE_CABUS, portMAX_DELAY);
	sema_take(SEMA_GATE_DDRCTL, portMAX_DELAY);
	sema_take(SEMA_GATE_DDRPHY, portMAX_DELAY);
	sema_take(SEMA_GATE_TIMER, portMAX_DELAY);
	sema_take(SEMA_GATE_UART0, portMAX_DELAY);
	sema_take(SEMA_GATE_UART1, portMAX_DELAY);
	sema_take(SEMA_GATE_DMA, portMAX_DELAY);
	sema_take(SEMA_GATE_SDMMC1, portMAX_DELAY);
	sema_take(SEMA_GATE_SPI0, portMAX_DELAY);
	sema_take(SEMA_GATE_SPI2, portMAX_DELAY);
	sema_take(SEMA_GATE_ECSPI, portMAX_DELAY);
	sema_take(SEMA_GATE_GPIO, portMAX_DELAY);
	sema_take(SEMA_GATE_WDT, portMAX_DELAY);
	sema_take(SEMA_GATE_LCD, portMAX_DELAY);
	sema_take(SEMA_GATE_BLENDING, portMAX_DELAY);
	sema_take(SEMA_GATE_PXP, portMAX_DELAY);
	sema_take(SEMA_GATE_QOI, portMAX_DELAY);
	sema_take(SEMA_GATE_MFC, portMAX_DELAY);
	sema_take(SEMA_GATE_WRAP, portMAX_DELAY);
	sema_take(SEMA_GATE_ETH, portMAX_DELAY);
	sema_take(SEMA_GATE_CRC, portMAX_DELAY);
	sema_take(SEMA_GATE_DDRRDC, portMAX_DELAY);
	sema_take(SEMA_GATE_SRAMRDC, portMAX_DELAY);
	sema_take(SEMA_GATE_ITU, portMAX_DELAY);
	sema_take(SEMA_GATE_I2C0, portMAX_DELAY);
	sema_take(SEMA_GATE_I2C1, portMAX_DELAY);
	sema_take(SEMA_GATE_GPU, portMAX_DELAY);
#ifdef USB_SUPPORT
	sema_take(SEMA_GATE_USB, portMAX_DELAY);
#endif
	sema_take(SEMA_GATE_RCRT, portMAX_DELAY);
	sema_take(SEMA_GATE_UART2, portMAX_DELAY);
	sema_take(SEMA_GATE_UART3, portMAX_DELAY);
	sema_take(SEMA_GATE_PWM, portMAX_DELAY);
	sema_take(SEMA_GATE_I2S0, portMAX_DELAY);
	sema_take(SEMA_GATE_I2S1, portMAX_DELAY);
#ifdef RTC_SUPPORT
	sema_take(SEMA_GATE_RTC, portMAX_DELAY);
#endif

#if LCD_INTERFACE_TYPE == LCD_INTERFACE_MIPI
	sema_take(SEMA_GATE_DSI, portMAX_DELAY);
#endif

#ifdef VIDEO_DECODER_MIPI
	sema_take(SEMA_GATE_CSI, portMAX_DELAY);
#endif

	//dynamic
	//sema_take(SEMA_GATE_SDMMC0, portMAX_DELAY);

	// mcu use module
//	sema_take(SEMA_GATE_ADC0, portMAX_DELAY);
//	sema_take(SEMA_GATE_ADC1, portMAX_DELAY);
//	sema_take(SEMA_GATE_ADC2, portMAX_DELAY);

}