dcc_display.c

dcc code for smp 8634 media processor

	if (RMFAILED(err = DCCGetVideoConnectorModuleID(pDCC, DCCRoute_Main, slave_connector, &slave))) 
		return err;
	if (RMFAILED(err = get_mixer_from_route(route, &mixer))) 
		return err;

	unbind_outport(pDCC, slave);
	
	/* the slave output has the same tv standard than its master */
	err = RUAGetProperty(pDCC->pRUA, master, RMGenericPropertyID_TVStandard, &standard, sizeof(standard));
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot get the master's tv standard\n"));
		return err;
	}


	disp_route.Enable = TRUE;
	disp_route.SourceModuleID = mixer;
	disp_route.DestinationModuleID = slave;
	DCCSP(pDCC->pRUA, routing, RMDispRoutingPropertyID_Route, &disp_route, sizeof(disp_route));

	DCCSP(pDCC->pRUA, routing, RMGenericPropertyID_Validate, NULL, 0);

	enable = TRUE;
	DCCSP(pDCC->pRUA, routing, RMGenericPropertyID_Enable, &enable, sizeof(enable));
	DCCSP(pDCC->pRUA, master, RMGenericPropertyID_AddSlaveOutput, &slave, sizeof(slave));
	DCCSP(pDCC->pRUA, master, RMGenericPropertyID_Validate, NULL, 0);
	
	DCCSP(pDCC->pRUA, slave, RMGenericPropertyID_SyncSourceModuleID, &master, sizeof(master));
	DCCSP(pDCC->pRUA, slave, RMGenericPropertyID_TVStandard, &standard, sizeof(standard));
	DCCSP(pDCC->pRUA, slave, RMGenericPropertyID_Validate, NULL, 0);

 	enable = TRUE;
	DCCSP(pDCC->pRUA, slave, RMGenericPropertyID_Enable, &enable, sizeof(enable));


	return RM_OK;
}

RMstatus DCCSetSDSlaveConnector(struct DCC *pDCC,
				enum DCCVideoConnector sd_connector,
				enum DCCVideoConnector hd_connector,
				enum EMhwlibTVStandard sd_standard,
				enum EMhwlibHDSDConversionMode hdsd_mode)
{
	enum EMhwlibTVStandard hd_standard;
	RMbool enable;
	RMuint32 hd_outport_id, sd_outport_id;
	RMuint32 routing = EMHWLIB_MODULE(DispRouting, 0); 
	RMuint32 dumped_lines = 0;
	struct DispRouting_Route_type disp_route;
	RMstatus err;

	struct EMhwlibClockGenerator sd_clock_pll;

	struct DispHDSDConverter_OnTheFlyModeParameters_in_type fly_params_in;
	struct DispHDSDConverter_OnTheFlyModeParameters_out_type fly_params_out;

	struct DispHDSDConverter_BufferedModeParameters_in_type buffer_params_in;
	struct DispHDSDConverter_BufferedModeParameters_out_type buffer_params_out;
	struct DispHDSDConverter_Open_type hdsd_open;
	struct DispComponentOut_TimingResetMaster_type reset_master;



	if (RMFAILED(err = DCCGetVideoConnectorModuleID(pDCC, DCCRoute_Main, sd_connector, &sd_outport_id))) 
		return err;
	if (RMFAILED(err = DCCGetVideoConnectorModuleID(pDCC, DCCRoute_Main, hd_connector, &hd_outport_id))) 
		return err;

	unbind_outport(pDCC, sd_outport_id);
	
	/* free previously allocated conversion buffer (if any) */
	{
		struct DispHDSDConverter_ConversionBuffer_type conversion_buffer;

		err = RUAGetProperty(pDCC->pRUA, DispHDSDConverter, RMDispHDSDConverterPropertyID_ConversionBuffer, &conversion_buffer, sizeof(conversion_buffer));
		if (RMFAILED(err)) {
			RMDBGLOG((ENABLE, "Cannot get HDSD converter's converison buffer info\n"));
			return err;
		}
		
		DCCSP(pDCC->pRUA, DispHDSDConverter,RMDispHDSDConverterPropertyID_Close, NULL, 0);
		if(conversion_buffer.BufferAddress){
			pDCC->rua_free(pDCC->pRUA, conversion_buffer.BufferAddress);
			RMDBGLOG((ENABLE, "Freed %ld bytes from 0x%08lx\n",conversion_buffer.BufferSize, conversion_buffer.BufferAddress));
		}
	}

