ad9380.c

SigmDesign SMP8634 media decode chip development SDK

				}	
				switch(regValue) {
				case 0:
					*yuvId=ad9380_yuv_480i;
					break;
				case 0xd4:
					*yuvId=ad9380_yuv_576i;
					break;
				default:
					*yuvId=ad9380_invalid_standard;
					fprintf(stderr, "0x08 -0x01- 0x07 - 0x%lx\n",regValue);
					//err=RM_ERROR;
				}
				break;
			default:
				*yuvId=ad9380_invalid_standard;
//				fprintf(stderr, "0x08 - 0x01 - 0x%lx\n",regValue);
				//err=RM_ERROR;
			}
			break;
		case 0x02:
			regAdd=0x18;
			err = read_i2c(pInstance, delay, dev, regAdd, &regValue);
			if (RMFAILED(err)) {
				fprintf(stderr, "Failed to read reg 0x%lx\n",regAdd);
				return err;
			}
			switch(regValue) {
			case 0x0d:
				*yuvId=ad9380_yuv_576p;
				break;
			case 0x32:
				*yuvId=ad9380_yuv_1080i25;
				break;
			default:
				*yuvId=ad9380_invalid_standard;
//				fprintf(stderr, "0x08 - 0x02 - 0x%lx\n",regValue);
				//err=RM_ERROR;
			}
			break;
		case 0x04:
			*yuvId=ad9380_yuv_1080p60;
			break;
		default:
			fprintf(stderr, "0x08 - 0x%lx\n",regValue);
		}
		break;
	default:
		*yuvId=ad9380_invalid_standard;
//		fprintf(stderr, "0x15=0x%lx\n",regValue);
		//err=RM_ERROR;
		break;
	}
	}
	return err;
}
#endif

static RMstatus ad9380_setCaptureStandard(
	struct RUA *pInstance, 
	RMuint8 dev, 
	RMuint8 delay,
	enum EMhwlibTVStandard TVStandard)
{
	RMstatus err;
	RMuint8 range, current;
	struct EMhwlibTVFormatDigital fmt;
	RMuint32 vcogain, postdiv, plldiv, bp;
	RMreal c;
	
	// Analog Devices 9883 setup
	RMuint8 i2c_data[][2] = {
		{0x01, 0x69},  // PLL Div MSB //1 - 1
		{0x02, 0xD0},  // PLL Div LSB //2 - 2
		{0x03, 0x48},  // VCO		  //3 - 3
		{0x04, 0x80},  // Phase adj.  //4 - 4
	};
	
	err = RUAExchangeProperty(pInstance, DisplayBlock, 
		RMDisplayBlockPropertyID_TVFormatDigital, 
		&(TVStandard), sizeof(TVStandard), 
		&fmt, sizeof(fmt));
	if (RMFAILED(err)) fprintf(stderr, "Failed to get TV format, %s\n", RMstatusToString(err));
	
	vcogain = 150;
	postdiv = 1;
	if (fmt.PixelClock < 32000000) {
		range = 0;
		postdiv = 4;
	} else if (fmt.PixelClock < 64000000) {
		range = 1;
		postdiv = 2;
	} else if (fmt.PixelClock < 125000000) {
		range = 2;
	} else {
		range = 3;
		vcogain = 180;
	}
	plldiv = fmt.HTotalSize;
	
	// Formula from AD's Excel sheet 249461068RevAD9883_PLL.xls:
	// c=((HFreq*6.28/((PixClk<32000000)?12.5:15))^2*((0.082*0.000001*plldiv*postdiv)/(vcogain*1000000))*1000000
	c = fmt.PixelClock;
	c *= 6.28 / fmt.HTotalSize;
	c /= ((fmt.PixelClock < 32000000) ? 12.5 : 15.0);
	c *= c;
	c *= (0.082 * plldiv * postdiv) / (vcogain * 1000000.0);
	current = 
		(c <   75.0) ? 0 : 
		(c <  125.0) ? 1 : 
		(c <  200.0) ? 2 : 
		(c <  300.0) ? 3 : 
		(c <  425.0) ? 4 : 
		(c <  625.0) ? 5 : 
		(c < 1125.0) ? 6 : 
		               7;
	fprintf(stderr, "AD9883 calc - PixClk=%lu range=%u c=%f current=%u\n", fmt.PixelClock, range, c, current);
	
	bp = fmt.XOffset - fmt.HSyncWidth;  // BackPorch
	i2c_data[0x01 - 1][1] = (plldiv >> 4) & 0xFF;
	i2c_data[0x02 - 1][1] = (plldiv << 4) & 0xF0;
	i2c_data[0x03 - 1][1] = (range << 6) | (current << 3);

	printf("i2c_data[0x01]= 0x%x\n",i2c_data[0x01-1][1]);
	printf("i2c_data[0x02]= 0x%x\n",i2c_data[0x02-1][1]);
	printf("i2c_data[0x03]= 0x%x\n",i2c_data[0x03-1][1]);
	err = init_i2c(pInstance, delay, dev, i2c_data, sizeof(i2c_data) / sizeof (RMuint8) / 2);
	
	return err;
}

RMstatus ad9380_setCaptureStandardYUV(struct RUA *pInstance, RMuint8 dev, RMuint8 delay,enum EMhwlibTVStandard yuvId)
{
	RMstatus err=RM_OK;

	if (0) {
		ad9380_setCaptureStandard(pInstance,dev,delay,yuvId);
	}
	
	switch(yuvId) {
	
	case ad9380_yuv_ntsc:
		err=init_i2c(pInstance,delay,dev,AD9380_NTSC_I2CDATA,sizeof(AD9380_NTSC_I2CDATA)/2/sizeof(RMuint8));
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to set capture standard yuv 480i\n");
			return err;
		}
		break;
	case ad9380_yuv_pal:
		err=init_i2c(pInstance,delay,dev,AD9380_PAL_I2CDATA,sizeof(AD9380_PAL_I2CDATA)/2/sizeof(RMuint8));
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to set capture standard yuv 480i\n");
			return err;
		}
		break;
	case ad9380_yuv_480i:
		err=init_i2c(pInstance,delay,dev,AD9380_480i60_I2CDATA,sizeof(AD9380_480i60_I2CDATA)/2/sizeof(RMuint8));
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to set capture standard yuv 480i\n");
			return err;
		}
		break;
	
	case ad9380_yuv_480p:
		err=init_i2c(pInstance,delay,dev,AD9380_480p59_I2CDATA,sizeof(AD9380_480p59_I2CDATA)/2/sizeof(RMuint8));
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to set capture standard yuv 480p\n");
			return err;
		}
		break;
	
	case ad9380_yuv_576i:
		err=init_i2c(pInstance,delay,dev,AD9380_576i50_I2CDATA,sizeof(AD9380_576i50_I2CDATA)/2/sizeof(RMuint8));
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to set capture standard yuv 576i\n");
			return err;
		}
		break;	
	case ad9380_yuv_576p:	
		/*
		err=init_i2c(pInstance,delay,dev,AD9380_576p50_I2CDATA,sizeof(AD9380_576p50_I2CDATA)/2/sizeof(RMuint8));
				if (RMFAILED(err)) {
					fprintf(stderr, "Failed to set capture standard yuv 576p\n");
					return err;
				}*/
		
		err=init_i2c(pInstance,delay,dev,AD9380_480p59_I2CDATA,sizeof(AD9380_480p59_I2CDATA)/2/sizeof(RMuint8));
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to set capture standard yuv 480p\n");
			return err;
		}
		
		break;
	case ad9380_yuv_720p60:
		err=init_i2c(pInstance,delay,dev,AD9380_720p60_I2CDATA,sizeof(AD9380_720p60_I2CDATA)/2/sizeof(RMuint8));
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to set capture standard yuv 720p60\n");
			return err;
		}
		break;
	case ad9380_yuv_1080i25:
		err=init_i2c(pInstance,delay,dev,AD9380_1080i50_I2CDATA,sizeof(AD9380_1080i50_I2CDATA)/2/sizeof(RMuint8));
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to set capture standard yuv 1080i25\n");
			return err;
		}
		break;
	case ad9380_yuv_1080i30:
		err=init_i2c(pInstance,delay,dev,AD9380_1080i60_I2CDATA,sizeof(AD9380_1080i60_I2CDATA)/2/sizeof(RMuint8));
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to set capture standard yuv 1080i30\n");
			return err;
		}
		break;
	case ad9380_yuv_1080p60:
		err=init_i2c(pInstance,delay,dev,AD9380_1080p60_I2CDATA,sizeof(AD9380_1080p60_I2CDATA)/2/sizeof(RMuint8));
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to set capture standard yuv 1080p60\n");
			return err;
		}
		break;
	default:		
		fprintf(stderr, "No support current capture standard yuv !\n");		
		//ad9380_checkRegisterSet(pInstance,dev,delay);
		break;
	}

	return err;
}

