/**
 * @file HwA_mb.h
 * @author flagchip
 * @brief Mailbox hardware access layer
 * @version 2.0.0
 * @date 2024-08-20
 *
 * SDK Version: 2.6.0
 *

 * @copyright Copyright (c) 2020-2024 Flagchip Semiconductors Co., Ltd.
 *
 * @details
 */
/* ********************************************************************************
   *   Revision History:
   *
   *   Version     Date          Initials      CR#          Descriptions
   *   ---------   ----------    ------------  ----------   ---------------
   *   0.1.0      2023-12-15     Flagchip070   N/A          First version for FC7300
   *   2.0.0      2024-10-12     Flagchip070   N/A          Change version and release
   ******************************************************************************** */

#ifndef _HWA_MAILBOX_H_
#define _HWA_MAILBOX_H_
#include "device_header.h"

#if MB_INSTANCE_COUNT > 0U

/**
 * @defgroup HwA_mb HwA_mb
 * @ingroup module_driver_mb
 * @{
 */

/**
 * @brief The definition of mask all events
 *
 */
#define MB_EVENT_NONE			0u
/**
 * @brief The definition of receiving all events
 *
 */
#define MB_EVENT_ALL			0xFFFFFFFFu
/**
 * @brief The definition of receiving all request events
 *
 */
#define MB_EVENT_ALL_REQ		0x0000FFFFu
/**
 * @brief The definition of receiving all done events
 *
 */
#define MB_EVENT_ALL_DONE		0xFFFF0000u
/**
 * @brief The definition of request events on ch
 *
 */
#define MB_EVENT_REQ(ch)		(uint32_t)((uint32_t)1u << (ch))
/**
 * @brief The definition of done events on ch
 *
 */
#define MB_EVENT_DONE(ch)		(uint32_t)((uint32_t)1u << ((ch) + MB_INTn_FLG_MASK_DONE_FLAG_MASK_SHIFT))
/**
 * @brief The definition of issue to no core
 *
 */
#define MB_CORE_MASK_CORE_NONE	0u
/**
 * @brief The definition of issue to core 0
 *
 */
#define MB_CORE_MASK_CORE_0		1u
/**
 * @brief The definition of issue to core 1
 *
 */
#define MB_CORE_MASK_CORE_1		2u
/**
 * @brief The definition of issue to core 2
 *
 */
#define MB_CORE_MASK_CORE_2		4u
/**
 * @brief The definition of issue to HSM
 *
 */
#define MB_CORE_MASK_HSM		8u
/**
 * @brief The definition of issue to all cores
 *
 */
#define MB_CORE_MASK_ALL		0xFu
/**
 * @brief The definition of issue to core
 *
 */
#define MB_CORE_MASK(core)		(uint32_t)(1ul << (core))

/**
 * @brief Lock the MB_INTn registers
 *
 * @param u8CoreIndex the index of the core
 * @param u32Mask the lock bits
 */
LOCAL_INLINE void MB_HWA_LockIntrReg(uint8_t u8CoreIndex, uint32_t u32Mask)
{
	MB->INTR[u8CoreIndex].CCn_CTRL |= u32Mask;
}

/**
 * @brief Unlock the MB_INTn registers
 *
 * @param u8CoreIndex the index of the core
 * @param u32Mask the unlock bits
 */
LOCAL_INLINE void MB_HWA_UnlockIntrReg(uint8_t u8CoreIndex, uint32_t u32Mask)
{
	MB->INTR[u8CoreIndex].CCn_CTRL &= ~u32Mask;
}

/**
 * @brief Lock the MB_INTn_FLG
 *
 * @param u8CoreIndex the index of the core
 */
LOCAL_INLINE void MB_HWA_LockFlag(uint8_t u8CoreIndex)
{
	MB->INTR[u8CoreIndex].CCn_CTRL |= MB_INTn_CTRL_FLG_LOCK_MASK;
}

/**
 * @brief Unlock the MB_INTn_FLG
 *
 * @param u8CoreIndex the index of the core
 */
LOCAL_INLINE void MB_HWA_UnlockFlag(uint8_t u8CoreIndex)
{
	MB->INTR[u8CoreIndex].CCn_CTRL &= ~MB_INTn_CTRL_FLG_LOCK_MASK;
}

/**
 * @brief Lock the MB_INTn_FLG_MASK
 *
 * @param u8CoreIndex the index of the core
 */
LOCAL_INLINE void MB_HWA_LockFlagMask(uint8_t u8CoreIndex)
{
	MB->INTR[u8CoreIndex].CCn_CTRL |= MB_INTn_CTRL_FLG_MASK_LOCK_MASK;
}

