ad9380.c

1. 8623L平台

	if(0) cap_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 cap_AD9380_read_avi_infoframe(struct cap_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);
	cap_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0x81, pData+1);
	cap_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0x82, pData+2);	
	cap_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0x83, pData+3);	
	cap_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0x84, pData+4);
	cap_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0x85, pData+5);

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

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

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

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

	return RM_OK;
}

static RMstatus cap_AD9380_read_spd_infoframe(struct cap_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]
		cap_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]
		cap_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]
		cap_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]
		cap_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0xb0+i, pData+21+i);		
	}	
	
	return RM_OK;

}

static RMstatus cap_AD9380_read_audio_infoframe(struct cap_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]
		cap_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0x91+i, pData+1+i);		
	}

	return RM_OK;
}

static RMstatus cap_AD9380_read_mpeg_infoframe(struct cap_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]
		cap_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0xb9+i, pData+1+i);		
	}

	return RM_OK;

}

static RMstatus cap_AD9380_read_acp_infoframe(struct cap_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
	cap_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]
		cap_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0xc1+i, pData+1+i);		
	}

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

	return RM_OK;

}

static RMstatus cap_AD9380_read_isrc1_infoframe(struct cap_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
	cap_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]
		cap_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0xc9+i, pData+i);		
	}
	for(i=0; i<7; i++){
		// 0xd0 - 0xd6  : data[6] - data[12]
		cap_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0xd0+i, pData+i);		
	}
	for(i=0; i<4; i++){
		// 0xd8 - 0xdb  : data[13] - data[16]
		cap_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0xc1+i, pData+i);		
	}
	return RM_OK;

}

static RMstatus cap_AD9380_read_isrc2_infoframe(struct cap_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]
		cap_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0xdc+i, pData+i);		
	}
	for(i=0; i<7; i++){
		// 0xe0 - 0xe6  : data[3] - data[9]
		cap_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0xe0+i, pData+i);		
	}
	for(i=0; i<7; i++){
		// 0xe8 - 0xee  : data[10] - data[16]
		cap_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0xe8+i, pData+i);		
	}
	return RM_OK;

}

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

	switch (type) {
	case 0x04:  // Audio CP
		cap_AD9380_read_acp_infoframe(pAD9380, header, data, size);	
		break;
	case 0x05:  // ISRC1
		cap_AD9380_read_isrc1_infoframe(pAD9380, header, data, size);
		break;
	case 0x06:  // ISRC2
		cap_AD9380_read_isrc2_infoframe(pAD9380, header, data, size);
		break;
	case 0x0A:  // Gamut Metadata
		//cap_AD9380_read_avi_infoframe(pAD9380, header, data, size);
		break;
	case 0x81:  // Vendor Specific
		//cap_AD9380_read_avi_infoframe(pAD9380, header, data, size);
		break;
	case 0x83:  // SPD
		cap_AD9380_read_spd_infoframe(pAD9380, header, data, size);
		break;
	case 0x82:  // AVI
		cap_AD9380_read_avi_infoframe(pAD9380, header, data, size);
		/*
		{
			RMuint32 i = 0;
			for(i=0; i< size; i++){
				RMDBGLOG((LOCALDBG, " data[%ld] : 0x%x\n", i, data[i]));
			}
		}
		*/
		break;
	case 0x84:  // Audio
		cap_AD9380_read_audio_infoframe(pAD9380, header, data, size);
		break;
	case 0x85:  // MPEG
		cap_AD9380_read_mpeg_infoframe(pAD9380, header, data, size);
		break;
	}
	

	return RM_OK;


}

/*
 * Analog Video Functions
*/

 // have to expand api to add input type and input port number