RMstatus ad9380_setColorSpaceConverter(struct RUA *pInstance, RMuint8 dev, RMuint8 delay,RMuint8 cscId)
{
	RMstatus err=RM_OK;
	printf("*******ad9380_setColorSpaceConverter Call*****\n");
	switch(cscId) {
	case ad9380_yuv_480i:
		err=init_i2c(pInstance,delay,dev,AD9380_CSC_480i60,sizeof(AD9380_CSC_480i60)/2/sizeof(RMuint8));
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to set capture standard yuv 480i\n");
			return err;
		}
		break;
	case ad9380_yuv_480p:
	/*
		err=init_i2c(pInstance,delay,dev,AD9380_CSC_480p59,sizeof(AD9380_CSC_480p59)/2/sizeof(RMuint8));
			if (RMFAILED(err)) {
				fprintf(stderr, "Failed to set capture standard yuv 480p\n");
				return err;
			}*/
		err=init_i2c(pInstance,delay,dev,AD9380_CSC_TABLE46,sizeof(AD9380_CSC_TABLE46)/2/sizeof(RMuint8));
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to set capture standard yuv 480p\n");
			return err;
		}
		break;
	case ad9380_yuv_576i:
		err=init_i2c(pInstance,delay,dev,AD9380_CSC_576i50,sizeof(AD9380_CSC_576i50)/2/sizeof(RMuint8));
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to set capture standard yuv 576i\n");
			return err;
		}
		break;
	case ad9380_yuv_576p:	
		err=init_i2c(pInstance,delay,dev,AD9380_CSC_576p50,sizeof(AD9380_CSC_576p50)/2/sizeof(RMuint8));
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to set capture standard yuv 576p\n");
			return err;
		}
		break;
	case ad9380_yuv_720p60:
		err=init_i2c(pInstance,delay,dev,AD9380_CSC_720p60,sizeof(AD9380_CSC_720p60)/2/sizeof(RMuint8));
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to set capture standard yuv 720p60\n");
			return err;
		}
		break;
	case ad9380_yuv_1080i25:
		err=init_i2c(pInstance,delay,dev,AD9380_CSC_1080i50,sizeof(AD9380_CSC_1080i50)/2/sizeof(RMuint8));
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to set capture standard yuv 1080i25\n");
			return err;
		}
		break;
	case ad9380_yuv_1080i30:
		err=init_i2c(pInstance,delay,dev,AD9380_CSC_1080i60,sizeof(AD9380_CSC_1080i60)/2/sizeof(RMuint8));
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to set capture standard yuv 1080i30\n");
			return err;
		}
		break;
	case ad9380_yuv_1080p60:
		err=init_i2c(pInstance,delay,dev,AD9380_CSC_1080p60,sizeof(AD9380_CSC_1080p60)/2/sizeof(RMuint8));
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to set capture standard yuv 1080p60\n");
			return err;
		}
		break;
