📄 fifo_if.c
字号:
RegClear(REG08_D_EPxJoin(number - 1),BIT_JoinCPU_Wr);
}
}
if (flag == 1) {
if (RegRead(REG08_D_EPxJoin(number - 1)) != join) {
/* For can not Join */
retValue = STATUS_INVALID_PARAMETER;
break;
}
}
}
break;};
return retValue;
}
/* =============================================================================
// Function_Name: FIFO_IFClearFIFO_AllJoin
// description : Release all the Join
// argument : None
// return : STATUS_SUCCESS Terminated normally
// STATUS_NOT_OPENED Not opened
// flag :
// global :
// =============================================================================
*/
LONG FIFO_IFClearFIFO_AllJoin(void)
{
LONG retValue;
retValue = STATUS_SUCCESS;
while (1) {
/* Release all Join */
RegWrite(REG08_D_ClrAllEPnJoin,R8_INT_ALLZERO);
RegWrite(REG08_ClrAllMediaFIFO_Join,R8_INT_ALLZERO);
break;};
return retValue;
}
/* =============================================================================
// Function_Name: FIFO_IFSetIntEvent
// description : FIFO_InCmp,FIFO_OutCmp Switch the valid and invalid for event
// argument : event Kind of event which made effective
// flag Flag of valid, invalid
// return : STATUS_SUCCESS Terminated normally
// STATUS_NOT_OPENED Not opened
// STATUS_UNABLE_TO_REGISTER Unable to register
// flag :
// global :
// =============================================================================
*/
LONG FIFO_IFSetIntEvent(UCHAR event,UCHAR flag)
{
LONG retValue;
retValue = STATUS_SUCCESS;
while (1) {
if (flag == FIFO_IF_EVENTON) {
if ((RegRead(REG08_MainIntEnb) & MASK_EnDeviceIntStat) != BIT_EnDeviceIntStat) {
// When the main interrupt is disabled, set it to 1
RegSet(REG08_MainIntEnb,BIT_EnDeviceIntStat);
}
if((RegRead(REG08_DeviceIntEnb) & MASK_EnD_FIFO_IntStat) != BIT_EnD_FIFO_IntStat)
{
// When the DeviceIntEnb.EnD_FIFO_IntStat interrupt is disabled, set it to 1
RegSet(REG08_DeviceIntEnb,BIT_EnD_FIFO_IntStat);
}
if (event & FIFO_IF_FIFO_IDE_CMP) {
/* FIFO_IDECmp is made effective */
RegWrite(REG08_D_FIFO_IntStat,INT_FIFO_IDE_CMP); /* Clear the FIFO_IDE_Cmp */
CLR_BIT(FIFO_IntStat,INT_FIFO_IDE_CMP);
SET_BIT(FIFO_IntEnb, INT_FIFO_IDE_CMP);
RegSet(REG08_D_FIFO_IntEnb,BIT_EnFIFO_IDE_Cmp);
}
if (event & FIFO_IF_FIFO1_CMP) {
/* FIFO1_Cmp is made effective */
RegWrite(REG08_D_FIFO_IntStat,INT_FIFO1_CMP); /* Clear the FIFO1_Cmp */
CLR_BIT(FIFO_IntStat,INT_FIFO1_CMP);
SET_BIT(FIFO_IntEnb, INT_FIFO1_CMP);
RegSet(REG08_D_FIFO_IntEnb,BIT_EnFIFO1_Cmp);
}
if (event & FIFO_IF_FIFO0_CMP) {
/* FIFO0_Cmp is made effective */
RegWrite(REG08_D_FIFO_IntStat,INT_FIFO0_CMP); /* Clear the FIFO0_Cmp */
CLR_BIT(FIFO_IntStat,INT_FIFO0_CMP);
SET_BIT(FIFO_IntEnb, INT_FIFO0_CMP);
RegSet(REG08_D_FIFO_IntEnb,BIT_EnFIFO0_Cmp);
}
if (event & FIFO_IF_FIFO_FULL) {
/* FIFO_Full is made effective*/
RegWrite(REG08_D_FIFO_IntStat,INT_FIFO_FULL); /* Clear the FIFO_Full */
CLR_BIT(FIFO_IntStat,INT_FIFO_FULL);
SET_BIT(FIFO_IntEnb, INT_FIFO_FULL);
RegSet(REG08_D_FIFO_IntEnb,BIT_EnFIFO_Full);
}
if (event & FIFO_IF_FIFO_EMPTY) {
/* FIFO_Empty is made effective */
RegWrite(REG08_D_FIFO_IntStat,INT_FIFO_EMPTY); /* Clear the FIFO_Empty */
CLR_BIT(FIFO_IntStat,INT_FIFO_EMPTY);
SET_BIT(FIFO_IntEnb, INT_FIFO_EMPTY);
RegSet(REG08_D_FIFO_IntEnb,BIT_EnFIFO_Empty);
}
if ((RegRead(REG08_MainIntEnb) & MASK_EnMediaFIFO_IntStat) != BIT_EnMediaFIFO_IntStat) {
// When the main interrupt is disabled, set it to 1
RegSet(REG08_MainIntEnb,BIT_EnMediaFIFO_IntStat);
}
if (event & FIFO_IF_MEDIA_IDE_CMP) {
/* FIFO_IDECmp is made effective*/
RegWrite(REG08_MediaFIFO_IntStat,INT_MEDIA_IDE_CMP); /* Clear the FIFO_IDE_Cmp */
CLR_BIT(MediaFIFO_IntStat,INT_MEDIA_IDE_CMP);
SET_BIT(MediaFIFO_IntEnb, INT_MEDIA_IDE_CMP);
RegSet(REG08_MediaFIFO_IntEnb,BIT_EnMediaIDE_Cmp);
}
if (event & FIFO_IF_MEDIA_FULL) {
/* FIFO_Full is made effective*/
RegWrite(REG08_MediaFIFO_IntStat,INT_MEDIA_FULL); /* Clear the FIFO_Full */
CLR_BIT(MediaFIFO_IntStat,INT_MEDIA_FULL);
SET_BIT(MediaFIFO_IntEnb, INT_MEDIA_FULL);
RegSet(REG08_MediaFIFO_IntEnb,BIT_EnFIFO_Full);
}
if (event & FIFO_IF_MEDIA_EMPTY) {
/* FIFO_Empty is made effective*/
RegWrite(REG08_MediaFIFO_IntStat,INT_MEDIA_EMPTY); /* Clear the FIFO_Empty */
CLR_BIT(MediaFIFO_IntStat,INT_MEDIA_EMPTY);
SET_BIT(MediaFIFO_IntEnb, INT_MEDIA_EMPTY);
RegSet(REG08_MediaFIFO_IntEnb,BIT_EnFIFO_Empty);
}
} else if (flag == FIFO_IF_EVENTOFF) {
if (event & FIFO_IF_FIFO_IDE_CMP) {
/* FIFO_IDECmp is invalidated */
RegClear(REG08_D_FIFO_IntEnb,BIT_EnFIFO_IDE_Cmp);
CLR_BIT(FIFO_IntEnb,INT_FIFO_IDE_CMP);
}
if (event & FIFO_IF_FIFO1_CMP) {
/* FIFO1_Cmp is invalidated */
RegClear(REG08_D_FIFO_IntEnb,BIT_EnFIFO1_Cmp);
CLR_BIT(FIFO_IntEnb,INT_FIFO1_CMP);
}
if (event & FIFO_IF_FIFO0_CMP) {
/* FIFO0_Cmp is invalidated */
RegClear(REG08_D_FIFO_IntEnb,BIT_EnFIFO0_Cmp);
CLR_BIT(FIFO_IntEnb,INT_FIFO0_CMP);
}
if (event & FIFO_IF_FIFO_FULL) {
/* FIFO_Full is invalidated */
RegClear(REG08_D_FIFO_IntEnb,BIT_EnFIFO_Full);
CLR_BIT(FIFO_IntEnb,INT_FIFO_FULL);
}
if (event & FIFO_IF_FIFO_EMPTY) {
/* FIFO_Empty is invalidated */
RegClear(REG08_D_FIFO_IntEnb,BIT_EnFIFO_Empty);
CLR_BIT(FIFO_IntEnb,INT_FIFO_EMPTY);
}
if (event & FIFO_IF_MEDIA_IDE_CMP) {
/* FIFO_IDECmp is invalidated */
RegClear(REG08_MediaFIFO_IntEnb,BIT_EnMediaIDE_Cmp);
CLR_BIT(MediaFIFO_IntEnb,INT_MEDIA_IDE_CMP);
}
if (event & FIFO_IF_MEDIA_FULL) {
/* FIFO_Full is invalidated */
RegClear(REG08_MediaFIFO_IntEnb,BIT_EnFIFO_Full);
CLR_BIT(MediaFIFO_IntEnb,INT_MEDIA_FULL);
}
if (event & FIFO_IF_MEDIA_EMPTY) {
/* FIFO_Empty is invalidated */
RegClear(REG08_MediaFIFO_IntEnb,BIT_EnFIFO_Empty);
CLR_BIT(MediaFIFO_IntEnb,INT_MEDIA_EMPTY);
}
}
break;};
return retValue;
}
/* =============================================================================
// Function_Name: FIFO_IFGetIntEvent
// argument : event Effective event
// return : STATUS_SUCCESS Terminated normally
// flag :
// global :
// =============================================================================
*/
LONG FIFO_IFGetIntEvent( UCHAR* pEvent )
{
*pEvent = FIFO_IntEnb;
return STATUS_SUCCESS;
}
/* =============================================================================
// Function_Name: FIFO_IFRegisterCBRFifoIDECmp
// description : Register the callback for the FIFO_IN_CMP notification
// argument : pfnCallback Pointer of callback function
// return : STATUS_SUCCESS Terminated normally
// STATUS_NOT_OPENED Not opened
// STATUS_UNABLE_TO_REGISTER Unable to register
// flag :
// global :
// =============================================================================
*/
LONG FIFO_IFRegisterCBRFifoIDECmp(const CALLBACK_PROC pfnCallback)
{
LONG retValue;
UCHAR i;
retValue = STATUS_UNABLE_TO_REGISTER;
while (1) {
for( i = 0; i < MAX_REGISTER_NUM; i++ )
{
if( CallbackTable[i][CBINF_FIFO_IDE_CMP] == NULL )
{
/* Registration of callback function */
CallbackTable[i][CBINF_FIFO_IDE_CMP] = pfnCallback;
retValue = STATUS_SUCCESS;
break;
}
}
break;};
return retValue;
}
/* =============================================================================
// Function_Name: FIFO_IFUnregisterCBRFifoIDECmp
// description : Delete callback registered by FIFO_IFRegisterCBRFifoIDECmp()
// argument : pfnCallback Pointer of callback function to delete
// return : STATUS_SUCCESS Terminated normally
// STATUS_NOT_OPENED Not opened
// STATUS_UNREGISTERED Unable to delete
// flag :
// global :
// =============================================================================
*/
LONG FIFO_IFUnregisterCBRFifoIDECmp(const CALLBACK_PROC pfnCallback)
{
LONG retValue;
UCHAR i;
retValue = STATUS_UNREGISTERED;
while (1) {
for( i = 0; i < MAX_REGISTER_NUM; i++ )
{
if( CallbackTable[i][CBINF_FIFO_IDE_CMP] == pfnCallback )
{
/* Callback function registration */
CallbackTable[i][CBINF_FIFO_IDE_CMP] = NULL;
retValue = STATUS_SUCCESS;
break;
}
}
break;};
return retValue;
}
/* =============================================================================
// Function_Name: FIFO_IFRegisterCBRFifo1Cmp
// description : Register the callback for the FIFO1_CMP notification
// argument : pfnCallback Pointer of callback function
// return : STATUS_SUCCESS Terminated normally
// STATUS_NOT_OPENED Not opened
// STATUS_UNABLE_TO_REGISTER Unable to register
// flag :
// global :
// =============================================================================
*/
LONG FIFO_IFRegisterCBRFifo1Cmp(const CALLBACK_PROC pfnCallback)
{
LONG retValue;
UCHAR i;
retValue = STATUS_UNABLE_TO_REGISTER;
while (1) {
for( i = 0; i < MAX_REGISTER_NUM; i++ )
{
if( CallbackTable[i][CBINF_FIFO1_CMP] == NULL )
{
/* Registration of callback function */
CallbackTable[i][CBINF_FIFO1_CMP] = pfnCallback;
retValue = STATUS_SUCCESS;
break;
}
}
break;};
return retValue;
}
/* =============================================================================
// Function_Name: FIFO_IFUnregisterCBRFifo1Cmp
// description : Delete callback registered by FIFO_IFRegisterCBRFifo1Cmp()
// argument : pfnCallback Pointer of callback function to deleted
// return : STATUS_SUCCESS Terminated normally
// STATUS_NOT_OPENED Not opened
// STATUS_UNREGISTERED Unable to delete
// flag :
// global :
// =============================================================================
*/
LONG FIFO_IFUnregisterCBRFifo1Cmp(const CALLBACK_PROC pfnCallback)
{
LONG retValue;
UCHAR i;
retValue = STATUS_UNREGISTERED;
while (1) {
for( i = 0; i < MAX_REGISTER_NUM; i++ )
{
if( CallbackTable[i][CBINF_FIFO1_CMP] == pfnCallback )
{
/* Callback function registration */
CallbackTable[i][CBINF_FIFO1_CMP] = NULL;
retValue = STATUS_SUCCESS;
break;
}
}
break;};
return retValue;
}
/* =============================================================================
// Function_Name: FIFO_IFRegisterCBRFifo0Cmp
// description : Register the callback for the FIFO0_CMP notification
// argument : pfnCallback Pointer of callback function
// return : STATUS_SUCCESS Terminated normally
// STATUS_NOT_OPENED Not opened
// STATUS_UNABLE_TO_REGISTER Unable to register
// flag :
// global :
// =============================================================================
*/
LONG FIFO_IFRegisterCBRFifo0Cmp(const CALLBACK_PROC pfnCallback)
{
LONG retValue;
UCHAR i;
retValue = STATUS_UNABLE_TO_REGISTER;
while (1) {
for( i = 0; i < MAX_REGISTER_NUM; i++ )
{
if( CallbackTable[i][CBINF_FIFO0_CMP] == NULL )
{
/* Registration of callback function */
CallbackTable[i][CBINF_FIFO0_CMP] = pfnCallback;
retValue = STATUS_SUCCESS;
break;
}
}
break;};
return retValue;
}
/* =============================================================================
// Function_Name: FIFO_IFUnregisterCBRFifo0Cmp
// description : Delete callback registered by FIFO_IFRegisterCBRFifo0Cmp()
// argument : pfnCallback Pointer of callback function to delete
// return : STATUS_SUCCESS Terminated normally
// STATUS_NOT_OPENED Not opened
// STATUS_UNREGISTERED Unable to delete
// flag :
// global :
// =============================================================================
*/
LONG FIFO_IFUnregisterCBRFifo0Cmp(const CALLBACK_PROC pfnCallback)
{
LONG retValue;
UCHAR i;
retValue = STATUS_UNREGISTERED;
while (1) {
for( i = 0; i < MAX_REGISTER_NUM; i++ )
{
if( CallbackTable[i][CBINF_FIFO0_CMP] == pfnCallback )
{
/* Callback function registration */
CallbackTable[i][CBINF_FIFO0_CMP] = NULL;
retValue = STATUS_SUCCESS;
break;
}
}
break;};
return retValue;
}
/* =============================================================================
// Function_Name: FIFO_IFRegisterCBRFifoFull
// description : Register the callback for the FIFO_FULL notification
// argument : pfnCallback Pointer of callback function
// return : STATUS_SUCCESS Terminated normally
// STATUS_NOT_OPENED Not opened
// STATUS_UNABLE_TO_REGISTER Unable to register
// flag :
// global :
// =============================================================================
*/
LONG FIFO_IFRegisterCBRFifoFull(const CALLBACK_PROC pfnCallback)
{
LONG retValue;
UCHAR i;
retValue = STATUS_UNABLE_TO_REGISTER;
while (1) {
for( i = 0; i < MAX_REGISTER_NUM; i++ )
{
if( CallbackTable[i][CBINF_FIFO_FULL] == NULL )
{
/* Registration of callback function */
CallbackTable[i][CBINF_FIFO_FULL] = pfnCallback;
retValue = STATUS_SUCCESS;
break;
}
}
break;};
return retValue;
}
/* =============================================================================
// Function_Name: FIFO_IFUnregisterCBRFifoFull
// description : Delete callback registered by FIFO_IFRegisterCBRFifoFull()
// argument : pfnCallback Pointer of callback function to delete
// return : STATUS_SUCCESS Terminated normally
// STATUS_NOT_OPENED Not opened
// STATUS_UNREGISTERED Unable to delete
// flag :
// global :
// =============================================================================
*/
LONG FIFO_IFUnregisterCBRFifoFull(const CALLBACK_PROC pfnCallback)
{
LONG retValue;
UCHAR i;
retValue = STATUS_UNREGISTERED;
while (1) {
for( i = 0; i < MAX_REGISTER_NUM; i++ )
{
if( CallbackTable[i][CBINF_FIFO_FULL] == pfnCallback )
{
/* Callback function registration */
CallbackTable[i][CBINF_FIFO_FULL] = NULL;
retValue = STATUS_SUCCESS;
break;
}
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -