ad9380.c

Sample code for use on smp 863x processor.

{
	RMstatus err=RM_OK;
	if (0) {
		ad9380_setCaptureStandard(pInstance,dev,delay,vgaId);
	}
	
	switch(vgaId) {		
	//VGA STANDARD :
	case ad9380_vga_25mhz_60hz: //640x480x60
	case ad9380_vga_25mhz_75hz:
	case ad9380_vga_25mhz_85hz:
			
		
		if (1) {
			err=init_i2c(pInstance,delay,dev,AD9380_25MHz_60Hz_VGA_I2CDATA,sizeof(AD9380_25MHz_60Hz_VGA_I2CDATA)/2/sizeof(RMuint8));
			if (RMFAILED(err)) {
				fprintf(stderr, "Failed to set capture standard yuv 1080p60\n");
				return err;			
			}
		}else {
			err=init_i2c(pInstance,delay,dev,AD9380_TEST_VGA_I2CDATA,sizeof(AD9380_TEST_VGA_I2CDATA)/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
	case ad9380_vga_40mhz_75hz: //800x600x75
	case ad9380_vga_40mhz_85hz: //800x600x85
		err=init_i2c(pInstance,delay,dev,AD9380_40MHz_60Hz_VGA_I2CDATA,sizeof(AD9380_40MHz_60Hz_VGA_I2CDATA)/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_65MHz_60Hz_VGA_I2CDATA,sizeof(AD9380_65MHz_60Hz_VGA_I2CDATA)/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_78MHz_75Hz_VGA_I2CDATA,sizeof(AD9380_78MHz_75Hz_VGA_I2CDATA)/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_94MHz_85Hz_VGA_I2CDATA,sizeof(AD9380_94MHz_85Hz_VGA_I2CDATA)/2/sizeof(RMuint8));
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to set capture standard yuv 1080p60\n");
			return err;
		}
		break;	
	case ad9380_vga_1280_768:
		err=init_i2c(pInstance,delay,dev,AD9380_1280_768_VGA_I2CDATA,sizeof(AD9380_1280_768_VGA_I2CDATA)/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_108MHz_60Hz_VGA_I2CDATA,sizeof(AD9380_108MHz_60Hz_VGA_I2CDATA)/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_135MHz_75Hz_VGA_I2CDATA,sizeof(AD9380_135MHz_75Hz_VGA_I2CDATA)/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_157MHz_85Hz_VGA_I2CDATA,sizeof(AD9380_157MHz_85Hz_VGA_I2CDATA)/2/sizeof(RMuint8));
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to set capture standard yuv 1080p60\n");
			return err;
		}
		break;	
		
	default:
		err=RM_ERROR;
		if (RMFAILED(err)) {
			fprintf(stderr, "No support current capture standard vga !\n");
		}
		break;
	}
	
	return err;
}

//////////////////////////////////////////////////////////////////////////


RMstatus ad9380_setCapturePort(struct RUA *pInstance, RMuint8 dev, RMuint8 delay,RMuint8 port)
{
	RMstatus err=RM_OK;
	RMuint32 regValue=0;
	RMuint32 regAdd=0x11;
	switch (port) {
				case 1:     //YUV
					regValue=0xfd;				
					err = write_i2c(pInstance, delay, dev,regAdd,regValue);
					if (RMFAILED(err)) {
						fprintf(stderr, "Failed to write register 0x%lx\n",regAdd);
						return err;
					}
					err=init_i2c(pInstance,delay,dev,AD9380_RGB_I2CDATA,sizeof(AD9380_RGB_I2CDATA)/2/sizeof(RMuint8));
					if (RMFAILED(err)) {
						fprintf(stderr, "Failed to set capture standard yuv 480i\n");
						return err;
					}

					break;
				case 2:    //VGA
					regValue=0x55;
					err = write_i2c(pInstance, delay, dev,regAdd,regValue);
					if (RMFAILED(err)) {
						fprintf(stderr, "Failed to write register 0x%lx\n",regAdd);
						return err;
					}
					//Default RGB Data.
					err=init_i2c(pInstance,delay,dev,AD9380_RGB_I2CDATA,sizeof(AD9380_RGB_I2CDATA)/2/sizeof(RMuint8));
					if (RMFAILED(err)) {
						fprintf(stderr, "Failed to set capture standard yuv 480i\n");
						return err;
					}
					break;
				case 3:    //HDMI
					regValue=0x02;
					//regValue=0xff;

					err = write_i2c(pInstance, delay, dev,regAdd,regValue);
					if (RMFAILED(err)) {
						fprintf(stderr, "Failed to write register 0x%lx\n",regAdd);
						return err;
					}
					//isUpdateCSC=1; //Enable Update Color Converter Space					
					isUpdateCSCTable=1;
					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;
					}
//					err=ad9380_setHdmiCSCOutput(pInstance,dev,delay,1);
					break;
				default: 
					printf("Only support YUV,VGA and HDMI Capture Port ! YUV By default !\n");
					regValue=0xfd;
					err = write_i2c(pInstance, delay, dev,regAdd,regValue);
					break;
				}
//	usleep(50);	
	return err;
}

//GAIN
RMstatus ad9380_setContrast(struct RUA *pInstance, 								  
							   RMuint8 dev, 
							   RMuint8 delay,
							   RMuint32 contrastValue)
{
	RMstatus err=RM_OK;
	// if contrastValue = 0x80 or 0x90 -> No effect on the video data
	if ((contrastValue>=0)&&(contrastValue<=255)) {
		RMuint32 regValue=0;
		RMuint32 regAdd=0x00;
		regAdd=0x05; //Red gain
		regValue=contrastValue & 0xff;
		err=write_i2c(pInstance,delay,dev,regAdd,regValue);
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to write reg 0x%lx\n",regAdd);
			return err;
		}		
		regAdd=0x06; //Green gain
		regValue=contrastValue & 0xff;
		err=write_i2c(pInstance,delay,dev,regAdd,regValue);
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to write reg 0x%lx\n",regAdd);
			return err;
		}
		regAdd=0x07; //Blue gain
		regValue=contrastValue & 0xff;
		err=write_i2c(pInstance,delay,dev,regAdd,regValue);
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to write reg 0x%lx\n",regAdd);
			return err;
		}

	}
	return err;
}

RMstatus ad9380_getContrast(struct RUA *pInstance, 								  
							   RMuint8 dev, 
							   RMuint8 delay,
							   RMuint32 *contrastValue)
{
	RMstatus err=RM_OK;
	// if contrastValue = 0x80 or 0x90 -> No effect on the video data
	
	RMuint32 regValue=0;
	RMuint32 regAdd=0x05;	
	err=read_i2c(pInstance,delay,dev,regAdd,&regValue);
	if (RMFAILED(err)) {
		fprintf(stderr, "Failed to read reg 0x%lx\n",regAdd);
		return err;
	}
	
	*contrastValue=regValue & 0xff;
	
	return err;
}

RMstatus ad9380_isContrastValid(struct RUA *pInstance, 								  
								RMuint8 dev, 
								RMuint8 delay,
								RMuint32 contrastValue)
{
	RMstatus err=RM_OK;
	// if contrastValue = 0x80 or 0x90 -> No effect on the video data
	if ((contrastValue<0)||(contrastValue>255)) {
		err=RM_ERROR;
	}
	return err;
}


RMstatus ad9380_setBrightness(struct RUA *pInstance, 								  
								 RMuint8 dev, 
								 RMuint8 delay,
								 RMint32 brightnessValue)
{
	RMstatus err=RM_OK;
	// if contrastValue = 0x80 or 0x90 -> No effect on the video data
	if ((brightnessValue>=-128)&&(brightnessValue<=127)) {
		RMuint32 regValue=0;
		RMuint32 regAdd=0x00;
		regAdd=0x09;//Red offset
		regValue=brightnessValue & 0xff;
		err=write_i2c(pInstance,delay,dev,regAdd,regValue);
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to write reg 0x%lx\n",regAdd);
			return err;
		}		
		regAdd=0x0b;//Green offset
		regValue=brightnessValue & 0xff;
		err=write_i2c(pInstance,delay,dev,regAdd,regValue);
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to write reg 0x%lx\n",regAdd);
			return err;
		}		
		regAdd=0x0d;//blue offset
		regValue=brightnessValue & 0xff;
		err=write_i2c(pInstance,delay,dev,regAdd,regValue);
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to write reg 0x%lx\n",regAdd);
			return err;
		}		
	}
	return err;
}

RMstatus ad9380_getBrightness(struct RUA *pInstance, 								  
							RMuint8 dev, 
							RMuint8 delay,
							RMint32 *brightnessValue)
{
	RMstatus err=RM_OK;
	// if contrastValue = 0x80 or 0x90 -> No effect on the video data
	
	RMuint32 regValue=0;
	RMuint32 regAdd=0x09;	
	err=read_i2c(pInstance,delay,dev,regAdd,&regValue);
	if (RMFAILED(err)) {
		fprintf(stderr, "Failed to read reg 0x%lx\n",regAdd);
		return err;
	}
	
	//*brightnessValue=regValue & 0xff;
	
	return err;
}