/**
 * @brief Unlock the MB_INTn_FLG_MASK
 *
 * @param u8CoreIndex the index of the core
 */
LOCAL_INLINE void MB_HWA_UnlockFlagMask(uint8_t u8CoreIndex)
{
	MB->INTR[u8CoreIndex].CCn_CTRL &= ~MB_INTn_CTRL_FLG_MASK_LOCK_MASK;
}

/**
 * @brief Lock the MB_INTn_INTEN
 *
 * @param u8CoreIndex the index of the core
 */
LOCAL_INLINE void MB_HWA_LockInten(uint8_t u8CoreIndex)
{
	MB->INTR[u8CoreIndex].CCn_CTRL |= MB_INTn_CTRL_INTEN_LOCK_MASK;
}

/**
 * @brief Unlock the MB_INTn_INTEN
 *
 * @param u8CoreIndex the index of the core
 */
LOCAL_INLINE void MB_HWA_UnlockInten(uint8_t u8CoreIndex)
{
	MB->INTR[u8CoreIndex].CCn_CTRL &= ~MB_INTn_CTRL_INTEN_LOCK_MASK;
}

/**
 * @brief Configure receive events of mailbox interrupt channel
 *
 * @param u8CoreIndex the index of the core
 * @param u32Mask configuration for receiving events
 */
LOCAL_INLINE void MB_HWA_ConfigFlagMask(uint8_t u8CoreIndex, uint32_t u32Mask)
{
	MB->INTR[u8CoreIndex].CCn_FLG_MASK = u32Mask;
}

/**
 * @brief Enable receive events of mailbox interrupt channel
 *
 * @param u8CoreIndex the index of the core
 * @param u32Mask indicates the events to be enabled
 */
LOCAL_INLINE void MB_HWA_EnableEvent(uint8_t u8CoreIndex, uint32_t u32Mask)
{
	MB->INTR[u8CoreIndex].CCn_FLG_MASK |= u32Mask;
}

/**
 * @brief Disable receive events of mailbox interrupt channel
 *
 * @param u8CoreIndex the index of the core
 * @param u32Mask indicates the events to be enabled
 */
LOCAL_INLINE void MB_HWA_DisableEvent(uint8_t u8CoreIndex, uint32_t u32Mask)
{
	MB->INTR[u8CoreIndex].CCn_FLG_MASK &= ~u32Mask;
}

/**
 * @brief Configure the interrupt of mailbox interrupt channel
 *
 * @param u8CoreIndex the index of the core
 * @param u32Mask configuration for interrupts
 */
LOCAL_INLINE void MB_HWA_ConfigIntrEnable(uint8_t u8CoreIndex, uint32_t u32Mask)
{
	MB->INTR[u8CoreIndex].CCn_INTEN = u32Mask;
}

/**
 * @brief Enable the interrupt of mailbox interrupt channel
 *
 * @param u8CoreIndex the index of the core
 * @param u32Mask indicates the interrupts to be enabled
 */
LOCAL_INLINE void MB_HWA_EnableIntr(uint8_t u8CoreIndex, uint32_t u32Mask)
{
	MB->INTR[u8CoreIndex].CCn_INTEN |= u32Mask;
}

/**
 * @brief Disable the interrupt of mailbox interrupt channel
 *
 * @param u8CoreIndex the index of the core
 * @param u32Mask indicates the interrupts to be disabled
 */
LOCAL_INLINE void MB_HWA_DisableIntr(uint8_t u8CoreIndex, uint32_t u32Mask)
{
	MB->INTR[u8CoreIndex].CCn_INTEN &= ~u32Mask;
}

/**
 * @brief Clear the flag of mailbox interrupt channel
 *
 * @param u8CoreIndex the index of the core
 * @param u32Mask indicates the flags to be cleared
 */
LOCAL_INLINE void MB_HWA_ClearFlag(uint8_t u8CoreIndex, uint32_t u32Mask)
{
	MB->INTR[u8CoreIndex].CCn_FLG = u32Mask;
}

/**
 * @brief Get the flag masks of mailbox interrupt channel
 *
 * @param u8CoreIndex the index of the core
 * @param u32Mask the mask to get
 * @return the flag masks of the mailbox interrupt channel
 */
LOCAL_INLINE uint32_t MB_HWA_GetFlagMask(uint8_t u8CoreIndex, uint32_t u32Mask)
{
	return MB->INTR[u8CoreIndex].CCn_FLG_MASK & u32Mask;
}

/**
 * @brief Get the flags of mailbox interrupt channel
 *
 * @param u8CoreIndex the index of the core
 * @param u32Mask the mask to get
 * @return the flags of the mailbox interrupt channel
 */