//VGA////////////////////////////////////////////////////////////////////////
	case ad9380_vga_25mhz_60hz: //640x480x60
		err=init_i2c(pInstance,delay,dev,AD9380_CSC_25MHz_60Hz_VGA,sizeof(AD9380_CSC_25MHz_60Hz_VGA)/2/sizeof(RMuint8));
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to set capture standard yuv 1080p60\n");
			return err;
		}
		break;		
	case ad9380_vga_40mhz_60hz: //800x600x60
		err=init_i2c(pInstance,delay,dev,AD9380_CSC_40MHz_60Hz_VGA,sizeof(AD9380_CSC_40MHz_60Hz_VGA)/2/sizeof(RMuint8));
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to set capture standard yuv 1080p60\n");
			return err;
		}
		break;	
	case ad9380_vga_65mhz_60hz: //1024x768x60
		//err=init_i2c(pInstance,delay,dev,AD9380_40MHz_60Hz_VGA_I2CDATA,sizeof(AD9380_40MHz_60Hz_VGA_I2CDATA)/2/sizeof(RMuint8));
		err=init_i2c(pInstance,delay,dev,AD9380_CSC_65MHz_60Hz_VGA,sizeof(AD9380_CSC_65MHz_60Hz_VGA)/2/sizeof(RMuint8));
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to set capture standard yuv 1080p60\n");
			return err;
		}
		break;	
	case ad9380_vga_78mhz_75hz: //1024x768x75
		err=init_i2c(pInstance,delay,dev,AD9380_CSC_78MHz_75Hz_VGA,sizeof(AD9380_CSC_78MHz_75Hz_VGA)/2/sizeof(RMuint8));
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to set capture standard yuv 1080p60\n");
			return err;
		}
		break;	
	case ad9380_vga_94mhz_85hz: //1024x768x85
		err=init_i2c(pInstance,delay,dev,AD9380_CSC_94MHz_85Hz_VGA,sizeof(AD9380_CSC_94MHz_85Hz_VGA)/2/sizeof(RMuint8));
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to set capture standard yuv 1080p60\n");
			return err;
		}
		break;	
	case ad9380_vga_108mhz_60hz://1280x1024x60
		err=init_i2c(pInstance,delay,dev,AD9380_CSC_108MHz_60Hz_VGA,sizeof(AD9380_CSC_108MHz_60Hz_VGA)/2/sizeof(RMuint8));
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to set capture standard yuv 1080p60\n");
			return err;
		}
		break;	
	case ad9380_vga_135mhz_75hz://1280x1024x75
		err=init_i2c(pInstance,delay,dev,AD9380_CSC_135MHz_75Hz_VGA,sizeof(AD9380_CSC_135MHz_75Hz_VGA)/2/sizeof(RMuint8));
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to set capture standard yuv 1080p60\n");
			return err;
		}
		break;	
	case ad9380_vga_157mhz_85hz://1280x1024x85
		err=init_i2c(pInstance,delay,dev,AD9380_CSC_157MHz_85Hz_VGA,sizeof(AD9380_CSC_157MHz_85Hz_VGA)/2/sizeof(RMuint8));
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to set capture standard yuv 1080p60\n");
			return err;
		}
		break;	
	
//HDMI////////////////////////////////////////////////////////////////////////
	case ad9380_hdmi_480i:
	case ad9380_hdmi_480p:
	case ad9380_hdmi_720p59:
	case ad9380_hdmi_720p60:
	case ad9380_hdmi_1080i59:
	case ad9380_hdmi_1080i60:
	case ad9380_hdmi_1080p59:
	case ad9380_hdmi_1080p60:
		if (0) {
			err=init_i2c(pInstance,delay,dev,AD9380_CSC_HDMI,sizeof(AD9380_CSC_HDMI)/2/sizeof(RMuint8));
			if (RMFAILED(err)) {
				fprintf(stderr, "Failed to set capture standard HDMI !\n");
				return err;
			}
		}else {
			err=init_i2c(pInstance,delay,dev,AD9380_CSC_TABLE46,sizeof(AD9380_CSC_TABLE46)/2/sizeof(RMuint8));
			if (RMFAILED(err)) {
				fprintf(stderr, "Failed to set capture standard HDMI !\n");
				return err;
			}
		}
		
		break;	
		
	default:
		err=RM_ERROR;
		if (RMFAILED(err)) {
			fprintf(stderr, "No support current capture standard yuv !\n");
		}
		break;
	}
	
	return err;
}