RMstatus cap_AD9380_init_analog_capture(struct cap_AD9380_instance *pAD9380,
					RMuint32 input)
{


	/*
	 * Input Port Setting
	 */
	RMuint8 AD9380_RGB_I2CDATA[][2] = {
		//	{ 0x5 , 0x80 },
		//	{ 0x6 , 0x80 },
		//	{ 0x7 , 0x80 },
		
		{ 0x5 , 0x80 },
		{ 0x6 , 0x45 },
		{ 0x7 , 0x80 },
		
		{ 0x8 , 0x0 },
		{ 0x9 , 0x80 },
		{ 0xa , 0x0 },
		{ 0xb , 0x08 },
		{ 0xc , 0x0 },
		{ 0xd , 0x80 },	
	};
	RMDBGLOG((FUNCNAME, "%s\n",__func__));

	// Input Port Setting
	if(1) cap_i2c_write_dev(pAD9380, pAD9380->BaseDevice, 0x11, 0x00); //interface select - digital interface
#if 1	
 	switch (input) {
	case cap_video_input_component:
		// YUV input set up
		//cap_i2c_write_dev(pAD9380, pAD9380->BaseDevice, 0x11, 0xfd);
		cap_i2c_init(pAD9380, pAD9380->BaseDevice, AD9380_RGB_I2CDATA);
		break;
	case cap_video_input_vga:
		// VGA input set up
		cap_i2c_write_dev(pAD9380, pAD9380->BaseDevice, 0x11, 0x55);
		cap_i2c_init(pAD9380, pAD9380->BaseDevice, AD9380_RGB_I2CDATA);
		break; 
	default:
		// defualt to YUV 
		cap_i2c_write_dev(pAD9380, pAD9380->BaseDevice, 0x11, 0xfd);
		break;
	}
#endif

	return RM_OK;
}

#if 0
RMstatus cap_AD9380_setup_audio_mclk(struct cap_AD9380_instance *pAD9380)
{
	
	RMDBGLOG((FUNCNAME, "%s\n",__func__));

	return RM_OK;

}

RMstatus cap_AD9380_setup_output(struct cap_AD9380_instance *pAD9380, 
				 struct cap_update *pUpdate)
{

	if (pUpdate->VideoOff == TRUE) {
		return RM_ERROR;
	}

	if (pUpdate->TVStandardValid && pUpdate->TVStandardUpdate) {
		RMbool isNTSC;
		IsNTSC(pUpdate->TVStandard, isNTSC);
		if (isNTSC) {
			/*
			 * when NTSC
			 * 0x07
			 * 0x08
			 * 0x09
			 * 0x0b
			 */
		
		}else{
			/*
			 * PAL
			 */
		
		}
	}
	
	if (pUpdate->TVFormatValid && pUpdate->TVFormatUpdate) {
		
	}

	if (pUpdate->PictureAspectRatioValid && pUpdate->PictureAspectRatioUpdate) {

	}

	if (pUpdate->InputColorSpaceValid && pUpdate->InputColorSpaceUpdate) {

	}

	if (pUpdate->InputColorFormatValid && pUpdate->InputColorFormatUpdate) {
		if(pUpdate->InputColorFormat == 1){

		}
	}
	return RM_OK;
}
#endif

#if 1
static RMstatus IsSyncDetected(struct cap_AD9380_instance *pAD9380)
{
	RMuint8 reg = 0;

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

	cap_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0x15, &reg);
	
	//RMDBGLOG((LOCALDBG, "%d\n", reg));

	if(reg & 0x80){
		RMDBGLOG((LOCALDBG, "HSYNC0 detected\n"));
	}

	if(reg & 0x40){
		RMDBGLOG((LOCALDBG, "HSYNC1 detected\n"));
	}

	if(reg & 0x20){
		RMDBGLOG((LOCALDBG, "VSYNC0 detected\n"));
	}

	if(reg & 0x10){
		RMDBGLOG((LOCALDBG, "VSYNC1 detected\n"));
	}

	if(reg & 0x8){
		RMDBGLOG((LOCALDBG, "SOG0 detected\n"));
	}

	if(reg & 0x4){
		RMDBGLOG((LOCALDBG, "SOG1 detected\n"));
	}

	if(reg & 0x2){
		RMDBGLOG((LOCALDBG, "Coast detected\n"));
	}
	
	return RM_OK;
		
}

static RMstatus IsSyncFilterLocked(struct cap_AD9380_instance *pAD9380)
{
	RMuint8 reg = 0;

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

	cap_i2c_read_dev(pAD9380, pAD9380->BaseDevice, 0x16, &reg);
	
	//RMDBGLOG((LOCALDBG, "%d\n", reg));

	if(reg & 0x2){
		RMDBGLOG((LOCALDBG, "Sync Filter Locked\n"));
	}

	if(reg & 0x1){
		RMDBGLOG((LOCALDBG, "Bad Sync Detected\n"));
	}	
	
	return RM_OK;
}

RMstatus cap_AD9380_analog_check_int(struct cap_AD9380_instance *pAD9380)
{
	/*
	 AD9380 is not interrupt driven
	 This will be polled by main_loop
	*/

	IsSyncDetected(pAD9380);
	IsSyncFilterLocked(pAD9380);
	return RM_OK;
}

RMstatus cap_AD9380_analog_handle_int(struct cap_AD9380_instance *pAD9380, 
				      struct cap_update *pUpdate)
{

	return RM_OK;
}

#endif