iap.c

本程序为ST公司开发的源代码

	tIapAcp* pIapAcp = &(pIap->Acp);
	tIapReq* pIapReq = &(pIap->Req);
	tuIapOutEvent* pOutEvent = &(pIap->OutEvent);


	IAP_PauseTimer();
	while(1)	/* some cases need processing in more transitions(loop) */
	{
		switch(pIap->FsmState)
		{
		case IAP_FSM_DONE:	/* 0 */
			/* nothing to do - everything is done */
			err = E_IAP;
			DBG_REPORT_ERROR(err);
#ifdef _IAP_DEBUG
			DBG_PRINTF("IAP: ERROR this transition shouldn't be called when FSM in idle!\r\n");
#endif
			break;

		case IAP_FSM_INIT:	/* 1 */
			M_SET_FLAG(pIap->bAuth);
			err = IAP_ProcessTxCopro(pIapAcp, ACP_CMD_INIT, NULL);
			if(err == IAP_OK)
			{
				pIap->FsmState = IAP_FSM_AUTH_REQ_CP_INFO;
				IAP_SetTimer(IAP_TIMER_DEFAULT_VAL);
				//err = IAP_REQ_ACP;
				M_SET_FLAG(pOutEvent->flag.TxCP);
				//err = IAP_AUTH;	//QQQQQQQQQQQQQQQQQ
			}
			else
			{
				DBG_REPORT_ERROR(err);
				IAP_ContinueTimer();
				//err = IAP_OK;
			}
			break;

		case IAP_FSM_AUTH_REQ_CP_INFO:	/* 2 */
			if(pIapAcp->InitInfo.pBuffer)
			{
				err = IAP_ProcessTxCopro(pIapAcp, ACP_CMD_GET_INFO, NULL);
				if(err == IAP_OK)
				{
					pIap->FsmState = IAP_FSM_AUTH_GET_CP_INFO;
					IAP_SetTimer(IAP_TIMER_DEFAULT_VAL);
					//err = IAP_REQ_ACP;
					M_SET_FLAG(pOutEvent->flag.TxCP);
				}
				else
				{
					DBG_REPORT_ERROR(err);
					IAP_ContinueTimer();
					//err = IAP_OK;
				}
			}
			break;

		case IAP_FSM_AUTH_GET_CP_INFO:	/* 3 */
			if (pIapAcp->Info.Version.V.AuthMajVer)	/* if some version */
			{
				pIap->Info.AuthMajVer = pIapAcp->Info.Version.V.AuthMajVer;
				pIap->Info.AuthMinVer = pIapAcp->Info.Version.V.AuthMinVer;
				pIap->FsmState = IAP_FSM_AUTH_TX_13;
				M_SET_FLAG(pIap->bAgain);
			}
			else
			{
				err = IAP_OK;
				IAP_ContinueTimer();
			}
			break;

		case IAP_FSM_AUTH_TX_13:	/* 4 */
			if(M_IS_SET(pIapTx->bPending))
			{
				err = IAP_OK;
				IAP_ContinueTimer();
			}
			else
			{
				err = IAP_ProcessTxRequest(pIap, IAP_LINGO_GENERAL, IAP_GEN_IDENT_DEV_LINGO, NULL, NULL);
				if(err == IAP_OK)
				{
					M_SET_FLAG(pIapTx->bPending);
					pIap->FsmState = IAP_FSM_AUTH_RX_ACK13;
					IAP_SetTimer(IAP_TIMER_DEFAULT_VAL);
					//err = IAP_REQ_TX;
					M_SET_FLAG(pOutEvent->flag.Tx);
				}
				else
				{
					DBG_REPORT_ERROR(err);
				}
			}
			break;

		case IAP_FSM_AUTH_RX_ACK13:	/* 5 */
//			if( (!IAP_IsArchiveEmpty(&(pIapRx->IapArchive))) && 
//				(E_IAP != IAP_PopArchive(&(pIapRx->IapArchive), &pRxItem)) )	/* archive contains some data */
			err = IAP_PopArchive(&(pIapRx->IapArchive), &pRxItem);
			if(err == IAP_RX_DONE)
			{
				M_SET_FLAG(pIap->OutEvent.flag.RxAck);
				err = IAP_OK;
			}

			if(err != E_IAP)	/* archive contains some data */
			{
				if( (pRxItem->Code.LingoId == IAP_LINGO_GENERAL) && (pRxItem->Code.CmdId == IAP_GEN_ACK) )	/* ACK (13) */
				{
					pIapGenCmd0x02iData = (tIapGenCmd0x02iData*)pRxItem->pData;
					if(pIapGenCmd0x02iData->Ack.Done.result == IAP_E_CMD_PENDING)
					{
						IAP_SetTimer( SWAP32_FROM(&(pIapGenCmd0x02iData->Ack.Pending.MaxPendWait)) );
					}
					/* ACK finished, check state OK */
					else if ((IAP_ACK == pIapGenCmd0x02iData->Ack.Done.result) 
						&& (IAP_GEN_IDENT_DEV_LINGO == pIapGenCmd0x02iData->Ack.Done.CmdAck))
					{
						pIap->FsmState = IAP_FSM_AUTH_RX_14; 
						IAP_SetTimer(IAP_TIMER_DEFAULT_VAL);
					}
					else
					{
						pIap->FsmState = IAP_FSM_DONE;
						//err = E_IAP_ACK;	//LL
						err = E_IAP_AUTH;	//LL
						DBG_REPORT_ERROR(err);
					}
				}
				else
				{
					M_SET_FLAG(pIap->bAgain);	/* contine commands processing to find ACK 13 */
				}
			}
			else
			{
				IAP_ContinueTimer();
				err = IAP_OK;
			}
			break;

		case IAP_FSM_AUTH_RX_14:	/* 6 */
//			if( (!IAP_IsArchiveEmpty(&(pIapRx->IapArchive))) && 
//				(E_IAP != IAP_PopArchive(&(pIapRx->IapArchive), &pRxItem)) )	/* archive contains some data */
			err = IAP_PopArchive(&(pIapRx->IapArchive), &pRxItem);
			if(err == IAP_RX_DONE)
			{
				M_SET_FLAG(pIap->OutEvent.flag.RxAck);
				err = IAP_OK;
			}

			if(err != E_IAP)	/* archive contains some data */
			{
				if( (pRxItem->Code.LingoId == IAP_LINGO_GENERAL) && (pRxItem->Code.CmdId == IAP_GEN_GET_DEV_AUTH_INFO) )	/* Archive == 14 */
				{
					pIap->FsmState = IAP_FSM_AUTH_REQ_CP_PAGE;
					IAP_SetTimer(IAP_TIMER_DEFAULT_VAL);
				}
				else
					M_SET_FLAG(pIap->bAgain);	/* contine commands processing to find 14 */
			}
			else
			{
				err = IAP_OK;
				IAP_ContinueTimer();
			}
			break;

		case IAP_FSM_AUTH_REQ_CP_PAGE:	/* 7 */
			err = IAP_ProcessTxCopro(pIapAcp, ACP_CMD_GET_PAGE, NULL);
			if(err == IAP_OK)
			{
				pIap->FsmState = IAP_FSM_AUTH_GET_CP_PAGE;
				IAP_SetTimer(IAP_TIMER_DEFAULT_VAL);
				//err = IAP_REQ_ACP;
				M_SET_FLAG(pOutEvent->flag.TxCP);
			}
			else
			{
				DBG_REPORT_ERROR(err);
				IAP_ContinueTimer();
				//err = IAP_OK;
			}
			break;

		case IAP_FSM_AUTH_GET_CP_PAGE:	/* 8 */
			if (pIapAcp->pPage)	/* CpPage page has come */
			{
				pIap->FsmState = IAP_FSM_AUTH_TX_15;
				M_SET_FLAG(pIap->bAgain);	/* continue processing */
			}
			else
			{
				err = IAP_OK;
			}
			break;

		case IAP_FSM_AUTH_TX_15:	/* 9 */
			if(M_IS_SET(pIapTx->bPending)) /* tx pending */
			{
				IAP_ContinueTimer();
				err = IAP_OK;
			}
			else
			{
				err = IAP_ProcessTxRequest(pIap, IAP_LINGO_GENERAL, IAP_GEN_RET_DEV_AUTH_INFO, NULL, NULL);
				if(err == IAP_OK)
				{
					M_SET_FLAG(pIapTx->bPending);
					pIap->FsmState = IAP_FSM_AUTH_RX_16;//?IAP_FSM_AUTH_RX_ACK13;
					IAP_SetTimer(IAP_TIMER_DEFAULT_VAL);
					//err = IAP_REQ_TX;
					M_SET_FLAG(pOutEvent->flag.Tx);
				}
				else
				{
					DBG_REPORT_ERROR(err);
				}
			}
			break;

		case IAP_FSM_AUTH_RX_16:	/* 10 */
//			if( (!IAP_IsArchiveEmpty(&(pIapRx->IapArchive))) && 
//				(E_IAP != IAP_PopArchive(&(pIapRx->IapArchive), &pRxItem)) )	/* archive contains some data */
			err = IAP_PopArchive(&(pIapRx->IapArchive), &pRxItem);
			if(err == IAP_RX_DONE)
			{
				M_SET_FLAG(pIap->OutEvent.flag.RxAck);
				err = IAP_OK;
			}

			if(err != E_IAP)	/* archive contains some data */
			{
				if( (pRxItem->Code.LingoId == IAP_LINGO_GENERAL) && (pRxItem->Code.CmdId == IAP_GEN_ACK_DEV_AUTH_INFO) )	/* Archive == 0x16 */
				{
					pIap->FsmState = IAP_FSM_TX_F;
					//pIap->FsmState = IAP_FSM_IDLE;		//LL
					//M_SET_FLAG(pIap->bFree);	/* permits a free order of the iAPs */ //LL
					IAP_SetTimer(IAP_TIMER_DEFAULT_VAL);
				}
				else
				{
					if ( (pRxItem->Code.LingoId == IAP_LINGO_GENERAL) && (pRxItem->Code.CmdId == IAP_GEN_ACK) )	/* ACK (15) */
					{
						pIapGenCmd0x02iData = (tIapGenCmd0x02iData*)pRxItem->pData;
						if(pIapGenCmd0x02iData->Ack.Done.result == IAP_E_CMD_PENDING)
						{
							IAP_SetTimer( SWAP32_FROM(&(pIapGenCmd0x02iData->Ack.Pending.MaxPendWait)) );
						}
						/* ACK finished, check state OK */
						else if((IAP_ACK == pIapGenCmd0x02iData->Ack.Done.result) 
							&& (IAP_GEN_RET_DEV_AUTH_INFO == pIapGenCmd0x02iData->Ack.Done.CmdAck))
						{
							pIap->FsmState = IAP_FSM_AUTH_REQ_CP_PAGE; 
							IAP_SetTimer(IAP_TIMER_DEFAULT_VAL);
						}
						else
						{
							pIap->FsmState = IAP_FSM_DONE;
							//err = E_IAP_ACK;	//LL
							err = E_IAP_AUTH;	//LL
							DBG_REPORT_ERROR(err);
						}
					}
					else
						M_SET_FLAG(pIap->bAgain);	/* contine commands processing to find 15 */
				}
			}
			else
			{
				err = IAP_OK;
				IAP_ContinueTimer();
			}
			break;

		case IAP_FSM_TX_F:	/* 11 */
			if(M_IS_SET(pIapTx->bPending)) /* tx pending */
			{
				IAP_ContinueTimer();
				err = IAP_OK;
			}
			else
			{
				/* to request first or next remaining lingo version info */
				err = IAP_ProcessTxRequest(pIap, IAP_LINGO_GENERAL, IAP_GEN_REQ_LINGO_VER, NULL, NULL);	//TBD
				if(err == IAP_READY)
				{	/* no remaining lingo version information is missing */
					/* switch to the Extended Interface */
					err = IAP_ProcessTxRequest(pIap, IAP_LINGO_GENERAL, IAP_GEN_ENT_REM_UI, NULL, NULL);
				}

				if(err == IAP_OK)
				{
					pIap->FsmState = IAP_FSM_TX;
					M_SET_FLAG(pIap->bFree);	/* permits a free order of the iAPs */
					M_SET_FLAG(pIap->bAgain);	/* continue processing */
				}
				else
				{
					pIap->FsmState = IAP_FSM_IDLE;
					DBG_REPORT_ERROR(err);
				}
			}
			break;

		case IAP_FSM_IDLE:	/* 20 */
			/* only in Free mode here */
#ifdef _IAP_DEBUG
			DBG_PRINTF("iap: ProcessFsm in transition IAP_FSM_IDLE\r\n");
#endif
			//TBD - to check if Archive is empty
			//ddd
			/* to check if package Tx is done */
			if(M_IS_SET(pIapReq->bSemifinished))
			{
				if(!(M_IS_SET(pIapTx->bEndFlag)))
					pIap->FsmState = IAP_FSM_CMD;	/* continue in cmd processing */
				else
			 		M_SET_FLAG(pIap->bReady);	//TBD - not clear; bReady can be set prematurely
			}
			
//			err = IAP_OK;
			break;

		case IAP_FSM_TX:	/* 21 */
			if(M_IS_SET(pIapTx->bPending)) /* tx pending */
			{
				IAP_ContinueTimer();
				err = IAP_OK;
			}
			else
			{
				/* no command is sent here, only flag */
				M_SET_FLAG(pIapTx->bPending);	/* indicate Tx pipe is not ready */
				pIap->FsmState = IAP_FSM_IDLE;	/* Tx packet processing is done */
				//err = IAP_REQ_TX;
				M_SET_FLAG(pOutEvent->flag.Tx);	/* Tx data packet is going to be sent */
			}
			break;

		case IAP_FSM_RX:	/* 22 */
//			if (E_IAP != IAP_PopArchive(&(pIapRx->IapArchive), &pRxItem))	/* archive contains some data */
			err = IAP_PopArchive(&(pIapRx->IapArchive), &pRxItem);
			if(err == IAP_RX_DONE)
			{
				M_SET_FLAG(pIap->OutEvent.flag.RxAck);
				err = IAP_OK;
			}

			if(err != E_IAP)	/* archive contains some data */
			{
				/* Decode RX */
				err = IAP_DecodeRx(pIap, pRxItem);
			}
			else /* no command ready */
			{
				DBG_REPORT_ERROR(err);
#ifdef _IAP_DEBUG
				DBG_PRINTF("iap: *W - ProcessFsm in transition IAP_FSM_RX no cmd ready!\r\n");
#endif
				err = IAP_OK;
			}
			break;

		case IAP_FSM_ACP:	/* 23 */
			err = IAP_DecodeAcp(pIap, pIapAcp);
			if (err == IAP_OK) /* retval OK keeps fsm running, processing continues */
			{
				M_SET_FLAG(pIap->bAgain);	/* continue processing */
			}
			else
			{
				DBG_REPORT_ERROR(err);
			}
			break;

		case IAP_FSM_CMD:	/* 24 */
			err = IAP_DecodeCmd(pIap, pIapReq);
			if(IAP_OK == err)   /* retval OK keeps fsm running, processing continues */
			{
				M_SET_FLAG(pIap->bAgain);	/* continue processing */
			}
			else
			{
				DBG_REPORT_ERROR(err);
			}
			break;

		case IAP_FSM_REFRESH_TX:	/* 25 */
//			IAP_Refresh(pIap);
			err = IAP_ProcessTxRequest(pIap, (teIapLingoId)C_IAP_LINGO_NO, C_IAP_CMD_REFRESH, NULL, NULL);	//TBD

			break;

		default:
#ifdef _IAP_DEBUG
			DBG_PRINTF("iap: *W - UNKNOWN transition in ProcessFsm\r\n");
#endif
			break;
		}

		if(M_IS_SET(pIap->bAgain))
		{
			M_CLEAR_FLAG(pIap->bAgain);
		}
		else
		{
			if(M_IS_IAP_ERROR(err))
				DBG_REPORT_ERROR(err);
			return err;	//TBD
		}
	}
}