RMstatus ad9380_isBrightnessValid(struct RUA *pInstance, 								  
								RMuint8 dev, 
								RMuint8 delay,
								RMint32 brightnessValue)
{
	RMstatus err=RM_OK;
	// if brightnessValue = 0x80 or 0x90 -> No effect on the video data
	if ((brightnessValue<-128)||(brightnessValue>127)) {
		err=RM_ERROR;
	}
	return err;
}


RMstatus ad9380_setBrightnessAdjust(struct RUA *pInstance, 								  
								 RMuint8 dev, 
								 RMuint8 delay,
								 RMint32 brightnessValue)
{
	RMstatus err=RM_OK;
	// if contrastValue = 0x80 or 0x90 -> No effect on the video data
	if ((brightnessValue>=-128)&&(brightnessValue<=127)) {
		RMuint32 regValue=0;
		RMuint32 regAdd=0x00;
		regAdd=0x08;//Red offset
		regValue=brightnessValue & 0xff;
		err=write_i2c(pInstance,delay,dev,regAdd,regValue);
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to write reg 0x%lx\n",regAdd);
			return err;
		}		
		regAdd=0x0a;//Green offset
		regValue=brightnessValue & 0xff;
		err=write_i2c(pInstance,delay,dev,regAdd,regValue);
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to write reg 0x%lx\n",regAdd);
			return err;
		}		
		regAdd=0x0c;//blue offset
		regValue=brightnessValue & 0xff;
		err=write_i2c(pInstance,delay,dev,regAdd,regValue);
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to write reg 0x%lx\n",regAdd);
			return err;
		}		
	}
	return err;
}

RMstatus ad9380_getBrightnessAdjust(struct RUA *pInstance, 								  
							RMuint8 dev, 
							RMuint8 delay,
							RMint32 *brightnessValue)
{
	RMstatus err=RM_OK;
	// if contrastValue = 0x80 or 0x90 -> No effect on the video data
	
	RMuint32 regValue=0;
	RMuint32 regAdd=0x08;	
	err=read_i2c(pInstance,delay,dev,regAdd,&regValue);
	if (RMFAILED(err)) {
		fprintf(stderr, "Failed to read reg 0x%lx\n",regAdd);
		return err;
	}
	
	//*brightnessValue=regValue & 0xff;
	
	return err;
}

RMstatus ad9380_isBrightnessAdjustValid(struct RUA *pInstance, 								  
								RMuint8 dev, 
								RMuint8 delay,
								RMint32 brightnessValue)
{
	RMstatus err=RM_OK;
	// if brightnessValue = 0x80 or 0x90 -> No effect on the video data
	if ((brightnessValue<-128)||(brightnessValue>127)) {
		err=RM_ERROR;
	}
	return err;
}


static RMstatus ad9380_TestRegister(struct RUA *pInstance, 								  
									   RMuint8 dev, 
									   RMuint8 delay,
									   RMuint32 regAdd,
									   RMuint32 isAsc)
{
	
	RMstatus err=RM_OK;
	RMuint32 regValue=0;
	RMuint32 i=0;
	
	for(i=0;i<=255;i++)
	{
		if (!isAsc) 
			regValue=255-i;
		else
			regValue=i;
		err=write_i2c(pInstance,delay,dev,regAdd,regValue);
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to write reg 0x%lx\n",regAdd);
			return err;
		}
		usleep(50000);
		printf("0x%lx = 0x%lx\n",regAdd,regValue);
		
	}
	return err;
}


RMstatus ad9380_setColorSpaceConverter_test(struct RUA *pInstance, RMuint8 dev, RMuint8 delay,RMuint8 tableId)
{
	RMstatus err=RM_OK;
	
	switch(tableId) {
	case 1://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 2://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;
		}
		break;
	case 3://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 4://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 5://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 6://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 7://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 8://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;
		
	case 44:
		err=init_i2c(pInstance,delay,dev,AD9380_CSC_TABLE44,sizeof(AD9380_CSC_TABLE44)/2/sizeof(RMuint8));
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to set capture standard yuv 44\n");
			return err;
		}
		break;
	case 45:
		err=init_i2c(pInstance,delay,dev,AD9380_CSC_TABLE45,sizeof(AD9380_CSC_TABLE45)/2/sizeof(RMuint8));
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to set capture standard yuv 45\n");
			return err;