	err = RUAGetProperty(pDCC->pRUA, hd_outport_id, RMGenericPropertyID_TVStandard, &hd_standard, sizeof(hd_standard));
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot get the master's tv standard\n"));
		return err;
	}


	disp_route.Enable = TRUE;
	disp_route.SourceModuleID = EMHWLIB_MODULE(DispHDSDConverter, 0);
	disp_route.DestinationModuleID = sd_outport_id;
	DCCSP(pDCC->pRUA, routing, RMDispRoutingPropertyID_Route, &disp_route, sizeof(disp_route));

	DCCSP(pDCC->pRUA, routing, RMGenericPropertyID_Validate, NULL, 0);
 	enable = TRUE;
	DCCSP(pDCC->pRUA, routing, RMGenericPropertyID_Enable, &enable, sizeof(enable));


	sd_clock_pll.PLL = PLLGen_cd_9;
	sd_clock_pll.PLLOut = PLL_VIDEO_OUT;
 	DCCSP(pDCC->pRUA, sd_outport_id, RMGenericPropertyID_MasterClockGenerator, &sd_clock_pll, sizeof(sd_clock_pll));

/* 	sd_clock_pll.PLL = PLLGen_cd_8; */
/* 	sd_clock_pll.PLLOut = PLL_VIDEO_OUT; */
/*  	DCCSP(pDCC->pRUA, hd_outport_id, RMGenericPropertyID_MasterClockGenerator, &sd_clock_pll, sizeof(sd_clock_pll)); */

	RUAExchangeProperty(pDCC->pRUA, DisplayBlock, RMDisplayBlockPropertyID_TVFormatAnalog,
			    &hd_standard, sizeof(hd_standard), &(fly_params_in.HDFormat), sizeof(fly_params_in.HDFormat));

	RUAExchangeProperty(pDCC->pRUA, DisplayBlock, RMDisplayBlockPropertyID_TVFormatAnalog, 
			    &sd_standard, sizeof(sd_standard), &(fly_params_in.SDFormat), sizeof(fly_params_in.SDFormat));

	RUAExchangeProperty(pDCC->pRUA, DisplayBlock, RMDisplayBlockPropertyID_TVFormatAnalog,
			    &hd_standard, sizeof(hd_standard), &(buffer_params_in.HDFormat), sizeof(buffer_params_in.HDFormat));

	RUAExchangeProperty(pDCC->pRUA, DisplayBlock, RMDisplayBlockPropertyID_TVFormatAnalog, 
			    &sd_standard, sizeof(sd_standard), &(buffer_params_in.SDFormat), sizeof(buffer_params_in.SDFormat));

	RUAExchangeProperty(pDCC->pRUA, DisplayBlock, RMDisplayBlockPropertyID_TVFormatAnalog, 
			    &sd_standard, sizeof(sd_standard), &(hdsd_open.SDFormat), sizeof(hdsd_open.SDFormat));
	
	switch(hdsd_mode){
	case EMhwlibHDSDConversionMode_OnTheFly:
		err = RUAExchangeProperty(pDCC->pRUA, DispHDSDConverter, RMDispHDSDConverterPropertyID_OnTheFlyModeParameters, 
					  &fly_params_in, sizeof(fly_params_in), &(fly_params_out), sizeof(fly_params_out));
		if(RMFAILED(err)){
			RMDBGLOG((ENABLE, "Incompatible formats for on-the-fly conversion\n"));
			return RM_ERROR;
		}
		RMDBGLOG((ENABLE, "=================ON THE FLY MODE====================\n", buffer_params_out.BufferSize));
		RMDBGLOG((ENABLE, "dumped lines %ld, delay %ld\n", fly_params_out.DumpedLines, fly_params_out.DelayLines, fly_params_out.DelayPixels));

		dumped_lines = fly_params_out.DumpedLines;
		reset_master.ResetSourceID = sd_outport_id;
		reset_master.DelayLines = fly_params_out.DelayLines;
		reset_master.DelayPixels = fly_params_out.DelayPixels;
		break;
	case EMhwlibHDSDConversionMode_Buffered:

		RUAExchangeProperty(pDCC->pRUA, DispHDSDConverter, RMDispHDSDConverterPropertyID_BufferedModeParameters, 
				    &buffer_params_in, sizeof(buffer_params_in), &(buffer_params_out), sizeof(buffer_params_out));
		RMDBGLOG((ENABLE, "=================BUFFERED MODE====================\n", buffer_params_out.BufferSize));
		RMDBGLOG((ENABLE, "buffer is %ld bytes long\n", buffer_params_out.BufferSize));

		hdsd_open.BufferSize = buffer_params_out.BufferSize;
		hdsd_open.BufferAddress = pDCC->rua_malloc(pDCC->pRUA, DisplayBlock, pDCC->dram, RUA_DRAM_UNCACHED, buffer_params_out.BufferSize);
		DCCSP(pDCC->pRUA, DispHDSDConverter, RMDispHDSDConverterPropertyID_Open, &hdsd_open, sizeof(hdsd_open));

		dumped_lines = 0;
		reset_master.ResetSourceID = hd_outport_id;
		reset_master.DelayLines = 0;
		reset_master.DelayPixels = 0;
		break;
	}

	DCCSP(pDCC->pRUA, hd_outport_id, RMGenericPropertyID_TimingResetMaster, &reset_master, sizeof(reset_master));

	DCCSP(pDCC->pRUA, DispHDSDConverter, RMDispHDSDConverterPropertyID_ConversionMode, &hdsd_mode, sizeof(hdsd_mode));

	DCCSP(pDCC->pRUA, DispHDSDConverter, RMDispHDSDConverterPropertyID_DumpedLines, &dumped_lines, sizeof(dumped_lines));
	DCCSP(pDCC->pRUA, DispHDSDConverter, RMGenericPropertyID_Validate, NULL, 0);
	enable = TRUE;
	DCCSP(pDCC->pRUA, DispHDSDConverter, RMGenericPropertyID_Enable, &enable, sizeof(enable));

	DCCSP(pDCC->pRUA, sd_outport_id, RMGenericPropertyID_SyncSourceModuleID, &sd_outport_id, sizeof(sd_outport_id));
	DCCSP(pDCC->pRUA, sd_outport_id, RMGenericPropertyID_TVStandard, &sd_standard, sizeof(sd_standard));

	enable = TRUE;
	DCCSP(pDCC->pRUA, sd_outport_id, RMGenericPropertyID_Enable, &enable, sizeof(enable));
	DCCSP(pDCC->pRUA, hd_outport_id, RMGenericPropertyID_Enable, &enable, sizeof(enable));


	DCCSP(pDCC->pRUA, sd_outport_id, RMGenericPropertyID_Validate, NULL, 0);
	DCCSP(pDCC->pRUA, hd_outport_id, RMGenericPropertyID_Validate, NULL, 0);

	return RM_OK;
}





