iap.c

来自「本程序为ST公司开发的源代码」· C语言 代码 · 共 2,625 行 · 第 1/5 页

	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);