fifo_if.c

epson usb2.0 控制芯片 S1R72V05 固件程序。

		}

	break;};
	return retValue;
}
/* =============================================================================
// Function_Name: FIFO_IFRegisterCBRFifoEmpty
// description	: Register the callback for the FIFO_EMPTY 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_IFRegisterCBRFifoEmpty(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_EMPTY] == NULL )
			{
				/* Registration of callback function */
				CallbackTable[i][CBINF_FIFO_EMPTY] = pfnCallback;
				retValue = STATUS_SUCCESS;
				break;
			}
		}
	break;};

	return retValue;
}
/* =============================================================================
// Function_Name: FIFO_IFUnregisterCBRFifoEmpty
// description	: Delete callback registered by FIFO_IFRegisterCBRFifoEmpty()
// 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_IFUnregisterCBRFifoEmpty(const CALLBACK_PROC pfnCallback)
{
	LONG retValue;
	UCHAR i;

	retValue = STATUS_SUCCESS;

	while (1) {
		for( i = 0; i < MAX_REGISTER_NUM; i++ )
		{
			if( CallbackTable[i][CBINF_FIFO_EMPTY] == pfnCallback )
			{
				/* Callback function registration */
				CallbackTable[i][CBINF_FIFO_EMPTY] = NULL;
				retValue = STATUS_SUCCESS;
				break;
			}
		}

	break;};
	return retValue;
}
/* =============================================================================
// Function_Name: FIFO_IFInterruptProc
// description	: It is called when there is an interrupt request
// argument		:
// return		:
// flag			:
// global		:
// =============================================================================
*/
void FIFO_IFInterruptProc(UCHAR fifoIntEnb)
{

//	pbMainIntStat  = (REG_rcMainIntStat *)&tempMainIntStat;
//	tempMainIntStat = (rcMainIntStat & (rcMainIntEnb & MASK_MAIN_INT_STAT));
//	if (pbMainIntStat->FIFO_IntStat == 1) {
/* When there is FIFO_IntStat */

//		FIFO_IntStat |= (rcFIFO_IntStat & (fifoIntEnb & rcFIFO_IntEnb));
//	FIFO_IntStat = (rcFIFO_IntStat & (fifoIntEnb | rcFIFO_IntEnb));

	FIFO_IntStat = (RegRead(REG08_D_FIFO_IntStat) & (fifoIntEnb & FIFO_IntEnb) );
	RegWrite(REG08_D_FIFO_IntStat,FIFO_IntStat);
	IntStatusCheck(FIFO_IntStat);

	/* FIFO_IntEnb is made effective */
	RegSet(REG08_D_FIFO_IntEnb,FIFO_IntEnb);
}
/* =============================================================================
// Function_Name: IntStatusCheck
// description	: Check the interrupt status
// argument		: bFIFO_IntStat		FIFO_IntStat's content
// return		:
// flag			:
// global		:
// =============================================================================
*/
static void IntStatusCheck(UCHAR bFIFO_IntStat)
{
	LONG retValue;

	if (IS_BIT(bFIFO_IntStat,BIT_FIFO_IDE_Cmp)) {
		/* FIFO_IDE_Cmp */
		retValue = SendCallback( CBINF_FIFO_IDE_CMP, 0, 0, NULL );
		if (retValue != STATUS_SUCCESS) {
			/* Abnormal */
		}
	}
	if (IS_BIT(bFIFO_IntStat,BIT_FIFO1_Cmp)) {
		/* FIFO1_Cmp */
		retValue = SendCallback( CBINF_FIFO1_CMP, 0, 0, NULL );
		if (retValue != STATUS_SUCCESS) {
			/* Abnormal */
		}
	}
	if (IS_BIT(bFIFO_IntStat,BIT_FIFO0_Cmp)) {
		/* FIFO0_Cmp */
		retValue = SendCallback( CBINF_FIFO0_CMP, 0, 0, NULL );
		if (retValue != STATUS_SUCCESS) {
			/* Abnormal */
		}
	}
	if (IS_BIT(bFIFO_IntStat,BIT_FIFO_Full)) {
		/* FIFO_Full */
		retValue = SendCallback( CBINF_FIFO_FULL, 0, 0, NULL );
		if (retValue != STATUS_SUCCESS) {
			/* Abnormal */
		}
	}
	if (IS_BIT(bFIFO_IntStat,BIT_FIFO_Empty)) {
		/* FIFO_Empty */
		retValue = SendCallback( CBINF_FIFO_EMPTY, 0, 0, NULL );
		if (retValue != STATUS_SUCCESS) {
			/* Abnormal */
		}
	}
}
/* =============================================================================
// Function_Name: FIFO_IFGetIntEventMedia
// argument		: event						Effective event
// return		: STATUS_SUCCESS			Terminated normally
// flag			:
// global		:
// =============================================================================
*/
LONG FIFO_IFGetIntEventMedia( UCHAR* pEvent )
{
	*pEvent = MediaFIFO_IntEnb;

	return STATUS_SUCCESS;
}