RMstatus DCCSetStandard(struct DCC *pDCC, enum DCCRoute route, enum EMhwlibTVStandard standard)
{
	RMstatus err;

	err = DCCSetMasterConnector(pDCC, DCCVideoConnector_DVI, route, standard);
	if(RMFAILED(err)){
		RMDBGLOG((ENABLE, "Error while setting the DVI connector\n"));
		return err;
	}
	if (! DCCGetDoubleRate(standard)) {
		err = DCCSetSlaveConnector(pDCC, DCCVideoConnector_COMPONENT,  DCCVideoConnector_DVI, route);
		if(RMFAILED(err)){
			RMDBGLOG((ENABLE, "Error while setting the COMPONENT connector\n"));
			return err;
		}
		err = DCCSetSlaveConnector(pDCC, DCCVideoConnector_COMPOSITE,  DCCVideoConnector_DVI, route);
		if(RMFAILED(err)){
			RMDBGLOG((ENABLE, "Error while setting the COMPOSITE connector\n"));
			return err;
		}
	}

	return RM_OK;
}



RMstatus DCCSetStandardDual(
	struct DCC *pDCC, 
	enum DCCRoute route_video, 
	enum DCCRoute route_vga, 
	enum EMhwlibTVStandard standard_video, 
	enum EMhwlibTVStandard standard_vga)
{
	RMbool enable;
	RMuint32 master_vga, slave_vga, master_video, slave_video, mixer_video = 0, mixer_vga = 0;
	RMuint32 bus_size = 24;
	enum EMhwlibColorSpace colorspace;
	RMuint32 routing = EMHWLIB_MODULE(DispRouting, 0); 
	struct DispRouting_Route_type disp_route;
	struct EMhwlibClockGenerator vga_clock_pll, video_clock_pll;
	
/* Works only on chips with two mixers, TODO adapt to future chips with "full" display */
#ifndef RMFEATURE_HAS_VCR_MIXER
	return RM_ERROR;
#endif
	
