iap.c

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

			//TBD
			break;

		case IAP_GEN_GET_AUTH_SIGN:
			//TBD
			break;

		case IAP_GEN_ACK_AUTH_STATUS:
			//TBD
			break;

		case IAP_GEN_GET_OPTIONS:
			//TBD
			break;

		case IAP_GEN_RET_ACC_INFO:
		{
			tIapGenCmd0x27iData* pSource = (tIapGenCmd0x27iData*)(pCmdData);
			tIapGenCmd0x28Data* pData = (tIapGenCmd0x28Data*)(pTxItem->pData);

			pData->InfoType = pSource->InfoType;
			switch(pSource->InfoType)
			{//TBD - to handle options
			case IAP_INFOTYPE_CAPABILITIES:		/* 0x00 */
				pData->Params.Type0.Capab.flags = 0;
				pData->Params.Type0.Capab.flag.InfoCapab = 1;
				//pData->Params.Type0.Capab.flag.Name = 1;
				//pData->Params.Type0.Capab.flag.FWVer = 1;
				//pData->Params.Type0.Capab.flag.Manufacturer = 1;
				//pData->Params.Type0.Capab.flag.ModelNum = 1;
				//pData->Params.Type0.Capab.flag.SerialNum = 1;
				pData->Params.Type0.Capab.flag.InMaxPloadSize = 1;
				break;
			case IAP_INFOTYPE_NAME:				/* 0x01 */
				pData->Params.Type1678.pString = gIapPRESET.AccInfoNAME;
				pData->Params.Type1678.StringLen = sizeof(gIapPRESET.AccInfoNAME);
				break;
			case IAP_INFOTYPE_MANUFACTURER:		/* 0x06 */
				pData->Params.Type1678.pString = gIapPRESET.AccInfoMFACTURER;
				pData->Params.Type1678.StringLen = sizeof(gIapPRESET.AccInfoMFACTURER);
				break;
			case IAP_INFOTYPE_MODEL_NUM:		/* 0x07 */
				pData->Params.Type1678.pString = gIapPRESET.AccInfoMODEL;
				pData->Params.Type1678.StringLen = sizeof(gIapPRESET.AccInfoMODEL);
				break;
			case IAP_INFOTYPE_SERIAL_NUM:		/* 0x08 */
				pData->Params.Type1678.pString = gIapPRESET.AccInfoSN;
				pData->Params.Type1678.StringLen = sizeof(gIapPRESET.AccInfoSN);
				break;
			case IAP_INFOTYPE_MIN_SUP_FW_VER:	/* 0x02 */
				break;
			case IAP_INFOTYPE_MIN_SUP_LINGO_VER:/* 0x03 */
				break;
			case IAP_INFOTYPE_FW_VER:			/* 0x04 */
				pData->Params.Type45.AccMajorVerNum = 3;
				pData->Params.Type45.AccMinorVerNum = 3;
				pData->Params.Type45.AccRevVerNum = 11;
				break;
			case IAP_INFOTYPE_HW_VER:			/* 0x05 */
				pData->Params.Type45.AccMajorVerNum = 0;
				pData->Params.Type45.AccMinorVerNum = 0;
				pData->Params.Type45.AccRevVerNum = 0;
				break;
			case IAP_INFOTYPE_IN_MAX_PLOAD_SIZE:/* 0x09 */
				pData->Params.Type9.MaxPayloadSize = gIapPRESET.AccInfoMaxPSize;
				break;
			default :
				DBG_REPORT_ERROR(err);
				return err;
			}
//			pTxItem->CompleteState = IAP_ARCHIVE_ITEM_COMPLETE;
			break;
		}

		case IAP_GEN_GET_PREFERENC:
			//TBD
			break;

		case IAP_GEN_SET_PREFERENC:
			//TBD
			break;

		default:
//			DBG_REPORT_ERROR(err);
//#ifdef _IAP_DEBUG
//			DBG_PRINTF("iap: *W - ProcessTxRequest func called with wrong IapCmdId\r\n");
//#endif
//			return err;
			M_SET_FLAG(bIsFreeCmd);
			break;	/* everything is possible */
		}
		break;

	case IAP_LINGO_EXT_INTERF:
	{
		switch (IapCmdId)
		{
//		case IAP_EXT_PLAY_CONTROL:
//			//*(pTxItem->pData) = *(uint8*)pCmdData;	//TBD
//			break;

		default:
//			DBG_REPORT_ERROR(err);
//#ifdef _IAP_DEBUG
//			DBG_PRINTF("iap: *W - ProcessTxRequest func called with wrong IapCmdId\r\n");
//#endif
//			return err;
			M_SET_FLAG(bIsFreeCmd);
			break;	/* everything is possible */
		}
		break;
	}
	case IAP_LINGO_DIG_AUDIO:
	{
		switch (IapCmdId)
		{

		default:
			M_SET_FLAG(bIsFreeCmd);
			break;	/* everything is possible */
		}
		break;
	}
	case C_IAP_LINGO_NO:
	{
		switch (IapCmdId)
		{
		case C_IAP_CMD_REFRESH:
			IAP_PrepareRefreshPacket(pIapTx);
			return err;

		case C_IAP_CMD_PASS:
			M_SET_FLAG(bIsFreeCmd);
			break;

		default:
			err = E_IAP_FATAL;
			DBG_REPORT_ERROR(err);
			return err;	//TBD - can not happen <= we control the C_IAP_LINGO_NO set
		}
		break;
	}
	default:
#ifdef _IAP_DEBUG
		DBG_PRINTF("iap: *W - ProcessTxRequest not implemented part\r\n");
#endif
//		DBG_REPORT_ERROR(err);
//		return err;
		M_SET_FLAG(bIsFreeCmd);
		break;	/* everything is possible */
	}
	//err = IAP_PreparePacket(pTxItem, pIapTx->pData, &(pIapTx->DataLength));	//LL
	if(M_IS_SET(bIsFreeCmd))
	{	/* command comming from outside */
		memcpy(pTxItem, pCmdItem, sizeof(tIapItem)); /* copy request */
		/* data is just prepared in the CMD_BUFFER */
	}
	else
	{	/* command formed internally */
		pTxItem->Code.CmdId = IapCmdId;
		pTxItem->Code.LingoId = IapLingoId;
	}

	err = IAP_PreparePacket(pIapTx, pTxItem);		//LL
//	ddd
	if(M_IS_SET(bIsFreeCmd))
	{
		if(pTxItem != IAP_ARCHIVE_ITEM_FREE)
		{	/* cmd has not been fully processed */
			memcpy(pCmdItem, pTxItem, sizeof(tIapItem));
			M_SET_FLAG(pIap->Req.bSemifinished);
			
		}
	}
	
	if(M_IS_IAP_ERROR(err))
		DBG_REPORT_ERROR(err);
	return err;
}

t_player_state IAP_DecodeRx(tIap* pIap, tIapItem* pRxItem)
{
	t_player_state err = IAP_OK;

	switch(pRxItem->Code.LingoId)
	{
	case IAP_LINGO_GENERAL:
		err = IAP_DecodeRxGen(pIap, pRxItem); /* CP/TX Request/msg/is done inside */
		break;

	case IAP_LINGO_EXT_INTERF:
		err = IAP_DecodeRxExt(pIap, pRxItem); /* CP/TX Request/msg/is done inside */
		break;

	case IAP_LINGO_DIG_AUDIO:
		err = IAP_DecodeRxAud(pIap, pRxItem); /* CP/TX Request/msg/is done inside */
		break;

	default:
#ifdef _IAP_DEBUG
		DBG_PRINTF("iap: *W - ProcessFsm: unsupported lingo in IAP_FSM_RX\r\n");
#endif
		err = E_IAP_ID_LINGO; /* not processed command */
		DBG_REPORT_ERROR(err);
		break;
	}

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

t_player_state IAP_DecodeRxGen(tIap* pIap, tIapItem* pRxItem)
{
	t_player_state err = IAP_OK;
	tuIapOutEvent* pOutEvent = &(pIap->OutEvent);

	switch(pRxItem->Code.CmdId)
	{
	case IAP_GEN_ACK:	/* 0x02 */
	{
		tIapGenCmd0x02iData* pIapGenCmd0x02iData = (tIapGenCmd0x02iData*)(pRxItem->pData);
		tIapMsg* pIapMsg = (tIapMsg*)&(pIap->Msg);

		pIap->FsmState = IAP_FSM_IDLE;
		if(pIapGenCmd0x02iData->Ack.Done.result == IAP_E_CMD_PENDING)
		{	/* case: ACK pending */
			IAP_SetTimer( SWAP32_FROM(&(pIapGenCmd0x02iData->Ack.Pending.MaxPendWait)) );
		}
		/* ACK finished, check state OK */
		else 
		{	/* case: ACK */
			pIapMsg->Code.LingoId = IAP_LINGO_GENERAL;	//TBD - preset
			pIapMsg->Code.CmdId = pIapGenCmd0x02iData->Ack.Done.CmdAck;
			pIapMsg->RemainLen = pIapMsg->ChunkLen = pRxItem->RemainLen;	//TBD - preset
			//M_SET_FLAG(pIapMsg->bFirstChunk);	//TBD - preset
			pIapMsg->CompleteState = IAP_ARCHIVE_ITEM_COMPLETE;	//TBD - preset

			//pIapGenCmd0x02iData->Ack.Done.CmdAck
			if (pIapGenCmd0x02iData->Ack.Done.result != IAP_ACK)
			{	/* case: command NOT acknowledged ~= some error */
				if(M_IS_CLEAR(pIap->bIsExtMode))
				{
					err = E_IAP_AUTH;
				}
				else
				{
					//tIapReq* pIapCmd = (tIapReq*)&(pIap->Cmd);
					//if(pIapCmd->Code.CmdId == pIapMsg->Code.CmdId)
					//{	/* case: CmdId of the ACK is equal to the CmdId of the Cmd */
					//	/* let say that Cmd and Ack corresponds together */
					//	pIapMsg->Code.LingoId = pIapCmd->Code.LingoId;
						err = E_IAP_MSG;
					//}
					//else
					//{	/* in extended mode can not happen (should not?)*/
					//	err = E_IAP;	//TBD
					//}
				}
				DBG_REPORT_ERROR(err);
			}
			else
			{	/* case: command acknowledged by iPod */
				if(M_IS_CLEAR(pIap->bIsExtMode))
				{
					if(pIapGenCmd0x02iData->Ack.Done.CmdAck == IAP_GEN_ENT_REM_UI)	//redundant condition
					{
						M_SET_FLAG(pIap->bIsExtMode);	/* info about the iPod in Extended mode */
						M_SET_FLAG(pIap->bReady);	/* user can start to use the commands */
						err = IAP_READY;
					}
					else
					{	//TBD - general lingo ACK errors
						err = E_IAP;
						DBG_REPORT_ERROR(err);
					}
				}
				else
				{
					if(pIapGenCmd0x02iData->Ack.Done.CmdAck == IAP_GEN_EXIT_REM_UI)	//redundant condition
					{
						M_CLEAR_FLAG(pIap->bReady);	/* user can start to use the commands */
						M_CLEAR_FLAG(pIap->bIsExtMode);	/* info about the iPod in Standard mode */
						err = IAP_NOT_READY;
					}
					else
					{
						err = IAP_MSG;
					}
				}
			}
		}
		break;
	}
	case IAP_GEN_RET_LINGO_VER:	/*0x10*/
	{
		tIapGenProtocolVersion* pProtocolVersion = (tIapGenProtocolVersion*)(pRxItem->pData);
		tIapInfo* pInfo = &(pIap->Info);

		pIap->FsmState = IAP_FSM_IDLE;	/* in general */ //TBD - could be by the more general?
		switch(pProtocolVersion->LingoId)
		{
		case IAP_LINGO_GENERAL:	//TBD
			M_SET_FLAG(pInfo->FoundLingoSpoken.Gen);
			pInfo->Gen.ProtMajVer = pProtocolVersion->Major;
			pInfo->Gen.ProtMinVer = pProtocolVersion->Minor;
			break;

		case IAP_LINGO_EXT_INTERF:
			M_SET_FLAG(pInfo->FoundLingoSpoken.Ext);
			pInfo->Ext.ProtMajVer = pProtocolVersion->Major;
			pInfo->Ext.ProtMinVer = pProtocolVersion->Minor;
			break;

		case IAP_LINGO_DIG_AUDIO:
			M_SET_FLAG(pInfo->FoundLingoSpoken.Dig);
			pInfo->Aud.ProtMajVer = pProtocolVersion->Major;
			pInfo->Aud.ProtMinVer = pProtocolVersion->Minor;
			break;

		default:
			err = E_IAP_ID_LINGO;
			DBG_REPORT_ERROR(err);
			break;
		}

		if(!M_IS_IAP_ERROR(err))
		{
			/* to request next lingo version info */
			err = IAP_ProcessTxRequest(pIap, IAP_LINGO_GENERAL, IAP_GEN_REQ_LINGO_VER, NULL, NULL);
			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->bAgain);	/* continue processing */
			}
			else
			{
				DBG_REPORT_ERROR(err);
			}
		}

		break;
	}
	case IAP_GEN_GET_DEV_AUTH_INFO:	/*0x14*/
		pIap->FsmState = IAP_FSM_AUTH_REQ_CP_PAGE;
		M_CLEAR_FLAG(pIap->bFree);	/* exiting free mode */
		M_CLEAR_FLAG(pIap->bReady);	/* auhentication has to start = iAP layer is not ready */
		M_SET_FLAG(pIap->bAuth);	/* iPod requests "re"authentication */
		err = IAP_NOT_READY; /* iPod seems to be in Extended mode but IAP is not in the Free mode */
		break;

	case IAP_GEN_GET_DEV_AUTH_SIGN:	/*0x17*/
	{
		tIapAcp* pIapAcp = &(pIap->Acp);
		err = IAP_ProcessTxCopro(pIapAcp, ACP_CMD_GET_SIGNATURE, pRxItem->pData);
		if(err == IAP_OK)
		{	//TBD
			pIap->FsmState = IAP_FSM_IDLE;
			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_GEN_ACK_DEV_AUTH_STAT:	/*0x19*/
	{
		teIapAck Ack = *((teIapAck*)(pRxItem->pData));
		if(Ack != IAP_ACK)
		{
			M_CLEAR_FLAG(pIap->bIsExtMode);	/* iPod has been automatically switched to the Standard mode */
			pIap->FsmState = IAP_FSM_DONE;	/* processing is over */
			err = E_IAP_AUTH;
			DBG_REPORT_ERROR(err);
		}
		else
		{
			pIap->FsmState = IAP_FSM_IDLE;
			M_CLEAR_FLAG(pIap->bAuth);	/* authentication is done */
			//err = IAP_AUTH_DONE;	//QQQQQQQQQQQQQQQQQ
		}
		break;
	}
	case IAP_GEN_GET_ACC_INFO:	/*0x27*/
	{
		err = IAP_ProcessTxRequest(pIap, IAP_LINGO_GENERAL, IAP_GEN_RET_ACC_INFO, NULL, pRxItem->pData);
		if(err == IAP_OK)
		{
			pIap->FsmState = IAP_FSM_TX;
			M_SET_FLAG(pIap->bAgain);	/* continue processing */
		}
		else
		{
			DBG_REPORT_ERROR(err);
		}
		break;
	}
	
	default:
		//TBD
		pIap->FsmState = IAP_FSM_IDLE;	/* for all not yet iplemented commands */
		break;
	}

	return err;
}

t_player_state IAP_DecodeRxExt(tIap* pIap, tIapItem* pRxItem)
{	//TBD
	t_player_state err = IAP_OK;
	tIapReq* pIapMsg = (tIapReq*)&(pIap->Msg);

	pIap->FsmState = IAP_FSM_IDLE;

	switch(pRxItem->Code.CmdId)
	{
	case IAP_EXT_ACK:
	{
		tIapExtCmd0x01iData* pIapExtCmd0x01iData = (tIapExtCmd0x01iData*)(pRxItem->pData);
		uint16 CmdAck = SWAP16_FROM(&(pIapExtCmd0x01iData->CmdAck));
		switch(CmdAck)
		{
		case IAP_EXT_RET_COLORDISP_IMG_LIM:
		case IAP_EXT_RET_MONO_DISP_IMG_LIM:
			//TBD - which are remote messages?
			memcpy(pIapMsg, pRxItem, sizeof(tIapItem));
			err = IAP_MSG_REMOTE;
			break;

		default:	//TBD (for now report everything)
			//pIapMsg->pData = pRxItem->pData;
			//pIapMsg->Code.LingoId = pRxItem->Code.LingoId;
			//pIapMsg->Code.CmdId = pRxItem->Code.CmdId;
			//pIapMsg->RemainLen = pIapMsg->ChunkLen = pRxItem->RemainLen;
			//M_SET_FLAG(pIapMsg->bFirstChunk);
			memcpy(pIapMsg, pRxItem, sizeof(tIapItem));	//TBD
			if(pIapExtCmd0x01iData->result == IAP_ACK)
				err = IAP_MSG;	//TBD
			else
				err = E_IAP_MSG;	//TBD
			break;
		}
		break;
	}
	case IAP_EXT_RET_COLORDISP_IMG_LIM:
	case IAP_EXT_RET_MONO_DISP_IMG_LIM:
		memcpy(pIapMsg, pRxItem, sizeof(tIapItem));
		err = IAP_MSG_REMOTE;
		break;

	default:	//TBD (for now report everything)
		//pIapMsg->pData = pRxItem->pData;
		//pIapMsg->Code.LingoId = pRxItem->Code.LingoId;
		//pIapMsg->Code.CmdId = pRxItem->Code.CmdId;
		//pIapMsg->RemainLen = pIapMsg->ChunkLen = pRxItem->RemainLen;
		//M_SET_FLAG(pIapMsg->bFirstChunk);
		memcpy(pIapMsg, pRxItem, sizeof(tIapItem));	//TBD
		err = IAP_MSG;	//TBD
		break;
	}
	return err;
}

t_player_state IAP_DecodeRxAud(tIap* pIap, tIapItem* pRxItem)
{
	/* TBD */
}

t_player_state IAP_DecodeAcp(tIap* pIap, tIapAcp* pIapAcp)
{
	t_player_state err = IAP_OK;

	if (pIapAcp->pSignature)	/* only signature is valid data */
	{
		pIap->FsmState = IAP_FSM_IDLE;	//new
		err = IAP_ProcessTxRequest(pIap, IAP_LINGO_GENERAL, IAP_GEN_RET_DEV_AUTH_SIGN, NULL, NULL);	//TBD
	}
	else /* Cmd not signature */
	{
		pIap->FsmState = IAP_FSM_DONE;
#ifdef _IAP_DEBUG
		DBG_PRINTF("iap: *E - FATAL:wrong CP command in IAP_FSM_ACP\r\n");
#endif
		err = E_IAP_AUTH;
	}

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

//static tIapCmdCode gCmdCode;
t_player_state IAP_DecodeCmd(tIap* pIap, tIapReq* pIapReq) //TBD
{
	/* TBD */
	t_player_state err = IAP_OK;
	tIapItem* pCmd = &(pIapReq->Item);
	tIapCmdCode CmdCode = pCmd->Code;

	pIap->FsmState = IAP_FSM_TX;	/* preset to send cmd to iPod */

	switch(CmdCode.LingoId)
	{
	case IAP_LINGO_GENERAL:
//		err = IAP_DecodeCmdGen(pIap, pCmd);
//		break;

	case IAP_LINGO_EXT_INTERF:
//		err = IAP_DecodeCmdExt(pIap, pCmd);
//		break;

	case IAP_LINGO_DIG_AUDIO:
//		err = IAP_DecodeCmdAud(pIap, pCmd);
		err = IAP_ProcessTxRequest(pIap, (teIapLingoId)C_IAP_LINGO_NO, C_IAP_CMD_PASS, pCmd, NULL