iap.c

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

	00, 0x0A, 
	00, 0x32, 00, 0x0B, 0x1F, 0xF8, 
	 00, 00, 00, 0x1F, 0xF8, 0xFF, 0xFF, 0xFF, 
	 0xFF, 0xD0, 00, 0x2F, 0xF8, 00, 00, 00, 
	 0xBF, 0xFF, 0xFF, 0xFF, 0xF4, 0x03, 0xFF, 0xFF, 
	 0xFF, 0xFF, 0xFF, 0xD0, 0xBF, 0xD0	//9
};
#endif /*IAP_TEST_COLOR*/

t_player_state iap_set_cmd_set_image(t_iap_handler hIap)
{
	t_player_state err = IAP_OK;

	if(hIap)
	{
		tIap* pIap = (tIap*)hIap;
		tIapItem Cmd;

		/* prepare iAP command chunk */
		Cmd.Code.LingoId = IAP_LINGO_EXT_INTERF;
		Cmd.Code.CmdId = IAP_EXT_SET_DISP_IMG;
		Cmd.CompleteState = IAP_ARCHIVE_ITEM_COMPLETE;

		if(i==255)
		{
#ifdef IAP_TEST_COLOR
			uint16 c;
			uint8 value = 0;
			uint8 Data[C_IAP_TEST_IMAGE_1ST_CHUNK_LEN];
			memcpy(&Data, gaIapTestIMAGEInit, sizeof(gaIapTestIMAGEInit));
			for(c=sizeof(gaIapTestIMAGEInit); c<C_IAP_TEST_IMAGE_1ST_CHUNK_LEN;c++)
			{
				Data[c] = value;
				value += 0x1;
			}
			Cmd.RemainLen = Cmd.ChunkLen = C_IAP_TEST_IMAGE_1ST_CHUNK_LEN;
			err = IAP_SetCmd(pIap, &Cmd, (uint8*)&Data, 0);
#else
			Cmd.RemainLen = Cmd.ChunkLen = C_IAP_TEST_IMAGE_1ST_CHUNK_LEN;
			err = IAP_SetCmd(pIap, &Cmd, (uint8*)&gaIapTestIMAGEInit, 0);
#endif
			i = 0;
		}
		else if(i<C_IAP_TEST_IMAGE_CHUNKS_NUM)
		{
#ifdef IAP_TEST_COLOR
			uint16 c;
			uint8 value;
			uint8 Data[C_IAP_TEST_IMAGE_CHUNK_LEN];
			Data[0] = ((i+1)>>8)&&0xFF;
			Data[1] = (i+1)&&0xFF;
			for(c=2; c<C_IAP_TEST_IMAGE_CHUNK_LEN;c++)
			{
				Data[c] = value;
				value += 0x10;
			}
			Cmd.RemainLen = Cmd.ChunkLen = C_IAP_TEST_IMAGE_CHUNK_LEN;
			err = IAP_SetCmd(pIap, &Cmd, (uint8*)&Data, 0);
#else
			Cmd.RemainLen = Cmd.ChunkLen = C_IAP_TEST_IMAGE_CHUNK_LEN;
			err = IAP_SetCmd(pIap, &Cmd, (uint8*)&(gaIapTestIMAGE.IapTestImage[i++]), 0);
#endif
			i++;
		}
	}
	else
		err = E_IAP_FATAL_CMD;

	if(M_IS_IAP_ERROR(err))
		DBG_REPORT_ERROR(err);
	return err;
}
#else /*IAP_TEST*/
t_player_state iap_set_cmd_set_image(t_iap_handler hIap) {return IAP_OK;}
#endif /*IAP_TEST*/

t_player_state iap_get_msg(t_iap_handler hIap, t_iap_msg* pMsg, uint8** ppMsgData)
{
	tIap* pIap = (tIap*)hIap;

	if(pIap)
	{
		memcpy(pMsg, &(pIap->Msg), sizeof(t_iap_msg));
		*ppMsgData = pIap->Msg.pData;
	}

	return IAP_OK;	//TBD
}