	master_vga = EMHWLIB_MODULE(DispDigitalOut, 0);
	slave_vga = EMHWLIB_MODULE(DispComponentOut, 0);
 	master_video = EMHWLIB_MODULE(DispMainAnalogOut, 0);
	slave_video = EMHWLIB_MODULE(DispCompositeOut, 0);
	
	if (route_video == route_vga) return RM_ERROR;
	
	switch (route_video) {
	case DCCRoute_Main:
		mixer_video = EMHWLIB_MODULE(DispMainMixer, 0);
		break;
	case DCCRoute_Secondary:
		mixer_video = EMHWLIB_MODULE(DispVCRMixer, 0);
		break;
	case DCCRoute_ColorBars:
		mixer_video = EMHWLIB_MODULE(DispColorBars, 0);
		break;
	case DCCRoute_HDSD:
		return RM_ERROR;
	}
	
	switch (route_vga) {
	case DCCRoute_Main:
		mixer_vga = EMHWLIB_MODULE(DispMainMixer, 0);
		break;
	case DCCRoute_Secondary:
		mixer_vga = EMHWLIB_MODULE(DispVCRMixer, 0);
		break;
	case DCCRoute_ColorBars:
		mixer_vga = EMHWLIB_MODULE(DispColorBars, 0);
		break;
	case DCCRoute_HDSD:
		return RM_ERROR;

	}
	
	vga_clock_pll.PLL = PLL_VIDEO_PRI;  // make sure DispDigitalOut is assigned primary PLL (hwlimit of SMP8634)
	vga_clock_pll.PLLOut = PLLOut_1;
	video_clock_pll.PLL = PLL_VIDEO_SEC;
	video_clock_pll.PLLOut = PLLOut_1;
	
	colorspace = EMhwlibColorSpace_RGB_0_255;
	DCCSP(pDCC->pRUA, master_vga, RMGenericPropertyID_ColorSpace, &colorspace, sizeof(colorspace));
	DCCSP(pDCC->pRUA, master_vga, RMGenericPropertyID_MasterClockGenerator, &vga_clock_pll, sizeof(vga_clock_pll));
	DCCSP(pDCC->pRUA, master_vga, RMDispDigitalOutPropertyID_BusSize, &bus_size, sizeof(bus_size));
	DCCSP(pDCC->pRUA, master_vga, RMGenericPropertyID_TVStandard, &standard_vga, sizeof(standard_vga));
	DCCSP(pDCC->pRUA, master_vga, RMGenericPropertyID_SyncSourceModuleID, &master_vga, sizeof(master_vga));
	DCCSP(pDCC->pRUA, master_vga, RMGenericPropertyID_AddSlaveOutput, &slave_vga, sizeof(slave_vga));
	{
		RMbool DoubleRate = DCCGetDoubleRate(standard_vga);
		RMDBGLOG((LOCALDBG, "Applying DoubleRate(%s)\n", DoubleRate ? "TRUE" : "FALSE"));
		DCCSP(pDCC->pRUA, DispDigitalOut, RMDispDigitalOutPropertyID_DoubleRate, &DoubleRate, sizeof(DoubleRate));
	}
	DCCSP(pDCC->pRUA, master_vga, RMGenericPropertyID_Validate, NULL, 0);
	
 	enable = TRUE;
	DCCSP(pDCC->pRUA, master_vga, RMGenericPropertyID_Enable, &enable, sizeof(enable));
	
	DCCSP(pDCC->pRUA, slave_vga, RMGenericPropertyID_SyncSourceModuleID, &master_vga, sizeof(master_vga));
	DCCSP(pDCC->pRUA, slave_vga, RMGenericPropertyID_TVStandard, &standard_vga, sizeof(standard_vga));
	DCCSP(pDCC->pRUA, slave_vga, RMGenericPropertyID_Validate, NULL, 0);
	
	enable = TRUE;
	DCCSP(pDCC->pRUA, slave_vga, RMGenericPropertyID_Enable, &enable, sizeof(enable));
	
