acp.c

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

/*************************** ACP TASK FUNCTIONS ****************************/
/* Command */
/******************************************************************************/
/* Function:  get_acp_cmd_event_data                                          */
/*                                                                            */
/*! \brief    ACP_CMD_EVENT data
*             
*  \param    
*  \return    pointer to the acp command event
*  \remark
*******************************************************************************/
t_acp_cmd_event acp_cmd_event[EVENT_MAX_STAGES];
void* get_acp_cmd_event_data(t_event_stage i)
{
  return (void*)&acp_cmd_event[i];
}

/******************************************************************************/
/* Function:  acp_command                                                     */
/*                                                                            */
/*! \brief    PLAYER task sends command to the ACP task
*             
*  \param     t_acp_cmd_event* acp_cmd
*  \return
*  \remark
*******************************************************************************/
void acp_command(t_acp_cmd_event* acp_cmd)
{
  t_acp_cmd_event* pout_event;
  
  pout_event = (t_acp_cmd_event *)pevent_get_out(ACP_CMD_EVENT);
  *pout_event = *acp_cmd;
  event_set_out(ACP_CMD_EVENT);     //priority dependent (semaphore signal immediatelly)
  event_out_shedule(ACP_CMD_EVENT);
  //event_cmd_set(ACP_CMD_EVENT);       //independent from priorities
}

/* Status */
/******************************************************************************/
/* Function:  get_acp_status_event_data                                       */
/*                                                                            */
/*! \brief    ACP_STATUS_EVENT data
*             
*  \param    
*  \return    pointer to the acp status event
*  \remark
*******************************************************************************/
t_acp_status_event acp_status_event[EVENT_MAX_STAGES];
void * get_acp_status_event_data(t_event_stage i)
{
  return (void *)&acp_status_event[i];
}

/******************************************************************************/
/* Function:  acp_status                                                      */
/*                                                                            */
/*! \brief    ACP task sends status to the PLAYER task
*             
*  \param     t_acp_status_event* acp_stat
*  \return
*  \remark
*******************************************************************************/
void acp_status(t_acp_status_event* acp_stat)
{
  t_acp_status_event *pout_event;
  
  pout_event = (t_acp_status_event *)pevent_get_out(ACP_STATUS_EVENT);
  *pout_event = *acp_stat;
  event_set_out(ACP_STATUS_EVENT);     //priority dependent (semaphore signal immediatelly)
  event_out_shedule(ACP_STATUS_EVENT);
  //event_cmd_set(ACP_STATUS_EVENT);       //independent from priorities
}

/******************************************************************************/
/* Function:  ACPTask                                                         */
/*                                                                            */
/*! \brief    own ACP Task
*  \param
*  \return
*  \remark    no Authentication Coprocessor communication yet
*******************************************************************************/
void ACPTask(void *unused)
{
	//TBD
	//t_acp_state status;

	//TBD
	//status = ACP_Init();

	//if (status == ACP_OK)
	{
		while (1)
		{
			OSAL_wait_thread(OSAL_THREAD_ACPTask);
			/* in scheduling */
			event_disable_scheduling();
			event_in_shedule(ACP_CMD_EVENT);
			event_enable_scheduling();

			acp_handler();

			/* out scheduling */
			event_disable_scheduling();
			event_in_clear(ACP_CMD_EVENT);
//			event_out_shedule(ACP_STATUS_EVENT);
			event_enable_scheduling();      
		}
	}
	//else
	//{
	//	DBG_PRINTF("usb: *E - USB_Init() failed\r\n");		
	//}
}

/******************************************************************************/
/* Function:  acp_handler                                                     */
/*                                                                            */
/*! \brief    acp task handler
*             
*  \param
*  \return
*  \remark    simulation of the Authentication Coprocessor
*******************************************************************************/
void acp_handler(void)
{
	t_acp_cmd_event acp_cmd;
	t_acp_status_event acp_stat;

	//TBD
	acp_stat.pData = gAcpBuffer;
	if (EVENT_ACP_IS_CMD)
	{
		tAcpInitInfo* pInitInfo = (tAcpInitInfo*)(acp_stat.pData);
		tAcpCertPageStatusData* pPageData = (tAcpCertPageStatusData*)(acp_stat.pData);
		acp_cmd = EVENT_ACP_CMD;
		switch(acp_cmd.Cmd)
		{
		case ACP_CMD_INIT:	/* 0 */
			acp_stat.Error = ACP_OK;
			acp_stat.ReplyStatusTo = acp_cmd.Cmd;
			pInitInfo->pBuffer = gAcpBuffer;
			pInitInfo->BufferLength = sizeof(gAcpBuffer);
			gAcpPageNumIndex = 0;
			acp_status(&acp_stat);
			break;

		case ACP_CMD_GET_INFO:		/* 1 */
			acp_stat.Error = ACP_OK;
			acp_stat.ReplyStatusTo = acp_cmd.Cmd;
			memcpy(acp_stat.pData, M_ACP_INFO, sizeof(M_ACP_INFO));
			//acp_stat.pData = M_ACP_INFO;
			acp_status(&acp_stat);
			break;

		case ACP_CMD_GET_PAGE:		/* 2 */
			acp_stat.Error = ACP_OK;
			acp_stat.ReplyStatusTo = acp_cmd.Cmd;
			//switch((tAcpPageCmdData)*(acp_cmd.pData))
			switch(gAcpPageNumIndex++)
			{
			case 0:
				pPageData->PageNum = 0;
				pPageData->PageLen = 128;
				memcpy(&(pPageData->PageData), Page81, sizeof(Page81));
				break;

			case 1:
				pPageData->PageNum = 1;
				pPageData->PageLen = 128;
				memcpy(&(pPageData->PageData), Page82, sizeof(Page82));
				break;

			case 2:
				pPageData->PageNum = 2;
				pPageData->PageLen = 128;
				memcpy(&(pPageData->PageData), Page83, sizeof(Page83));
				break;

			case 3:
				pPageData->PageNum = 3;
				pPageData->PageLen = 128;
				memcpy(&(pPageData->PageData), Page84, sizeof(Page84));
				break;

			case 4:
				pPageData->PageNum = 4;
				pPageData->PageLen = 128;
				memcpy(&(pPageData->PageData), Page85, sizeof(Page85));
				break;

			case 5:
				pPageData->PageNum = 5;
				pPageData->PageLen = 128;
				memcpy(&(pPageData->PageData), Page86, sizeof(Page86));
				break;

			case 6:
				pPageData->PageNum = 6;
				pPageData->PageLen = 128;
				memcpy(&(pPageData->PageData), Page87, sizeof(Page87));
				break;

			case 7:
				pPageData->PageNum = 7;
				pPageData->PageLen = 49;
				memcpy(&(pPageData->PageData), Page88, sizeof(Page88));
				gAcpPageNumIndex = 0;
				break;

			default:
				acp_stat.Error = E_ACP;
				gAcpPageNumIndex = 0;
				break;
			}
			acp_status(&acp_stat);
			break;

		case ACP_CMD_GET_SIGNATURE:	/* 3 */
			acp_stat.Error = E_ACP;
			acp_stat.ReplyStatusTo = acp_cmd.Cmd;
			//acp_status(&acp_stat);	//TBD - DO not FORGET to enable!
			break;

		default:
			DBG_PRINTF("acp: *E - handler: unknown cmd\r\n");
			break;
		}
	}
}

#endif /*IPOD_AP*/