/* =============================================================================
// Function_Name: FIFO_IFRegisterCBRMediaIDECmp
// description	: Registered the notification callback
// 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_IFRegisterCBRMediaIDECmp(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_MEDIA_IDE_CMP] == NULL )
			{
				/* Registration of callback function */
				CallbackTable[i][CBINF_MEDIA_IDE_CMP] = pfnCallback;
				retValue = STATUS_SUCCESS;
				break;
			}
		}
	break;};

	return retValue;
}
/* =============================================================================
// Function_Name: FIFO_IFUnregisterCBRMediaIDECmp
// description	: Delete callback registered by FIFO_IFRegisterCBRFifoIDECmp()
// argument		: pfnCallback	Pointer of callback function to  registere
// return		: STATUS_SUCCESS			Terminated normally
//				  STATUS_NOT_OPENED			Not opened
//				  STATUS_UNREGISTERED		Unable to delete
// flag			:
// global		:
// =============================================================================
*/
LONG FIFO_IFUnregisterCBRMediaIDECmp(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_MEDIA_IDE_CMP] == pfnCallback )
			{
				/* Callback function registration */
				CallbackTable[i][CBINF_MEDIA_IDE_CMP] = NULL;
				retValue = STATUS_SUCCESS;
				break;
			}
		}

	break;};

	return retValue;
}
/* =============================================================================
// Function_Name: FIFO_IFRegisterCBRMediaFull
// 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_IFRegisterCBRMediaFull(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_MEDIA_FULL] == NULL )
			{
				/* Registration of callback function */
				CallbackTable[i][CBINF_MEDIA_FULL] = pfnCallback;
				retValue = STATUS_SUCCESS;
				break;
			}
		}
	break;};

	return retValue;
}
/* =============================================================================
// Function_Name: FIFO_IFUnregisterCBRMediaFull
// 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_IFUnregisterCBRMediaFull(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_MEDIA_FULL] == pfnCallback )
			{
				/* Callback function registration */
				CallbackTable[i][CBINF_MEDIA_FULL] = NULL;
				retValue = STATUS_SUCCESS;
				break;
			}
		}

	break;};
	return retValue;
}
/* =============================================================================
// Function_Name: FIFO_IFRegisterCBRMediaEmpty
// description	: Register the callback for the FIFO_EMPTY 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_IFRegisterCBRMediaEmpty(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_MEDIA_EMPTY] == NULL )
			{
				/* Registration of callback function */
				CallbackTable[i][CBINF_MEDIA_EMPTY] = pfnCallback;
				retValue = STATUS_SUCCESS;
				break;
			}
		}
	break;};

	return retValue;
}
/* =============================================================================
// Function_Name: FIFO_IFUnregisterCBRMediaEmpty
// description	: Delete callback registered by FIFO_IFRegisterCBRFifoEmpty()
// 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_IFUnregisterCBRMediaEmpty(const CALLBACK_PROC pfnCallback)
{
	LONG retValue;
	UCHAR i;

	retValue = STATUS_SUCCESS;

	while (1) {
		for( i = 0; i < MAX_REGISTER_NUM; i++ )
		{
			if( CallbackTable[i][CBINF_MEDIA_EMPTY] == pfnCallback )
			{
				/* Callback function registration */
				CallbackTable[i][CBINF_MEDIA_EMPTY] = NULL;
				retValue = STATUS_SUCCESS;
				break;
			}
		}

	break;};
	return retValue;
}