/* precondition: LingoId and CmdId have sense; both ID's must be under iAP layer control */
t_player_state IAP_ProcessTxRequest(tIap* pIap, teIapLingoId IapLingoId, tIapCmdId IapCmdId, tIapItem* pCmdItem, void* pCmdData)
{
	t_player_state err = E_IAP;
	uint8 bIsFreeCmd;
	tIapTx* pIapTx = &(pIap->Tx);
	tIapItem* pTxItem = &(pIapTx->Item);
	tAcpInfoStatusData* pInfo = &(pIap->Acp.Info);


	M_CLEAR_FLAG(bIsFreeCmd);
	pTxItem->pData = M_IAP_GET_CMD_BUFFER_BASE();
	switch (IapLingoId)
	{
//	case C_IAP_REQ_REFRESH:
//		/* first priority refreshing */
//		break;
//
	case IAP_LINGO_GENERAL:
		switch (IapCmdId)
		{
		case IAP_GEN_REQ_REM_UI:
		case IAP_GEN_ENT_REM_UI:
		case IAP_GEN_EXIT_REM_UI:
//		case IAP_GEN_REQ_NAME:
//		case IAP_GEN_REQ_SW_VER:
//		case IAP_GEN_REQ_SER_NUM:
//		case IAP_GEN_REQ_MODEL:
			break;

		case IAP_GEN_REQ_LINGO_VER:
		{
			uint8* pData = pTxItem->pData;
			/* identify which lingo version information is missing and request it */
			if( (M_IS_CLEAR(pIap->Info.FoundLingoSpoken.Gen))  && 
				(M_IS_SET(gIapPRESET.DevLingoesSpoken.flag.Gen)) )
				*pData = IAP_LINGO_GENERAL;
			else if( (M_IS_CLEAR(pIap->Info.FoundLingoSpoken.Ext))  && 
				(M_IS_SET(gIapPRESET.DevLingoesSpoken.flag.Ext)) )
				*pData = IAP_LINGO_EXT_INTERF;
			else if( (M_IS_CLEAR(pIap->Info.FoundLingoSpoken.Dig)) && 
				(M_IS_SET(gIapPRESET.DevLingoesSpoken.flag.Dig)) )
				*pData = IAP_LINGO_DIG_AUDIO;
			else
				return IAP_READY;
//			pTxItem->CompleteState = IAP_ARCHIVE_ITEM_COMPLETE;
			break;
		}

		case IAP_GEN_IDENT_DEV_LINGO:
		{
			tIapGenCmd0x13Data* pData = (tIapGenCmd0x13Data*)(pTxItem->pData);
			//pData->DevLingoesSpoken.flags = 0;
			//pData->DevLingoesSpoken.flag.Gen = gIapPRESET.DevLingoesSpoken.Gen;
			//pData->DevLingoesSpoken.flag.Ext = gIapPRESET.DevLingoesSpoken.Ext;
			pData->DevLingoesSpoken.flags = gIapPRESET.DevLingoesSpoken.flags;
			if (pInfo->Version.V.FWMajVer == IAP_VER_1)
			{
				pData->DeviceID = pInfo->Version.V1.DeviceID;
			}
			else
			{
				pData->DeviceID = SWAP32_FROM(&(pInfo->Version.V2.DeviceID));
				pData->Options.flags = 0;
				pData->Options.flag.AuthCtrl = C_IAP_13_CTRL_IMMED;
				pData->Options.flag.PowerCtrl = C_IAP_13_POWER_INTERMIT;
			}
//			pTxItem->CompleteState = IAP_ARCHIVE_ITEM_COMPLETE;
			break;
		}

		case IAP_GEN_RET_DEV_AUTH_INFO:
		{
			tIapGenCmd0x15Data* pData = (tIapGenCmd0x15Data*)(pTxItem->pData);
			tAcpCertPageStatusData* pPage = pIap->Acp.pPage;
			pData->VerNum = (teIapVersion)pInfo->Version.V.FWMajVer;
			if (pInfo->Version.V.FWMajVer == IAP_VER_1)
			{
				pData->Version.V1.AuthMajVer = pInfo->Version.V1.AuthMajVer;
				pData->Version.V1.AuthMinVer = pInfo->Version.V1.AuthMinVer;
			}
			else
			{
				pData->Version.V2.AuthMajVer = pInfo->Version.V2.AuthMajVer;
				pData->Version.V2.AuthMinVer = pInfo->Version.V2.AuthMinVer;
				pData->Version.V2.MaxSectIndex = pInfo->Version.V2.PageMaxNum - 1;
				pData->Version.V2.CurSectIndex = pPage->PageNum;
				pData->Version.V2.CertDataLen = pPage->PageLen;
				pData->Version.V2.pCertData = pPage->PageData;
			}
//			pTxItem->CompleteState = IAP_ARCHIVE_ITEM_COMPLETE;
			break;
		}

		case IAP_GEN_RET_DEV_AUTH_SIGN:
		{
			tIapGenCmd0x18Data* pData = (tIapGenCmd0x18Data*)(pTxItem->pData);
			tAcpSignatureStatusData* pSignature = pIap->Acp.pSignature;
			pData->pSignData = pSignature->SignatureData;
			pData->SignatureLen = pSignature->SignatureLen;
//			pTxItem->CompleteState = IAP_ARCHIVE_ITEM_COMPLETE;
			break;
		}

		case IAP_GEN_GET_AUTH_INFO:
			//TBD
			break;

		case IAP_GEN_ACK_AUTH_INFO: