play_capture_ad9380.c

1. 8623L平台

	RMDBGLOG((FUNCNAME, "%s\n",__func__));
	return RM_OK;
}

/* get current audio channel status from AD9380 */
RMstatus capsam_AD9380_get_audio_channel_status(struct capsam_AD9380_instance *pAD9380, 
					     RMuint8 ch_stat[5])
{
	RMuint8 reg_0x5f, reg_0x60, reg_0x61;
	
	RMDBGLOG((FUNCNAME, "%s\n",__func__));

	capsam_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0x5f, &reg_0x5f); 
	capsam_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0x60, &reg_0x60); 
	capsam_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0x61, &reg_0x61); 

	printf("audio channel status code 0x%x\n", reg_0x5f);
	printf("audio channel number 0x%x\n", reg_0x60);
	printf("audio channel accuracy & freqency code 0x%x\n", reg_0x61);

	return RM_OK;
}

/* get current audio clock divider values N/CTS from AD9380 */
RMstatus capsam_AD9380_get_audio_n_cts(struct capsam_AD9380_instance *pAD9380, 
				     RMuint32 *pN, 
				     RMuint32 *pCTS, 
				     RMuint32 *pApproxSamplingRate)
{
	RMDBGLOG((FUNCNAME, "%s\n",__func__));
	return RM_OK;
}


RMstatus capsam_AD9380_detect_mode(struct capsam_AD9380_instance *pAD9380, 
				enum capsam_hdmi_mode *pHDMIMode)
{
	RMuint8 reg_0x5b = 0;
	
	RMDBGLOG((FUNCNAME, "%s\n",__func__));
	capsam_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0x5b, &reg_0x5b); 
	*pHDMIMode = ((reg_0x5b & 0x8) ? capsam_hdmi_mode_HDMI : capsam_hdmi_mode_DVI);

	return RM_OK;
}

RMstatus capsam_AD9380_set_mode(struct capsam_AD9380_instance *pAD9380, 
			     enum capsam_hdmi_mode hdmi_mode)
{
	RMDBGLOG((FUNCNAME, "%s\n",__func__));
	return RM_OK;
}


static RMstatus capsam_AD9380_is_packet_detected_since_reset(struct capsam_AD9380_instance *pAD9380,
							  RMuint8 *pPacket)
{
	RMuint8 reg_0x5a;
	
	//RMDBGLOG((FUNCNAME, "%s\n",__func__));

	capsam_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0x5a, &reg_0x5a); 

	if(reg_0x5a && pAD9380->FirstPacketSinceReset){
		printf("packet since last reset 0x%x \n", reg_0x5a);
		*pPacket = reg_0x5a;
		pAD9380->FirstPacketSinceReset = FALSE;
	}

	return RM_OK;
}

static RMstatus capsam_AD9380_is_packet_detected(struct capsam_AD9380_instance *pAD9380,
					      RMuint8 *pPacket)
{
	//RMDBGLOG((FUNCNAME, "%s\n",__func__));

	capsam_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0x87, pPacket); 
	if(*pPacket){
		printf("*********packet********* 0x%x \n", *pPacket);
	}
	return RM_OK;
}


/* Returns RM_OK if an interrupt is pending on the AD9380 */
RMstatus capsam_AD9380_check_int(struct capsam_AD9380_instance *pAD9380)
{
	RMuint8 packet = 0;
	//RMDBGLOG((FUNCNAME, "%s\n",__func__));
	

	
	capsam_AD9380_is_packet_detected_since_reset(pAD9380, &packet);
	if(0) capsam_AD9380_is_packet_detected(pAD9380, &packet);
	

	pAD9380->AVI_InfoFrameDetected = ((packet & 0x1) == 0x1);
	pAD9380->Audio_InfoFrameDetected = ((packet & 0x2) == 0x2);
	pAD9380->SPD_InfoFrameDetected = ((packet & 0x4) == 0x4);
	pAD9380->MPEG_InfoFrameDetected = ((packet & 0x8) == 0x8);
	pAD9380->ACP_InfoFrameDetected = ((packet & 0x10) == 0x10); 
	pAD9380->ISRC1_InfoFrameDetected = ((packet & 0x20) == 0x20);
	pAD9380->ISRC2_InfoFrameDetected = ((packet & 0x40) == 0x40);



	if(packet != 0){
		printf("packet 0x%x \n", packet);
		return RM_OK;
	}else{
		return RM_ERROR;
	}
}

RMstatus capsam_AD9380_handle_int(struct capsam_AD9380_instance *pAD9380, 
			       struct capsam_update *pUpdate, 
			       struct capsam_hdmi_update *pHDMIUpdate)
{
	RMDBGLOG((FUNCNAME, "%s\n",__func__));

	if(0) capsam_AD9380_detect_TMDS_sync(pAD9380);
	if(0) capsam_AD9380_detect_sync(pAD9380);

	pHDMIUpdate->AVIInfoFrameUpdate = pAD9380->AVI_InfoFrameDetected;
	pHDMIUpdate->AudioInfoFrameUpdate = pAD9380->Audio_InfoFrameDetected;
	pHDMIUpdate->SPDInfoFrameUpdate = pAD9380->SPD_InfoFrameDetected;
	pHDMIUpdate->MPEGInfoFrameUpdate = pAD9380->MPEG_InfoFrameDetected;
	pHDMIUpdate->AudioCPPacketUpdate = pAD9380->ACP_InfoFrameDetected;
	pHDMIUpdate->ISRC1PacketUpdate = pAD9380->ISRC1_InfoFrameDetected;
	pHDMIUpdate->ISRC2PacketUpdate = pAD9380->ISRC2_InfoFrameDetected;

	pAD9380->AVI_InfoFrameDetected = FALSE;
	pAD9380->Audio_InfoFrameDetected = FALSE;
	pAD9380->SPD_InfoFrameDetected = FALSE;
	pAD9380->MPEG_InfoFrameDetected = FALSE;
	pAD9380->ACP_InfoFrameDetected = FALSE;
	pAD9380->ISRC1_InfoFrameDetected = FALSE;
	pAD9380->ISRC2_InfoFrameDetected = FALSE;

	return RM_OK;
}

static RMstatus capsam_AD9380_read_avi_infoframe(struct capsam_AD9380_instance *pAD9380,RMuint8 *pHeader,  RMuint8 *pData, RMuint32 size )
{

	RMDBGLOG((FUNCNAME, "%s\n",__func__));

	if( (pData == NULL) || (size < 14) ){ // TODO define macro for size 14
		return RM_ERROR;
	}

	RMMemset(pData, 0x0, size);
	capsam_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0x81, pData+1);
	capsam_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0x82, pData+2);	
	capsam_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0x83, pData+3);	
	capsam_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0x84, pData+4);
	capsam_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0x85, pData+5);

	capsam_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0x86, pData+6); // active line start LSB
	capsam_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0x88, pData+7); // active line start MSB

	capsam_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0x89, pData+8); // active line end LSB
	capsam_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0x8a, pData+9); // active line end MSB

	capsam_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0x86, pData+10); // active pixel start LSB
	capsam_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0x88, pData+11); // active pixel start MSB

	capsam_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0x86, pData+12); // active pixel end LSB
	capsam_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0x88, pData+13); // active pixel end MSB

	return RM_OK;
}

static RMstatus capsam_AD9380_read_spd_infoframe(struct capsam_AD9380_instance *pAD9380,RMuint8 *pHeader, RMuint8 *pData, RMuint32 size )
{
	RMuint32 i = 0;
	
	RMDBGLOG((FUNCNAME, "%s\n",__func__));

	if( (pData == NULL) || (size < 26) ){ // TODO define macro for size 
		return RM_ERROR;
	}

	RMMemset(pData, 0x0, size);
	for(i=0; i<6; i++){
		// 0x99 - 0x9e (VN1 - VN6) : data[1] - data[6]
		capsam_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0x99+i, pData+1+i);		
	}

	for(i=0; i<7; i++){
		// 0xa0 - 0xa6 (VN7 - PD5) : data[7] - data[13]
		capsam_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0xa0+i, pData+7+i);		
	}

	for(i=0; i<7; i++){
		// 0xa8 - 0xae (PD6 - PD12) : data[14] - data[20]
		capsam_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0xa8+i, pData+14+i);		
	}

	for(i=0; i<5; i++){
		// 0xb0 - 0xb4 (PD13 - SDI) : data[21] - data[25]
		capsam_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0xb0+i, pData+21+i);		
	}	
	
	return RM_OK;

}

static RMstatus capsam_AD9380_read_audio_infoframe(struct capsam_AD9380_instance *pAD9380, RMuint8 *pHeader, RMuint8 *pData, RMuint32 size )
{
	RMuint32 i = 0;
	
	RMDBGLOG((FUNCNAME, "%s\n",__func__));

	if( (pData == NULL) || (size < 6) ){ // TODO define macro for size 
		return RM_ERROR;
	}

	RMMemset(pData, 0x0, size);
	for(i=0; i<5; i++){
		// 0x91 - 0x95  : data[1] - data[5]
		capsam_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0x91+i, pData+1+i);		
	}

	return RM_OK;
}

static RMstatus capsam_AD9380_read_mpeg_infoframe(struct capsam_AD9380_instance *pAD9380,RMuint8 *pHeader, RMuint8 *pData, RMuint32 size )
{
	RMuint32 i = 0;
	
	RMDBGLOG((FUNCNAME, "%s\n",__func__));

	if( (pData == NULL) || (size < 6) ){ // TODO define macro for size 
		return RM_ERROR;
	}

	RMMemset(pData, 0x0, size);
	for(i=0; i<5; i++){
		// 0xb9 - 0xbd  : data[1] - data[5]
		capsam_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0xb9+i, pData+1+i);		
	}

	return RM_OK;

}

static RMstatus capsam_AD9380_read_acp_infoframe(struct capsam_AD9380_instance *pAD9380, RMuint8 *pHeader, RMuint8 *pData, RMuint32 size )
{
	RMuint32 i = 0;
	
	RMDBGLOG((FUNCNAME, "%s\n",__func__));

	if( (pHeader == NULL) || (pData == NULL) || (size < 6) ){ // TODO define macro for size 
		return RM_ERROR;
	}

	RMMemset(pHeader, 0x0, 3); // TODO headersize macro

	// only header[1] is meaningfull
	capsam_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0xc0, pHeader+1);		


	RMMemset(pData, 0x0, size);
	for(i=0; i<6; i++){
		// 0xc1 - 0xc7  : data[1] - data[6]
		capsam_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0xc1+i, pData+1+i);		
	}

	RMDBGLOG((FUNCNAME, "%s return OK !\n",__func__));

	return RM_OK;

}

static RMstatus capsam_AD9380_read_isrc1_infoframe(struct capsam_AD9380_instance *pAD9380, RMuint8 *pHeader, RMuint8 *pData, RMuint32 size )
{
	RMuint32 i = 0;
	
	RMDBGLOG((FUNCNAME, "%s\n",__func__));

	if( (pHeader == NULL) || (pData == NULL) || (size < 20) ){ // TODO define macro for size 
		return RM_ERROR;
	}

	RMMemset(pHeader, 0x0, 3); // TODO headersize macro

	// only header[1] is meaningfull
	capsam_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0xc8, pHeader+1);		

	RMMemset(pData, 0x0, size);

	// be careful! play_capture_hdmi will treat data from data[0] 
	for(i=0; i<6; i++){
		// 0xc9 - 0xce  : data[0] - data[5]
		capsam_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0xc9+i, pData+i);		
	}
	for(i=0; i<7; i++){
		// 0xd0 - 0xd6  : data[6] - data[12]
		capsam_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0xd0+i, pData+i);		
	}
	for(i=0; i<4; i++){
		// 0xd8 - 0xdb  : data[13] - data[16]
		capsam_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0xc1+i, pData+i);		
	}
	return RM_OK;

}

static RMstatus capsam_AD9380_read_isrc2_infoframe(struct capsam_AD9380_instance *pAD9380, RMuint8 *pHeader, RMuint8 *pData, RMuint32 size )
{
	RMuint32 i = 0;
	
	RMDBGLOG((FUNCNAME, "%s\n",__func__));

	if( (pHeader == NULL) || (pData == NULL) || (size < 20) ){ // TODO define macro for size 
		return RM_ERROR;
	}

	RMMemset(pData, 0x0, size);

	// be careful! play_capture_hdmi will treat data from data[0] 
	for(i=0; i<3; i++){
		// 0xdc - 0xce  : data[0] - data[2]
		capsam_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0xdc+i, pData+i);		
	}
	for(i=0; i<7; i++){
		// 0xe0 - 0xe6  : data[3] - data[9]
		capsam_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0xe0+i, pData+i);		
	}
	for(i=0; i<7; i++){
		// 0xe8 - 0xee  : data[10] - data[16]
		capsam_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0xe8+i, pData+i);		
	}
	return RM_OK;

}

RMstatus capsam_AD9380_read_info_frame(struct capsam_AD9380_instance *pAD9380, 
				    RMuint8 type, 
				    RMuint8 *header, 
				    RMuint8 *data, 
				    RMuint32 size)
{
	
	RMDBGLOG((FUNCNAME, "%s\n",__func__));

	switch (type) {
	case 0x04:  // Audio CP
		capsam_AD9380_read_acp_infoframe(pAD9380, header, data, size);	
		break;
	case 0x05:  // ISRC1
		capsam_AD9380_read_isrc1_infoframe(pAD9380, header, data, size);
		break;
	case 0x06:  // ISRC2
		capsam_AD9380_read_isrc2_infoframe(pAD9380, header, data, size);
		break;
	case 0x0A:  // Gamut Metadata
		//capsam_AD9380_read_avi_infoframe(pAD9380, header, data, size);
		break;
	case 0x81:  // Vendor Specific
		//capsam_AD9380_read_avi_infoframe(pAD9380, header, data, size);
		break;
	case 0x83:  // SPD
		capsam_AD9380_read_spd_infoframe(pAD9380, header, data, size);
		break;
	case 0x82:  // AVI
		capsam_AD9380_read_avi_infoframe(pAD9380, header, data, size);
		/*
		{
			RMuint32 i = 0;
			for(i=0; i< size; i++){
				printf(" data[%ld] : 0x%x\n", i, data[i]);
			}
		}
		*/
		break;
	case 0x84:  // Audio
		capsam_AD9380_read_audio_infoframe(pAD9380, header, data, size);
		break;
	case 0x85:  // MPEG
		capsam_AD9380_read_mpeg_infoframe(pAD9380, header, data, size);
		break;
	}
	

	return RM_OK;


}