/* =============================================================================
// Function_Name: FIFO_IFInterruptProcMedia
// description	: It is called when there is an interrupt request
// argument		:
// return		:
// flag			:
// global		:
// =============================================================================
*/
void FIFO_IFInterruptProcMedia(UCHAR mediaFifoIntEnb)
{

//	pbMainIntStat  = (REG_rcMainIntStat *)&tempMainIntStat;
//	tempMainIntStat = (rcMainIntStat & (rcMainIntEnb & MASK_MAIN_INT_STAT));
//	if (pbMainIntStat->FIFO_IntStat == 1) {
/* When there is FIFO_IntStat */

//		FIFO_IntStat |= (rcFIFO_IntStat & (fifoIntEnb & rcFIFO_IntEnb));
//	FIFO_IntStat = (rcFIFO_IntStat & (fifoIntEnb | rcFIFO_IntEnb));

	MediaFIFO_IntStat = (RegRead(REG08_MediaFIFO_IntStat) & (mediaFifoIntEnb & MediaFIFO_IntEnb) );
	RegWrite(REG08_MediaFIFO_IntStat,MediaFIFO_IntStat);
	IntStatusCheckMedia(MediaFIFO_IntStat);

	/* FIFO_IntEnb is made effective */
	RegSet(REG08_MediaFIFO_IntEnb,MediaFIFO_IntEnb);
}
/* =============================================================================
// Function_Name: IntStatusCheckMedia
// description	: Check the interrupt status
// argument		: bFIFO_IntStat		FIFO_IntStat's content
// return		:
// flag			:
// global		:
// =============================================================================
*/
static void IntStatusCheckMedia(UCHAR bMediaFIFO_IntStat)
{
	LONG retValue;

	if (IS_BIT(bMediaFIFO_IntStat,BIT_MediaIDE_Cmp)) {
		/* FIFO_IDE_Cmp */
		retValue = SendCallback( CBINF_MEDIA_IDE_CMP, 0, 0, NULL );
		if (retValue != STATUS_SUCCESS) {
			/* Abnormal */
		}
	}
	if (IS_BIT(bMediaFIFO_IntStat,BIT_FIFO_Full)) {
		/* FIFO_Full */
		retValue = SendCallback( CBINF_MEDIA_FULL, 0, 0, NULL );
		if (retValue != STATUS_SUCCESS) {
			/* Abnormal */
		}
	}
	if (IS_BIT(bMediaFIFO_IntStat,BIT_FIFO_Empty)) {
		/* FIFO_Empty */
		retValue = SendCallback( CBINF_MEDIA_EMPTY, 0, 0, NULL );
		if (retValue != STATUS_SUCCESS) {
			/* Abnormal */
		}
	}
}

/* -----------------------------------------------------------------------------
// Function_Name: InitVariables
// description	: Initialize the variable used in the FIFO I/F layer
// argument		: None
// return		: STATUS_SUCCESS			Terminated normally
// flag			:
// global		:
// -----------------------------------------------------------------------------
*/
static LONG InitVariables(void)
{
	LONG retValue;

	retValue = STATUS_SUCCESS;

	while (1) {
		/* Area for Interrupt save */
		FIFO_IntStat = 0x00;
		FIFO_IntEnb = 0x00;

		/* FIFO Info */
		memset(sFifoInfo,0x00,sizeof (FIFO_INFO) * MAX_FIFO);

		/* Callback function's table */
		memset(CallbackTable,0x00,sizeof (CALLBACK_PROC) * MAX_CALLBACK * MAX_REGISTER_NUM);
	break;};

	return retValue;
}