t_player_state iap_transition(t_iap_handler hIap)
{
	t_player_state ret = IAP_OK;//E_IAP;
	tIap* pIap = (tIap*)hIap;
	teIapFsmState* pFsmState = &(pIap->FsmState);
	tuIapInEvent* pInEvent= &(pIap->InEvent);
	tuIapOutEvent* pOutEvent= &(pIap->OutEvent);
	uint8 bDoRx;
	uint8 bDoRxCP;
	uint8 bFsmDone;
//	uint8 bAuth = pIap->bAuth;
//	uint8 bReady = pIap->bReady;


	M_CLEAR_FLAG(bDoRx);
	M_CLEAR_FLAG(bDoRxCP);
	M_CLEAR_FLAG(bFsmDone);
	//do
	//{
/*
		if(M_IS_SET(pInEvent->flag.Mounted))
		{
			M_CLEAR_FLAG(pInEvent->flag.Mounted);

			//IAP_Init(pIap);
			// *pFsmState = IAP_FSM_INIT;
			ret = IAP_ProcessFsm(pIap);
			break;
		}
*/		
/*
		if(M_IS_SET(pInEvent->flag.Disconnect))
		{
			M_CLEAR_FLAG(pInEvent->flag.Disconnect);

			//IAP_Close(pIap);
			// *pFsmState = IAP_FSM_DONE;
			ret = IAP_CLOSED;
			break;
		}
*/
		if(M_IS_SET(pInEvent->flag.Timer))
		{
			M_CLEAR_FLAG(pInEvent->flag.Timer);

			if(*pFsmState != IAP_FSM_DONE)
			{
				*pFsmState = IAP_FSM_DONE;
				ret = IAP_OK;//;
				//return IAP_OK;	/* immediatelly */
			}
			else
			{
				ret = IAP_TIMEOUT;
			}
			//break;
		}

		else if(M_IS_SET(pInEvent->flag.TxAck))
		{
			M_CLEAR_FLAG(pInEvent->flag.TxAck);

			/* first to reset Tx pipe */
			M_CLEAR_FLAG(gIap.Tx.bPending);
			gIap.Tx.DataLength = 0;
			//memset(&(gIap.Tx), 0, sizeof(tIapTx))

			if(*pFsmState != IAP_FSM_DONE)
			{
				ret = IAP_ProcessFsm(pIap);
				M_SET_FLAG(bFsmDone);
			}
			else
			{
				ret = IAP_OK;//;
			}
//			break;
		}

		else if(M_IS_SET(pInEvent->flag.Rx))
		{
			M_CLEAR_FLAG(pInEvent->flag.Rx);
			M_SET_FLAG(pOutEvent->flag.RxAck);

			if(*pFsmState != IAP_FSM_DONE)
			{
				if(pIap->bFree)
				{
					if(*pFsmState == IAP_FSM_IDLE)
					{
						*pFsmState = IAP_FSM_RX;
						M_SET_FLAG(bDoRx);
					}
					else
					{
						/* some process is pending -> repeat Rx event */
						//ret = IAP_REP_RX;
						M_SET_FLAG(pInEvent->flag.Rx);
						M_CLEAR_FLAG(pOutEvent->flag.RxAck);
					}
				}
				else
				{
					M_SET_FLAG(bDoRx);
				}
			}
			else
			{
//				ret = IAP_RX_DONE;
				//M_SET_FLAG(pOutEvent->flag.RxAck);
			}

			if(M_IS_SET(bDoRx))
			{
				tIapRx* pIapRx = &(pIap->Rx);
				if(IAP_IsArchiveEmpty(&(pIapRx->IapArchive)))
				{
					ret = IAP_ProcessRx(pIapRx);	//TBD
					if(ret == IAP_OK)
					{
						M_CLEAR_FLAG(pOutEvent->flag.RxAck);	/* no RxAck yet; first data processing */
						ret = IAP_ProcessFsm(pIap);
						M_SET_FLAG(bFsmDone);
					}
				}
				else
				{
					ret = E_IAP_RX;
				}
			}
			//break;
		}

		else if(M_IS_SET(pInEvent->flag.RxAcp))
		{
			M_CLEAR_FLAG(pInEvent->flag.RxAcp);

			if(*pFsmState != IAP_FSM_DONE)
			{
				if(pIap->bFree)
				{
					if(*pFsmState == IAP_FSM_IDLE)
					{
						*pFsmState = IAP_FSM_ACP;
						M_SET_FLAG(bDoRxCP);
					}
					else
					{
						//ret = IAP_REP_RX_ACP;
						M_SET_FLAG(pInEvent->flag.RxAcp);
					}
				}
				else
				{
					M_SET_FLAG(bDoRxCP);
				}
			}
			else
			{
				ret = IAP_OK;//;
			}

			if(M_IS_SET(bDoRxCP))
			{
				tIapAcp* pIapAcp = &(pIap->Acp);
				ret = IAP_ProcessAcpRx(pIapAcp);	//TBD
				if(ret == IAP_OK)
				{
					ret = IAP_ProcessFsm(pIap);
					M_SET_FLAG(bFsmDone);
				}
			}
			//break;
		}
		
		else if(M_IS_SET(pInEvent->flag.Cmd))
		{
			M_CLEAR_FLAG(pInEvent->flag.Cmd);

			if(*pFsmState != IAP_FSM_DONE)
			{
				if( //(pIap->bReady) && 
					//((*pFsmState == IAP_FSM_IDLE) || (*pFsmState == IAP_FSM_CMD)) )
					((*pFsmState == IAP_FSM_IDLE) || (*pFsmState == IAP_FSM_CMD)) )
				{
					tIapReq* pIapReq = &(pIap->Req);
					//M_CLEAR_FLAG(pIap->bReady);
					ret = IAP_ProcessCmd(pIapReq, pIap->bIsExtMode);
					if(ret == IAP_OK)
					{
						*pFsmState = IAP_FSM_CMD;
						ret = IAP_ProcessFsm(pIap);
						M_SET_FLAG(bFsmDone);
						//if(!M_IS_IAP_ERROR(ret))
						if(M_IS_IAP_ERROR(ret))
						//	ret = IAP_CMD_ACK;
						//else
							ret = E_IAP_CMD;	//TBD
					}
				}
				else
				{	/* not possible to process it now */
					/* let the cmd request pending instead of "problem"(=hold up) reporting */
					M_SET_FLAG(pInEvent->flag.Cmd);
					//ret = E_IAP_CMD;	//TBD
				}
			}
			else
			{	/* if here, cmd has been agreed */
			 	/* probbaly, iAP processing has been stopped from some reason */
				ret = E_IAP_FATAL_CMD;	//TBD - fatal or possible???
			}
			//break;
		}
		//else
		//{
		//	ret = IAP_ProcessFsm(pIap);
		//}
	//} while(0);


	// TBD 
	if(ret == IAP_OK)
	{
		if(M_IS_CLEAR(bFsmDone))
		{	/* only one call in one turn */
			ret = IAP_ProcessFsm(pIap);
		}

/*
		if(bAuth != pIap->bAuth)
		{
			if(bAuth < pIap->bAuth)
				ret = IAP_AUTH;
			else
				ret = IAP_AUTH_DONE;
		}
*/
/*
		else if(bReady != pIap->bReady)
		{
			if(bReady < pIap->bReady)
				ret = IAP_READY;
			else
				ret = IAP_BUSY;
		}
*/
	}

	if(M_IS_IAP_ERROR(ret))
		DBG_REPORT_ERROR(ret);
	return ret;
}