	DCCSP(pDCC->pRUA, master_video, RMGenericPropertyID_MasterClockGenerator, &video_clock_pll, sizeof(video_clock_pll));
	DCCSP(pDCC->pRUA, master_video, RMGenericPropertyID_SyncSourceModuleID, &master_video, sizeof(master_video));
	DCCSP(pDCC->pRUA, master_video, RMGenericPropertyID_TVStandard, &standard_video, sizeof(standard_video));
	DCCSP(pDCC->pRUA, master_video, RMGenericPropertyID_Validate, NULL, 0);
	DCCSP(pDCC->pRUA, master_video, RMGenericPropertyID_AddSlaveOutput, &slave_video, sizeof(slave_video));
	DCCSP(pDCC->pRUA, master_video, RMGenericPropertyID_Validate, NULL, 0);
	
 	enable = TRUE;
	DCCSP(pDCC->pRUA, master_video, RMGenericPropertyID_Enable, &enable, sizeof(enable));
	
	if (
		(standard_video == EMhwlibTVStandard_NTSC_M) || 
		(standard_video == EMhwlibTVStandard_NTSC_M_Japan) || 
		(standard_video == EMhwlibTVStandard_PAL_60) || 
		(standard_video == EMhwlibTVStandard_PAL_M) || 
		(standard_video == EMhwlibTVStandard_PAL_BG) || 
		(standard_video == EMhwlibTVStandard_PAL_N) 
	) {
		DCCSP(pDCC->pRUA, slave_video, RMGenericPropertyID_SyncSourceModuleID, &master_video, sizeof(master_video));
		DCCSP(pDCC->pRUA, slave_video, RMGenericPropertyID_TVStandard, &standard_video, sizeof(standard_video));
		DCCSP(pDCC->pRUA, slave_video, RMGenericPropertyID_Validate, NULL, 0);
		
		enable = TRUE;
		DCCSP(pDCC->pRUA, slave_video, RMGenericPropertyID_Enable, &enable, sizeof(enable));
	}
	
	disp_route.Enable = TRUE;
	disp_route.SourceModuleID = mixer_vga;
	disp_route.DestinationModuleID = master_vga;
	DCCSP(pDCC->pRUA, routing, RMDispRoutingPropertyID_Route, &disp_route, sizeof(disp_route));
	
	disp_route.Enable = TRUE;
	disp_route.SourceModuleID = mixer_vga;
	disp_route.DestinationModuleID = slave_vga;
	DCCSP(pDCC->pRUA, routing, RMDispRoutingPropertyID_Route, &disp_route, sizeof(disp_route));
	
	disp_route.Enable = TRUE;
	disp_route.SourceModuleID = mixer_video;
	disp_route.DestinationModuleID = master_video;
	DCCSP(pDCC->pRUA, routing, RMDispRoutingPropertyID_Route, &disp_route, sizeof(disp_route));
	
	if (
		(standard_video == EMhwlibTVStandard_NTSC_M) || 
		(standard_video == EMhwlibTVStandard_NTSC_M_Japan) || 
		(standard_video == EMhwlibTVStandard_PAL_60) || 
		(standard_video == EMhwlibTVStandard_PAL_M) || 
		(standard_video == EMhwlibTVStandard_PAL_BG) || 
		(standard_video == EMhwlibTVStandard_PAL_N) 
	) {
		disp_route.Enable = TRUE;
		disp_route.SourceModuleID = mixer_video;
		disp_route.DestinationModuleID = slave_video;
		DCCSP(pDCC->pRUA, routing, RMDispRoutingPropertyID_Route, &disp_route, sizeof(disp_route));
	}
	
	DCCSP(pDCC->pRUA, routing, RMGenericPropertyID_Validate, NULL, 0);
	
	enable = TRUE;
	DCCSP(pDCC->pRUA, routing, RMGenericPropertyID_Enable, &enable, sizeof(enable));
	
	return RM_OK;
}

RMstatus DCCSetTVFormat(struct DCC *pDCC, enum DCCRoute route, struct EMhwlibTVFormatDigital *fmt_d, struct EMhwlibTVFormatAnalog *fmt_a)
{
	RMbool enable;
	RMuint32 slave, slave2, slave3, master, mixer=0;
	RMuint32 bus_size = 24;
	enum EMhwlibColorSpace colorspace;
	RMuint32 routing = EMHWLIB_MODULE(DispRouting, 0); 
	struct DispRouting_Route_type disp_route;