amt630hv160-sdk-release/amt630hv160-freertos-beta/ArkmicroFiles/libboard-amt630hv160/source/access_module.c

#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include "mmcsd_core.h"
#include "flash.h"
#include "FreeRTOS.h"
#include "task.h"
#include "chip.h"
#include "crc.h"
#include "mailbox_message.h"
#include "access_module.h"


#ifdef MAILBOX_SUPPORT
#define ACCESS_DEBUG(fmt, args...)		//printf(fmt, ##args)


static uint32_t header_size;
static uint32_t c_msg_size;
static uint32_t f_msg_size;

#ifdef MCU_ACCESS_MODULE_SUPPORT
static int SendAccessModuleRsp(AccessModuleType type, uint32_t result, AccessModuleRespondMsgStatus msg_status)
{
	AccessModuleHeader header = {0};

	header.result = result;
	header.type = type;
	header.len = header_size;
	header.msg_status = msg_status;
	if (mailbox_msg_send(MB_MSG_T_MCU_MODULE_ACCESS, (const uint8_t *)&header, header.len, pdMS_TO_TICKS(50))) {
		printf("%s, mailbox send frame fail.\n", __func__);
		return -1;
	}
	return 0;
}

#ifdef ACCESS_FLASH_SUPPORT
static void McuAccessFlash(AccessFlashMsg *rx_msg)
{
	int ret = 0;

	if (rx_msg->access_type == AFT_ERASE) {
		ACCESS_DEBUG("mcu erase flash addr:0x%x, size:0x%x.\n",rx_msg->flash_addr, rx_msg->mem_size);
		ret = flash_erase(rx_msg->flash_addr, rx_msg->mem_size);
	} else if (rx_msg->access_type == AFT_WRITE) {
		ACCESS_DEBUG("mcu write flash addr:0x%x, size:0x%x, mem:0x%x.\n",rx_msg->flash_addr, rx_msg->mem_size, rx_msg->mem_addr);
		CP15_invalidate_dcache_for_dma(rx_msg->mem_addr, rx_msg->mem_addr + rx_msg->mem_size);
		ret = flash_write(rx_msg->flash_addr, rx_msg->mem_size, (void*)rx_msg->mem_addr);
	} else if (rx_msg->access_type == AFT_READ) {
		ACCESS_DEBUG("mcu read flash addr:0x%x, size:0x%x, mem:0x%x.\n",rx_msg->flash_addr, rx_msg->mem_size, rx_msg->mem_addr);
		ret = flash_read(rx_msg->flash_addr, rx_msg->mem_size, (void*)rx_msg->mem_addr);
		CP15_clean_dcache_for_dma(rx_msg->mem_addr, rx_msg->mem_addr + rx_msg->mem_size);
	} else {
		printf("%s, mailbox receive access flash type error.\n", __func__);
		SendAccessModuleRsp(AMT_FLASH, 0, AMRMS_PARA_ERROR);
		return;
	}

	SendAccessModuleRsp(AMT_FLASH, (uint32_t)ret, AMRMS_NO_ERROR);
}
#endif

#ifdef ACCESS_CRC_SUPPORT
void McuAccessCrc(AccessCrcMsg *rx_msg)
{
	ACCESS_DEBUG("mcu calc crc mem addr:0x%x, size:0x%x, init:0x%x.\n",rx_msg->mem_addr, rx_msg->mem_size, rx_msg->init);
	CP15_invalidate_dcache_for_dma(rx_msg->mem_addr, rx_msg->mem_addr + rx_msg->mem_size);
	uint32_t ret = CRC_Calc((void *)rx_msg->mem_addr, rx_msg->mem_size, rx_msg->init, CRC_POLY32, rx_msg->widthopt);
	SendAccessModuleRsp(AMT_CRC, ret, AMRMS_NO_ERROR);
}
#endif

static void McuAccessModuleThread(void *para)
{
	mb_rxmsg_t msg;
	AccessModuleHeader *header;
	uint32_t msg_len;

	header_size = sizeof(AccessModuleHeader);
#ifdef ACCESS_FLASH_SUPPORT
	f_msg_size = sizeof(AccessFlashMsg);
#endif
	c_msg_size = sizeof(AccessCrcMsg);

	for (;;) {
		if (mailbox_msg_receive(MB_MSG_T_MCU_MODULE_ACCESS, &msg, portMAX_DELAY) != pdTRUE) {
			continue;
		}

		header = (AccessModuleHeader *)msg.data;
		if (header->type == AMT_STATUS) {
			SendAccessModuleRsp(header->type, 0, AMRMS_NO_ERROR);
			continue;
		} else if (header->type == AMT_FLASH) {
#ifdef ACCESS_FLASH_SUPPORT
			msg_len = f_msg_size;
#endif
		} else if (header->type == AMT_CRC) {
			msg_len = c_msg_size;
		} else {
			printf("%s, unknown module type, access not supportd.\n", __func__);
			//unknown module type, Unable to reply.
			continue;
		}

		if (msg.dl != header_size + msg_len) {
			printf("%s, mailbox rev msg length err.\n", __func__);
			SendAccessModuleRsp(header->type, 0, AMRMS_LEN_ERROR);
			continue;
		}

		if (header->type == AMT_FLASH) {
#ifdef ACCESS_FLASH_SUPPORT
			McuAccessFlash((AccessFlashMsg *)(msg.data + header_size));
#endif
		} else if (header->type == AMT_CRC) {
			McuAccessCrc((AccessCrcMsg *)(msg.data + header_size));
		}
	}
}