void IAP_Init(tIap* pIap)
{
	tIapTx* pIapTx = &(pIap->Tx);
	//tIapItem* pTxItem = &(pIapTx->Item);
	tIapItem* pCmd = &(pIap->Req.Item);

	memset(pIap, 0, sizeof(tIap));
	//pIapTx->pData = gIapTxBuffer;	/* preset pointer to the tx data buffer */
	//pTxItem->pData = gIapCmdBuffer;	/* preset pointer to the cmd data buffer */
	pCmd->pData = M_IAP_GET_CMD_BUFFER_BASE();	/* preset pointer to the cmd data buffer */
	M_SET_FLAG(pIapTx->bEndFlag);	/* indentifies that no Tx package is open */
}

void IAP_Close(tIap* pIap)
{
	
}

t_player_state IAP_ProcessRx(tIapRx* pIapRx)
{
	t_player_state err = E_IAP;
	static uint8 bStart = TRUE;
	//uint8* pData= pIapRx->pData;
	//uint16 DataLen = pIapRx->DataLength;

	IAP_ConsolidateArchive(&(pIapRx->IapArchive), bStart);
	if(bStart)
	{
		pIapRx->ErrPacketCount = 0;
		M_SET_FLAG(pIapRx->bParsing);
		err = IAP_PushOntoArchive(&(pIapRx->IapArchive), pIapRx->pData, pIapRx->DataLength);
		if (err == IAP_OK)
			M_CLEAR_FLAG(pIapRx->bParsing);
		else
		{
			DBG_REPORT_ERROR(err);
		}
	}
	else
	{
		if(pIapRx->ErrPacketCount)
		{
			pIapRx->ErrPacketCount++;
			err = E_IAP_RX_PACKET;
			DBG_REPORT_ERROR(err);
		}
		else if(M_IS_SET(pIapRx->bParsing))
		{
			//TBD - CHECK Content
			err = IAP_PushOntoArchive(&(pIapRx->IapArchive), pIapRx->pData, pIapRx->DataLength);
		}
	}

//	if(err != IAP_OK)
//	{
//		M_CLEAR_FLAG(pIapRx->bParsing);
//	}
	bStart = pIapRx->bEndFlag;

	if(M_IS_IAP_ERROR(err))
	{
		err = E_IAP_RX_PACKET;
		DBG_REPORT_ERROR(err);
	}
	return err;
}