LOCAL_INLINE uint32_t MB_HWA_GetFlag(uint8_t u8CoreIndex, uint32_t u32Mask)
{
	return MB->INTR[u8CoreIndex].CCn_FLG & u32Mask;
}

/**
 * @brief Get the result of flag & inten of mailbox interrupt channel
 *
 * @param u8CoreIndex the index of the core
 * @param u32Mask the mask to get
 * @return the result of flag & inten of the mailbox interrupt channel
 */
LOCAL_INLINE uint32_t MB_HWA_GetFlagStat(uint8_t u8CoreIndex, uint32_t u32Mask)
{
	return MB->INTR[u8CoreIndex].CCn_FLG_STAT & u32Mask;
}

/**
 * @brief Get the master ID of the currently obtained channel
 *
 * @param u32Channel the index of the channel
 * @return the master ID
 */
LOCAL_INLINE uint32_t MB_HWA_GetMasterID(uint32_t u32Channel)
{
	return (MB->CHANNEL[u32Channel].CCn_STAT & MB_CCn_STAT_CURRENT_LOCK_MASTER_ID_MASK) >> MB_CCn_STAT_CURRENT_LOCK_MASTER_ID_SHIFT;
}

/**
 * @brief Send data to the mailbox channel
 *
 * @param u32Channel the index of the channel
 * @param pData the buffer to be written
 */
LOCAL_INLINE void MB_HWA_WriteData(uint32_t u32Channel, uint32_t *pData)
{
	MB->CHANNEL[u32Channel].CCn_DATA0 = pData[0];
	MB->CHANNEL[u32Channel].CCn_DATA1 = pData[1];
}

/**
 * @brief Receive data from the mailbox channel
 *
 * @param u32Channel the index of the channel
 * @param pData the buffer to receive data
 */
LOCAL_INLINE void MB_HWA_GetData(uint32_t u32Channel, uint32_t *pData)
{
	pData[0] = MB->CHANNEL[u32Channel].CCn_DATA0;
	pData[1] = MB->CHANNEL[u32Channel].CCn_DATA1;
}

/**
 * @brief Get the automatically clear status of the mailbox channel
 *
 * @param u32Channel the index of the channel
 * @param u8CoreIndex the index of the core
 * @return automatically clear the channel lock enable bit
 */
LOCAL_INLINE uint32_t MB_HWA_GetAutoClear(uint32_t u32Channel, uint8_t u8CoreIndex)
{
	return MB->CHANNEL[u32Channel].CCn_SEMA_UNLK & ((uint32_t)1u << u8CoreIndex);
}

/**
 * @brief Release the mailbox channel
 *
 * @param u32Channel the index of the channel
 */
LOCAL_INLINE void MB_HWA_ReleaseChannel(uint32_t u32Channel)
{
	MB->CHANNEL[u32Channel].CCn_DONE = MB_MASTER_DONE_CODE;
}

/**
 * @brief Software clears channel lock
 *
 * @param u32Channel the index of the channel
 */
LOCAL_INLINE void MB_HWA_UnlockChannel(uint32_t u32Channel)
{
	MB->CHANNEL[u32Channel].CCn_CLR = MB_FORCE_UNLOCK_CODE;
}

/**
 * @brief Issue a done event
 *
 * @param u32Channel the index of the channel
 * @param u32DoneMask the cores to issue
 */
LOCAL_INLINE void MB_HWA_SetDone(uint32_t u32Channel, uint32_t u32DoneMask)
{
	MB->CHANNEL[u32Channel].CCn_DONE |= (u32DoneMask & MB_CCn_DONE_MASK);
}

/**
 * @brief Get the Communication Channel Semaphore Register
 *
 * @param u32Channel the index of the channel
 * @return Channel Lock Acquisition
 */
LOCAL_INLINE uint32_t MB_HWA_GetSemaphore(uint32_t u32Channel, uint32_t u32Mask)
{
	return MB->CHANNEL[u32Channel].CCn_SEMA & u32Mask;
}

/**
 * @brief Configure the master ID of the core that generates a done event
 *
 * @param u32Channel the index of the channel
 * @param u32MasterId master ID
 */
LOCAL_INLINE void MB_HWA_ConfigDoneMasterId(uint32_t u32Channel, uint32_t u32MasterId)
{
	MB->CHANNEL[u32Channel].CCn_DONE_MASK = (MB->CHANNEL[u32Channel].CCn_DONE_MASK & (~MB_CCn_DONE_MASK_DONE_MASTER_ID_MASK)) \
											| 	MB_CCn_DONE_MASK_DONE_MASTER_ID(u32MasterId);
}

/**
 * @brief Get the master ID of the core that generates a done event
 *
 * @param u32Channel the index of the channel
 * @return the master ID
 */
LOCAL_INLINE uint32_t MB_HWA_GetDoneMasterId(uint32_t u32Channel)
{
	return (MB->CHANNEL[u32Channel].CCn_DONE_MASK & MB_CCn_DONE_MASK_DONE_MASTER_ID_MASK) \
			>> MB_CCn_DONE_MASK_DONE_MASTER_ID_SHIFT;

}

/**
 * @brief Configure the mask of the done events
 *
 * @param u32Channel the index of the channel
 * @param u32DoneMask the cores to issue
 */
LOCAL_INLINE void MB_HWA_ConfigDoneMask(uint32_t u32Channel, uint32_t u32DoneMask)
{
	MB->CHANNEL[u32Channel].CCn_DONE_MASK = (MB->CHANNEL[u32Channel].CCn_DONE_MASK & (~MB_CCn_DONE_MASK)) | \
					(u32DoneMask & MB_CCn_DONE_MASK);
}

/**
 * @brief Get the mask of the done events
 *
 * @param u32Channel the index of the channel
 * @return the mask of the done events
 */
LOCAL_INLINE uint32_t MB_HWA_GetDoneMask(uint32_t u32Channel)
{
	return MB->CHANNEL[u32Channel].CCn_DONE_MASK & MB_CCn_DONE_MASK;
}

/**
 * @brief Configure the automatically clear of the lock enable bit
 *
 * @param u32Channel the index of the channel
 * @param u32AutoUnlockMask the automatically clear of the lock enable bit
 */
LOCAL_INLINE void MB_HWA_ConfigAutoUnlock(uint32_t u32Channel, uint32_t u32AutoUnlockMask)
{
	MB->CHANNEL[u32Channel].CCn_SEMA_UNLK = u32AutoUnlockMask & MB_CCn_SEMA_UNLK_MASK;
}

/**
 * @brief Issue request events
 *
 * @param u32Channel the index of the channel
 * @param u32RequestMask the cores to issue
 */
LOCAL_INLINE void MB_HWA_ConfigRequest(uint32_t u32Channel, uint32_t u32RequestMask)
{
	MB->CHANNEL[u32Channel].CCn_REQUEST = u32RequestMask & MB_CCn_REQUEST_MASK;
}

#ifdef MB_SEMA_EXSIST
/**
 * @brief Function to get the semaphore status
 * 
 * This function retrieves the status of a semaphore specified by the identifier u32Sema.
 * It accesses the SEMAn_STATUS array of a predefined MB object, which contains the status values of all semaphores.
 * 
 * @param u32Sema Semaphore identifier used to specify the semaphore whose status is to be retrieved.
 * @return uint32_t Returns the status value of the specified semaphore.
 * 
 */
LOCAL_INLINE uint32_t MB_HWA_GetSemaStatus(uint32_t u32Sema)
{
    return MB->SEMAn_STATUS[u32Sema];
}

/**
 * @brief  Get semaphore lock status
 * 
 * @param u32Sema  Semaphore identifier
 * 
 * @return bool    Returns the semaphore lock status
 * 
 * @note   This function checks the specific bit in the SEMAn_STATUS register to determine if the semaphore is locked
 */
LOCAL_INLINE bool MB_HWA_GetSemaLock(uint32_t u32Sema)
{
    return (bool)(MB->SEMAn_STATUS[u32Sema] & MB_SEMAn_STATUS_SEMA_FLG_MASK);
}
/**
 * @brief Get the master ID of a semaphore
 * 
 * @param u32Sema Semaphore identifier used to select the specific semaphore status register
 * @return uint8_t The master ID of the semaphore
 */
LOCAL_INLINE uint8_t MB_HWA_GetSemaMasterID(uint32_t u32Sema)
{
    return (uint8_t)((MB->SEMAn_STATUS[u32Sema] & MB_SEMAn_STATUS_SEMA_MID_MASK) >> MB_SEMAn_STATUS_SEMA_MID_SHIFT);
}

/**
 * @brief Get Semaphore Resource ID
 * 
 * @param u32Sema Semaphore index, indicating which semaphore register to use.
 * @return uint8_t Semaphore resource ID.
 */
LOCAL_INLINE uint8_t MB_HWA_GetSemaResourceID(uint32_t u32Sema)
{
    return (uint8_t)((MB->SEMAn_STATUS[u32Sema] & MB_SEMAn_STATUS_SEMA_RSRC_ID_MASK) >> MB_SEMAn_STATUS_SEMA_RSRC_ID_SHIFT);
}

/**
 * @brief Get the global semaphore status
 * 
 * @return uint16_t The current global semaphore status value
 */
LOCAL_INLINE uint16_t MB_HWA_GetSemaGlobalStatus(void)
{
    return (uint16_t)(MB->SEMA_GLOBAL_STATUS & MB_SEMA_GLOBAL_STATUS_MASK);
}

/**
 * @brief Enable semaphore lock protection
 * 
 */
LOCAL_INLINE void MB_HWA_EnableSemaLockProtect(void)
{
    MB->SEMA_CTRL &= ~MB_SEMA_CTRL_MASK;
}

/**
 * @brief Disable semaphore lock protection
 * 
 */
LOCAL_INLINE void MB_HWA_DisableSemaLockProtect(void)
{
    MB->SEMA_CTRL |= MB_SEMA_CTRL_MASK;
}

/**
 * @brief Get the SEMA error status register value
 * 
 * @return uint32_t The current value of the SEMA error status register
 */
LOCAL_INLINE uint32_t MB_HWA_ReadSemaErrorStatus(void)
{
    return MB->SEMA_ERROR_STATUS;
}

/**
 * @brief Get Semaphore Error Resource ID
 * 
 * @return uint8_t The value of the semaphore error resource ID
 */
LOCAL_INLINE uint8_t MB_HWA_GetSemaErrorResourceID(void)
{
    return (uint8_t)((MB->SEMA_ERROR_STATUS & MB_SEMA_ERROR_STATUS_SEMA_ERR_RSRC_ID_MASK) >> MB_SEMA_ERROR_STATUS_SEMA_ERR_RSRC_ID_SHIFT);
}

/**
 * @brief Get Semaphore Master ID
 * 
 * @return uint8_t The value of the semaphore error master ID
 */
LOCAL_INLINE uint8_t MB_HWA_GetSemaErrorMasterID(void)
{
    return (uint8_t)((MB->SEMA_ERROR_STATUS & MB_SEMA_ERROR_STATUS_SEMA_ERR_MID_MASK) >> MB_SEMA_ERROR_STATUS_SEMA_ERR_MID_SHIFT);
}

/**
 * @brief Get Semaphore Error Status
 * 
 * @return uint8_t The value of the semaphore error status
 */
LOCAL_INLINE uint32_t MB_HWA_GetSemaErrorStatus(void)
{
    return MB->SEMA_ERROR_STATUS;
}

/**
 * @brief Sets the software reset signal for the MB module
 * 
 */
LOCAL_INLINE void MB_HWA_SoftwareResetSema(void)
{
    MB->SEMA_SW_RESET = MB_SEMA_KEY_SW_RESET;
}

/**
 * @brief Release all semaphores
 * 
 * @param u8MasterId The Master Index used to identify the resource to be acquired, the value should be 0~4
 */
LOCAL_INLINE void MB_HWA_ReleaseAllSema(uint8_t u8MasterIdx)
{
    MB->SEMA_RELEASE = MB_SEMA_KEY_RELEASE_ALL | (uint32_t)(u8MasterIdx & 0x7u);
}

/**
 * @brief Acquire a resource by its ID
 * 
 * @param u32ResourceID The resource ID used to identify the resource to be acquired
 */
LOCAL_INLINE uint32_t MB_HWA_GetResource(uint32_t u32ResourceID)
{
    return MB->SEMA_RSRC[u32ResourceID];
}

/**
 * @brief Unlocks the specified resource
 * 
 * This function unlocks the resource identified by u32ResourceID by setting the associated semaphore key to an unlocked state.
 * 
 * @param u32ResourceID The resource identifier used to specify the resource to unlock
 */
LOCAL_INLINE void MB_HWA_UnlockResource(uint32_t u32ResourceID)
{
    MB->SEMA_RSRC[u32ResourceID] = MB_SEMA_KEY_UNLOCK;
}

LOCAL_INLINE void MB_HWA_ReleaseResource(uint32_t u32ResourceID)
{
	MB->SEMA_RSRC[u32ResourceID] = MB_SEMA_KEY_RELEASE;
}

/**
 * @brief Clear error status function
 * 
 * Sets the status flag for the specified resource ID to the key value that clears the error status.
 * 
 */
LOCAL_INLINE void MB_HWA_ClearErrorStatus(void)
{
    MB->SEMA_ERROR_STATUS = MB_SEMA_KEY_CLEAR_ERROR;
}
#endif

/** @}*/

#endif /* #if MB_INSTANCE_COUNT > 0U */

#endif