/* 接收MCU通过mailbox访问模块信息 */
void McuAccessModule(void)
{
	if (xTaskCreate(McuAccessModuleThread, "McuAccessModule", configMINIMAL_STACK_SIZE, NULL,
			1, NULL) != pdPASS) {
		printf("create MCU access module task fail.\n");
	}
}
#endif

#ifdef CPU_ACCESS_MODULE_SUPPORT
int WaitAccessModuleRsp(AccessModuleType type, u32 *result, void *rsp_data)
{
	mb_rxmsg_t msg = {0};
	AccessModuleHeader *header;

	if (mailbox_msg_receive(MB_MSG_T_CPU_MODULE_ACCESS, &msg, pdMS_TO_TICKS(5000)) == pdTRUE) {
		header = (AccessModuleHeader *)msg.data;
		if (header->type != type) {
			printf("%s, mailbox rev header info module type error.\n", __func__);
			return -1;
		}

		if (header->len != msg.dl) {
			printf("%s, mailbox rev header info access length err.\n", __func__);
			return -1;
		} else {
			if (type == AMT_RTC && rsp_data && (msg.dl == (sizeof(AccessModuleHeader) + sizeof(AccessRtcMsg)))) {
				memcpy(rsp_data, (void *)(msg.data + sizeof(AccessModuleHeader)), sizeof(AccessRtcMsg));
			}
		}

		if (header->msg_status == AMRMS_LEN_ERROR) {
			printf("%s, cpu mailbox rev msg length err.\n", __func__);
			return -1;
		} else if (header->msg_status == AMRMS_TYPE_ERROR) {
			printf("%s, cpu mailbox rev msg access module type error.\n", __func__);
			return -1;
		} else if (header->msg_status == AMRMS_PARA_ERROR) {
			printf("%s, cpu mailbox rev msg access module parameter error.\n", __func__);
			return -1;
		}
		*result = header->result;

		return 0;
	}

	printf("%s, mailbox receive timeout.\n",__func__);
	return -1;
}

int SendAccessModuleReq(AccessModuleType type, void *msg, u32 msg_len)
{
	u8 buf[26] = {0};
	AccessModuleHeader *header;

	if (msg_len + sizeof(AccessModuleHeader) > 64) {
		printf("%s, buf is too small.\n", __func__);
		return -1;
	}

	header = (AccessModuleHeader *)buf;
	header->type = type;
	header->len = sizeof(AccessModuleHeader) + msg_len;
	if (msg)
		memcpy((void *)(buf + sizeof(AccessModuleHeader)), msg, msg_len);

	if (mailbox_msg_send(MB_MSG_T_CPU_MODULE_ACCESS, buf, header->len, pdMS_TO_TICKS(50))) {
		printf("%s, mailbox send frame fail.\n", __func__);
		return -1;
	}

	return 0;
}

#ifdef ACCESS_RTC_SUPPORT
int AccessRTC(AccessRtcType type, uint32_t *time)
{
	int ret = -1;
	AccessRtcMsg tx_msg = {0};
	AccessRtcMsg *rx_msg = NULL;
	AccessRtcMsg msg = {0};

	tx_msg.access_type = type;

	if (type == ART_SET_TIME)
		tx_msg.rtc_cnt_h = *time;
	else if (type == ART_GET_TIME)
		rx_msg = &msg;

	if (SendAccessModuleReq(AMT_RTC, &tx_msg, sizeof(AccessRtcMsg))) {
		printf("%s, send frame fail.\n", __func__);
		return -1;
	}

	if (WaitAccessModuleRsp(AMT_RTC, (u32 *)&ret, rx_msg)) {
		printf("%s, wait rex frame abnormal.\n", __func__);
		return -1;
	}

	if(!ret && type == ART_GET_TIME)
		*time = rx_msg->rtc_cnt_h;

	return ret;
}
#endif
#endif
#endif