RMstatus ad9380_setColorSpaceConverterStatus(struct RUA *pInstance, RMuint8 dev, RMuint8 delay,RMuint8 isEnable)
{
	RMstatus err=RM_OK;
	RMuint32 regAdd=0;
	RMuint32 regValue=0;
	regAdd=0x34;
	err = read_i2c(pInstance, delay, dev, regAdd, &regValue);
	if (RMFAILED(err)) {
		fprintf(stderr, "Failed to read reg 0x%lx\n",regAdd);
		return err;
	}

	if (isEnable) {
		regValue |= 0x02;
		err = write_i2c(pInstance, delay, dev,regAdd,regValue);
		if (RMFAILED(err)) {
			fprintf(stderr, "Can't enable CSC . \nFailed to write reg 0x%lx\n",regAdd);
			return err;
		}
	}else {
		regValue &= (~0x02);
		err = write_i2c(pInstance, delay, dev,regAdd,regValue);
		if (RMFAILED(err)) {
			fprintf(stderr, "Can't disable CSC . \nFailed to write reg 0x%lx\n",regAdd);
			return err;
		}
	}


	return err;
}


RMstatus ad9380_setAutoOffset(struct RUA *pInstance, RMuint8 dev, RMuint8 delay,RMuint8 isHold)
{
	RMstatus err=RM_OK;
	RMuint32 regAdd=0;
	RMuint32 regValue=0;
	regAdd=0x1b;
	err = read_i2c(pInstance, delay, dev, regAdd, &regValue);
	if (RMFAILED(err)) {
		fprintf(stderr, "Failed to read reg 0x%lx\n",regAdd);
		return err;
	}
	
	if (isHold) {
		regValue |= 0x01;
		err = write_i2c(pInstance, delay, dev,regAdd,regValue);
		if (RMFAILED(err)) {
			fprintf(stderr, "Can't Hold Auto offset . \nFailed to write reg 0x%lx\n",regAdd);
			return err;
		}
	}else {
		regValue &= (~0x01);
		err = write_i2c(pInstance, delay, dev,regAdd,regValue);
		if (RMFAILED(err)) {
			fprintf(stderr, "Can't use Auto offset . \nFailed to write reg 0x%lx\n",regAdd);
			return err;
		}
	}
	
	
	return err;
}

///HDMI CAPTURE//////////////////////////////////////////////////////////////////////////
RMstatus ad9380_isHdmiMode(struct RUA *pInstance,
						   RMuint8 dev, 
						   RMuint8 delay,
						   RMuint8 *isHDMIMode)
{
	RMstatus err=RM_OK;
	RMuint32 regAdd=0;
	RMuint32 regVal=0;
	regAdd=0x5b;
	err=read_i2c(pInstance,delay,dev,regAdd,&regVal);
	if (RMFAILED(err)) {
		fprintf(stderr, "Failed to read reg 0x%lx\n",regAdd);
		return err;
	}
	if (regVal & 0x08) {
		*isHDMIMode=1;
	}else
		*isHDMIMode=0; //DVI
	return err;
}

RMstatus ad9380_isHdmiRGBAviInput(struct RUA *pInstance,
						   RMuint8 dev, 
						   RMuint8 delay,
						   RMuint8 *isRGB)
{
	RMstatus err=RM_OK;
	RMuint32 regAdd=0;
	RMuint32 regVal=0;
	regAdd=0x81;