t_player_state IAP_ProcessAcpRx(tIapAcp* pIapAcp)
{
	t_player_state err = IAP_OK;

	if(pIapAcp->Error != ACP_OK)
	{
		DBG_REPORT_ERROR(E_IAP_AUTH);
		DBG_PRINTF("iap: IAP_ProcessAcpRx: ACP error\r\n");
		return E_IAP_AUTH;	//TBD
	}

	switch(pIapAcp->Cmd)
	{
	case ACP_CMD_INIT:
		pIapAcp->InitInfo = *((tAcpInitInfo*)pIapAcp->pData);
		break;

	case ACP_CMD_GET_INFO:
		pIapAcp->Info = *((tAcpInfoStatusData*)pIapAcp->pData);
		break;

	case ACP_CMD_GET_PAGE:
		pIapAcp->pPage = (tAcpCertPageStatusData*)pIapAcp->pData;
		break;

	case ACP_CMD_GET_SIGNATURE:
		pIapAcp->pSignature = (tAcpSignatureStatusData*)pIapAcp->pData;
		break;

	default:
		err = E_IAP;
		DBG_REPORT_ERROR(err);
		DBG_PRINTF("iap: *E - FATAL: RxCopro wrong cmd\r\n");
		break;
	}

	return err;	
}

t_player_state IAP_ProcessTxCopro(tIapAcp* pIapAcp, t_acp_cmd Cmd, void* pCmdData)
{
	t_player_state err = IAP_OK;	//IAP_REQ_ACP;

	switch(Cmd)
	{
	case ACP_CMD_INIT:
		break;

	case ACP_CMD_GET_INFO:
		break;

	case ACP_CMD_GET_PAGE:
		pIapAcp->pPage = NULL;	/* clear for requested page */
		break;

	case ACP_CMD_GET_SIGNATURE:
	{
		tIapGenCmd0x17iData* pChallenge = (tIapGenCmd0x17iData*)pCmdData;
		pIapAcp->pSignature = NULL;	/* clear for requested signature */
		pIapAcp->pData = pIapAcp->InitInfo.pBuffer;
		switch(pIapAcp->Info.Version.V.AuthMajVer)
		{
		case IAP_VER_1:
			memcpy(pIapAcp->pData, pChallenge->Version.V1.Challenge, C_ACP_CHALLENGE_V1_LENGTH);	//TBD? max length pIapAcp->InitInfo.BufferLength
			break;

		case IAP_VER_2:
			memcpy(pIapAcp->pData, pChallenge->Version.V1.Challenge, C_ACP_CHALLENGE_V2_LENGTH);	//TBD? max length
			break;

		default:
			err = E_IAP;
			DBG_REPORT_ERROR(err);
			DBG_PRINTF("iap: *E - FATAL:TxCopro wrong VERSION\r\n");
			break;
		}
		break;
	}
	default:
		err = E_IAP;
		DBG_REPORT_ERROR(err);
		DBG_PRINTF("iap: *E - FATAL:TxCopro wrong CMD\r\n");
		break;
	}

	if( !(M_IS_IAP_ERROR(err)) )
	{	/* if OK */
		pIapAcp->Cmd = Cmd;
	}
	else
	{
		DBG_REPORT_ERROR(err);
	}

	return err;
}


t_player_state IAP_ProcessCmd(tIapReq* pIapReq, uint8 bIsExtMode)
{ //TBD
	t_player_state err = IAP_OK;

	return err;
}

/* JS implemented */
t_player_state IAP_ProcessFsm(tIap* pIap)
{
	t_player_state err = IAP_OK;
//	uint8 bAgain = 0;
	tIapItem* pRxItem;
	tIapGenCmd0x02iData* pIapGenCmd0x02iData;
	tIapRx* pIapRx = &(pIap->Rx);
	tIapTx* pIapTx = &(pIap->Tx);