int packets_SourceProductInfoFrame(u16 baseAddr, const u8 * vName, u8 vLength, const u8 * pName, u8 pLength, u8 code, u8 autoSend) { const unsigned short pSize = 8; const unsigned short vSize = 16; LOG_TRACE(); halFrameComposerPackets_AutoSend(baseAddr + FC_BASE_ADDR, 0, SPD_TX); /* prevent sending half the info. */ if (vName == 0) { error_Set(ERR_INVALID_PARAM_VENDOR_NAME); LOG_WARNING("invalid parameter"); return FALSE; } if (vLength > vSize) { vLength = vSize; LOG_WARNING("vendor name truncated"); } if (pName == 0) { error_Set(ERR_INVALID_PARAM_PRODUCT_NAME); LOG_WARNING("invalid parameter"); return FALSE; } if (pLength > pSize) { pLength = pSize; LOG_WARNING("product name truncated"); } halFrameComposerSpd_VendorName(baseAddr + FC_BASE_ADDR, vName, vLength); halFrameComposerSpd_ProductName(baseAddr + FC_BASE_ADDR, pName, pLength); halFrameComposerSpd_SourceDeviceInfo(baseAddr + FC_BASE_ADDR, code); if (autoSend) { halFrameComposerPackets_AutoSend(baseAddr + FC_BASE_ADDR, autoSend, SPD_TX); } else { halFrameComposerPackets_ManualSend(baseAddr + FC_BASE_ADDR, SPD_TX); } return TRUE; }
int dtd_SetPixelRepetitionInput(dtd_t *dtd, u16 value) { LOG_TRACE(); switch (dtd->mCode) { case (u8)-1: case 10: case 11: case 12: case 13: case 25: case 26: case 27: case 28: if (value < 10) { dtd->mPixelRepetitionInput = value; return TRUE; } break; case 14: case 15: case 29: case 30: if (value < 2) { dtd->mPixelRepetitionInput = value; return TRUE; } break; case 35: case 36: case 37: case 38: if (value < 2 || value == 3) { dtd->mPixelRepetitionInput = value; return TRUE; } break; default: if (value == dtd->mPixelRepetitionInput) { return TRUE; } break; } error_Set(ERR_PIXEL_REPETITION_FOR_VIDEO_MODE); LOG_ERROR3("Invalid pixel repetition input for video mode", value, dtd->mCode); return FALSE; }
int api_Reinitialize(u16 address, u8 dataEnablePolarity, u16 sfrClock, u8 force) //cmd:auto argument: 0, 1, 2500, 0 { dataEnablePolarity = 1; api_mDataEnablePolarity = dataEnablePolarity; api_mHpd = FALSE; api_mSendGamutOk = FALSE; //????????????????? api_mSfrClock = sfrClock; // sfrClock,that are required for setting the low time of the SCL clock in each speed mode LOG_NOTICE("dwc_hdmi_tx_software_api_2.12"); LOG_NOTICE(__DATE__); LOG_TRACE1(dataEnablePolarity); /* reset error */ error_Set(NO_ERROR); api_mBaseAddress = address; if (!api_mutex_inited) { mutex_Initialize(&api_mMutex); api_mutex_inited = 1; } if ((api_mCurrentState < API_HPD) || (api_mCurrentState > API_EDID_READ)) { /* if EDID read do not re-read, if HPDetected, keep in same state * otherwise, set to INIT */ api_mCurrentState = API_INIT; } if (system_InterruptHandlerRegister(TX_INT, api_EventHandler, NULL) == TRUE) { printk("==>enable TX_INT in %s:%d\n", __func__, __LINE__); //return system_InterruptEnable(TX_INT); printk("enter %s, %d\n", __func__, __LINE__); return TRUE; } return FALSE; }
int api_Initialize(u16 address, u8 dataEnablePolarity, u16 sfrClock, u8 force) //cmd:auto argument: 0, 1, 2500, 0 { dtd_t dtd; videoParams_t params; dataEnablePolarity = 1; api_mDataEnablePolarity = dataEnablePolarity; api_mHpd = FALSE; api_mSendGamutOk = FALSE; //????????????????? api_mSfrClock = sfrClock; // sfrClock,that are required for setting the low time of the SCL clock in each speed mode LOG_NOTICE("dwc_hdmi_tx_software_api_2.12"); LOG_NOTICE(__DATE__); LOG_TRACE1(dataEnablePolarity); /* reset error */ error_Set(NO_ERROR); api_mBaseAddress = address; if (!api_mutex_inited) { mutex_Initialize(&api_mMutex); api_mutex_inited = 1; } control_InterruptMute(api_mBaseAddress, ~0); /* disable all interrupts */ if ((api_mCurrentState < API_HPD) || (api_mCurrentState > API_EDID_READ)) { /* if EDID read do not re-read, if HPDetected, keep in same state * otherwise, NOT INIT */ api_mCurrentState = API_NOT_INIT; } /* VGA must be supported by all sinks * so use it as default configuration */ dtd_Fill(&dtd, 4, 60000); videoParams_Reset(¶ms); videoParams_SetHdmi(¶ms, TRUE); videoParams_SetDtd(¶ms, &dtd); /* params->mDtd = dtd; */ pixelClock = videoParams_GetPixelClock(¶ms); /* dtd_GetPixelClock(&(params->mDtd)); */ /* reset HAPS51 DEMO BOARD, by default mask all interrupts */ if (board_Initialize(api_mBaseAddress, pixelClock, 8) != TRUE) { return FALSE; } /* get Product Identification Register 0 */ LOG_NOTICE2("Product Line", control_ProductLine(api_mBaseAddress)); /* get Product Identification Register 1*/ LOG_NOTICE2("Product Type", control_ProductType(api_mBaseAddress)); /* if ((ProductLine == 0xA0) && ((ProductType == 0x01 || ProductType == 0xC1))) */ if (control_SupportsCore(api_mBaseAddress) != TRUE) { error_Set(ERR_HW_NOT_SUPPORTED); LOG_ERROR("Unknown device: aborting..."); return FALSE; } /* get Design Identification Register */ LOG_NOTICE2("HDMI TX Controller Design", control_Design(api_mBaseAddress)); /* get Revision Identification Register */ LOG_NOTICE2("HDMI TX Controller Revision", control_Revision(api_mBaseAddress)); /* if(ProductLine == 0xA0 && ProductType == 0xC1)*/ if (control_SupportsHdcp(api_mBaseAddress) == TRUE) { LOG_NOTICE("HDMI TX controller supports HDCP"); } /* print api_mDataEnablePolarity value ,always return TRUE */ if (video_Initialize(api_mBaseAddress, ¶ms, api_mDataEnablePolarity) != TRUE) { return FALSE; } if (audio_Initialize(api_mBaseAddress) != TRUE) { return FALSE; } if (packets_Initialize(api_mBaseAddress) != TRUE) { return FALSE; } if (hdcp_Initialize(api_mBaseAddress, api_mDataEnablePolarity) != TRUE) { return FALSE; } /* clock gate == 1 => turn off all modules */ if (control_Initialize(api_mBaseAddress, api_mDataEnablePolarity, pixelClock) != TRUE) { return FALSE; } #ifdef CONFIG_HMDI_JZ4780_DEBUG printk("jz4780 hdmi %s %d phy init\n",__func__,__LINE__); #endif control_InterruptClearAll(api_mBaseAddress); if (board_PixelClock(api_mBaseAddress, pixelClock, videoParams_GetColorResolution(¶ms))!= TRUE) { return FALSE; } #ifdef CONFIG_HMDI_JZ4780_DEBUG printk("jz4780 hdmi %s %d video configured\n",__func__,__LINE_); #endif if (video_Configure(api_mBaseAddress, ¶ms, api_mDataEnablePolarity, FALSE) != TRUE) { return FALSE; } if ((api_mCurrentState < API_HPD) || (api_mCurrentState > API_EDID_READ)) { /* if EDID read do not re-read, if HPDetected, keep in same state * otherwise, set to INIT */ api_mCurrentState = API_INIT; } /* * By default no pixel repetition and color resolution is 8 */ #ifdef CONFIG_HMDI_JZ4780_DEBUG printk("jz4780 hdmi %s %d control configured\n",__func__,__LINE_); #endif if (control_Configure(api_mBaseAddress, pixelClock, 0, 8, 0, 0, 0, 0) != TRUE) { return FALSE; } /* send AVMUTE SET (optional) */ #ifdef CONFIG_HMDI_JZ4780_DEBUG printk("jz4780 hdmi %s %d phy configured\n",__func__,__LINE_); #endif #if 0 /* enable interrupts */ access_CoreWriteByte(0x0, 0x10D2); access_CoreWriteByte(0x0, 0x10D6); access_CoreWriteByte(0x0, 0x10DA); access_CoreWriteByte(0x0, 0x0180); #endif #if 0 access_CoreWriteByte(~0x4, 0x10D2); //audio packets access_CoreWriteByte(0x0, 0x0180); //intc mute #endif api_phy_enable(PHY_ENABLE_HPD); control_InterruptMute(api_mBaseAddress, 0); if (system_InterruptHandlerRegister(TX_INT, api_EventHandler, NULL) == TRUE) { printk("=====>enable TX_INT in %s:%d\n", __func__, __LINE__); //return system_InterruptEnable(TX_INT); return TRUE; } return FALSE; }
int api_Configure(videoParams_t * video, audioParams_t * audio, productParams_t * product, hdcpParams_t * hdcp) { hdmivsdb_t vsdb; // int audioOn = 0; //lltang audio on int audioOn = 1; int success = TRUE; int hdcpOn = (hdcp != 0 && (control_SupportsHdcp(api_mBaseAddress) == TRUE)) ? TRUE : FALSE; LOG_TRACE(); if (video == NULL) { error_Set(ERR_HPD_LOST); LOG_ERROR("video params invalid"); return FALSE; } audioOn = (audio != 0 && videoParams_GetHdmi(video)); if (api_mCurrentState < API_HPD) { error_Set(ERR_HPD_LOST); LOG_ERROR("cable not connected"); return FALSE; } else if (api_mCurrentState == API_HPD) { printk("E-EDID not read. Media may not be supported by sink\n"); } else if (api_mCurrentState == API_EDID_READ) { api_CheckParamsVideo(video); if (api_EdidHdmivsdb(&vsdb)) { if (!hdmivsdb_GetDeepColor30(&vsdb) && !hdmivsdb_GetDeepColor36(&vsdb) && !hdmivsdb_GetDeepColor48(&vsdb)) { videoParams_SetColorResolution(video, 0); } } } control_InterruptMute(api_mBaseAddress, ~0); /* disable interrupts */ #ifdef CONFIG_HMDI_JZ4780_DEBUG printk("=====>disable TX_INT in %s:%d\n", __func__, __LINE__); #endif system_InterruptDisable(TX_INT); do { if (video_Configure(api_mBaseAddress, video, api_mDataEnablePolarity, hdcpOn) != TRUE) { success = FALSE; break; } if (audioOn) { if (api_mCurrentState == API_EDID_READ) { api_CheckParamsAudio(audio); } #if 0 //del by lltang if (board_AudioClock(api_mBaseAddress, audioParams_AudioClock(audio)) != TRUE) { success = FALSE; break; } #endif if (audio_Configure(api_mBaseAddress, audio, videoParams_GetPixelClock( video), videoParams_GetRatioClock(video)) != TRUE) { success = FALSE; break; } packets_AudioInfoFrame(api_mBaseAddress, audio); } else if (audio != 0 && videoParams_GetHdmi(video) != TRUE) { printk("DVI mode selected: audio not configured\n"); } else { printk("No audio parameters provided: not configured\n"); } if (videoParams_GetHdmi(video) == TRUE) { if (packets_Configure(api_mBaseAddress, video, product) != TRUE) { success = FALSE; break; } api_mSendGamutOk = (videoParams_GetEncodingOut(video) == YCC444) || (videoParams_GetEncodingOut(video) == YCC422); api_mSendGamutOk = api_mSendGamutOk && (videoParams_GetColorimetry( video) == EXTENDED_COLORIMETRY); } else { printk("DVI mode selected: packets not configured\n"); } if (hdcpOn == TRUE) { /* HDCP is PHY independent */ if (hdcp_Configure(api_mBaseAddress, hdcp, videoParams_GetHdmi(video), dtd_GetHSyncPolarity(videoParams_GetDtd(video)), dtd_GetVSyncPolarity(videoParams_GetDtd(video))) == FALSE) { printk("HDCP not configured\n"); hdcpOn = FALSE; success = FALSE; break; } } else if (hdcp != 0 && control_SupportsHdcp(api_mBaseAddress) != TRUE) { printk("HDCP is not supported by hardware\n"); } else { printk("No HDCP parameters provided: not configured\n"); } if (board_PixelClock(api_mBaseAddress, videoParams_GetPixelClock(video), videoParams_GetColorResolution(video)) != TRUE) { success = FALSE; break; } if (control_Configure(api_mBaseAddress, videoParams_GetPixelClock(video), videoParams_GetPixelRepetitionFactor(video), videoParams_GetColorResolution(video), videoParams_IsColorSpaceConversion(video), audioOn, FALSE, hdcpOn) != TRUE) { success = FALSE; break; } if (phy_Configure(api_mBaseAddress, videoParams_GetPixelClock(video), videoParams_GetColorResolution(video), videoParams_GetPixelRepetitionFactor(video)) != TRUE) { success = FALSE; break; } /* disable blue screen transmission after turning on all necessary blocks (e.g. HDCP) */ if (video_ForceOutput(api_mBaseAddress, FALSE) != TRUE) { success = FALSE; break; } /* reports HPD state to HDCP */ if (hdcpOn) { hdcp_RxDetected(api_mBaseAddress, phy_HotPlugDetected( api_mBaseAddress)); } /* send AVMUTE CLEAR (optional) */ api_mCurrentState = API_CONFIGURED; } while(0); control_InterruptMute(api_mBaseAddress, 0); /* enable interrupts */ #ifdef CONFIG_HMDI_JZ4780_DEBUG printk("hdmi enable TX_INT in %s:%d\n", __func__, __LINE__); #endif system_InterruptEnable(TX_INT); return success; }
/** * Check Video parameters against allowed values and read EDID structure * to ensure compatibility with sink. * @param video video parameters */ static int api_CheckParamsVideo(videoParams_t * video) { u8 errorCode = TRUE; hdmivsdb_t vsdb; dtd_t dtd; unsigned i = 0; shortVideoDesc_t svd; videoCapabilityDataBlock_t capability; int valid = FALSE; colorimetryDataBlock_t colorimetry; LOG_TRACE(); colorimetryDataBlock_Reset(&colorimetry); shortVideoDesc_Reset(&svd); dtd_Fill(&dtd, 1, 60000); videoCapabilityDataBlock_Reset(&capability); if (videoParams_GetHdmi(video)) { /* HDMI mode */ if (api_EdidHdmivsdb(&vsdb) == TRUE) { if (videoParams_GetColorResolution(video) == 10 && !hdmivsdb_GetDeepColor30(&vsdb)) { error_Set(ERR_SINK_DOES_NOT_SUPPORT_30BIT_DC); printk("Sink does NOT support 30bits/pixel deep colour mode"); errorCode = FALSE; } else if (videoParams_GetColorResolution(video) == 12 && !hdmivsdb_GetDeepColor36(&vsdb)) { error_Set(ERR_SINK_DOES_NOT_SUPPORT_36BIT_DC); printk("Sink does NOT support 36bits/pixel deep colour mode"); errorCode = FALSE; } else if (videoParams_GetColorResolution(video) == 16 && !hdmivsdb_GetDeepColor48(&vsdb)) { error_Set(ERR_SINK_DOES_NOT_SUPPORT_48BIT_DC); printk("Sink does NOT support 48bits/pixel deep colour mode"); errorCode = FALSE; } if (videoParams_GetEncodingOut(video) == YCC444 && !hdmivsdb_GetDeepColorY444(&vsdb)) { error_Set(ERR_SINK_DOES_NOT_SUPPORT_YCC444_DC); printk("Sink does NOT support YCC444 in deep colour mode"); errorCode = FALSE; } if (videoParams_GetTmdsClock(video) > 16500) { /* * Sink must specify MaxTMDSClk when supports frequencies over 165MHz * GetMaxTMDSClk() is TMDS clock / 5MHz and GetTmdsClock() returns [0.01MHz] * so GetMaxTMDSClk() value must be multiplied by 500 in order to be compared */ if (videoParams_GetTmdsClock(video) > (hdmivsdb_GetMaxTmdsClk( &vsdb) * 500)) { error_Set(ERR_SINK_DOES_NOT_SUPPORT_TMDS_CLOCK); LOG_WARNING2("Sink does not support TMDS clock", videoParams_GetTmdsClock(video)); LOG_WARNING2("Maximum TMDS clock supported is", hdmivsdb_GetMaxTmdsClk(&vsdb) * 500); errorCode = FALSE; } } } else { error_Set(ERR_SINK_DOES_NOT_SUPPORT_HDMI); printk("Sink does not support HDMI"); errorCode = FALSE; } /* video out encoding (YCC/RGB) */ if (videoParams_GetEncodingOut(video) == YCC444 && !api_EdidSupportsYcc444()) { error_Set(ERR_SINK_DOES_NOT_SUPPORT_YCC444_ENCODING); printk("Sink does NOT support YCC444 encoding"); errorCode = FALSE; } else if (videoParams_GetEncodingOut(video) == YCC422 && !api_EdidSupportsYcc422()) { error_Set(ERR_SINK_DOES_NOT_SUPPORT_YCC422_ENCODING); printk("Sink does NOT support YCC422 encoding"); errorCode = FALSE; } /* check extended colorimetry data and if supported by sink */ if (videoParams_GetColorimetry(video) == EXTENDED_COLORIMETRY) { if (api_EdidColorimetryDataBlock(&colorimetry) == TRUE) { if (!colorimetryDataBlock_SupportsXvYcc601(&colorimetry) && videoParams_GetExtColorimetry(video) == 0) { error_Set(ERR_SINK_DOES_NOT_SUPPORT_XVYCC601_COLORIMETRY); printk("Sink does NOT support xvYcc601 extended colorimetry"); errorCode = FALSE; } else if (!colorimetryDataBlock_SupportsXvYcc709(&colorimetry) && videoParams_GetExtColorimetry(video) == 1) { error_Set(ERR_SINK_DOES_NOT_SUPPORT_XVYCC709_COLORIMETRY); printk("Sink does NOT support xvYcc709 extended colorimetry"); errorCode = FALSE; } else { error_Set(ERR_EXTENDED_COLORIMETRY_PARAMS_INVALID); printk("Invalid extended colorimetry parameters"); errorCode = FALSE; } } else { error_Set(ERR_SINK_DOES_NOT_SUPPORT_EXTENDED_COLORIMETRY); errorCode = FALSE; } } } else { /* DVI mode */ if (videoParams_GetColorResolution(video) > 8) { error_Set(ERR_COLOR_DEPTH_NOT_SUPPORTED); printk("DVI - deep color not supported"); errorCode = FALSE; } if (videoParams_GetEncodingOut(video) != RGB) { error_Set(ERR_DVI_MODE_WITH_YCC_ENCODING); printk("DVI mode does not support video encoding other than RGB"); errorCode = FALSE; } if (videoParams_IsPixelRepetition(video)) { error_Set(ERR_DVI_MODE_WITH_PIXEL_REPETITION); printk("DVI mode does not support pixel repetition"); errorCode = FALSE; } if (videoParams_GetTmdsClock(video) > 16500) { printk("Sink must support DVI dual-link"); } /* check colorimetry data */ if ((videoParams_GetColorimetry(video) == EXTENDED_COLORIMETRY)) { error_Set(ERR_DVI_MODE_WITH_EXTENDED_COLORIMETRY); printk("DVI does not support extended colorimetry"); errorCode = FALSE; } } /* * DTD check * always checking VALID to minimise code execution (following probability) * this video code is to be supported by all dtv's */ valid = (dtd_GetCode(videoParams_GetDtd(video)) == 1) ? TRUE : FALSE; if (!valid) { for (i = 0; i < api_EdidDtdCount(); i++) { api_EdidDtd(i, &dtd); if (dtd_GetCode(videoParams_GetDtd(video)) != (u8) (-1)) { if (dtd_GetCode(videoParams_GetDtd(video)) == dtd_GetCode(&dtd)) { valid = TRUE; break; } } else if (dtd_IsEqual(videoParams_GetDtd(video), &dtd)) { valid = TRUE; break; } } } if (!valid) { if (dtd_GetCode(videoParams_GetDtd(video)) != (u8) (-1)) { for (i = 0; i < api_EdidSvdCount(); i++) { api_EdidSvd(i, &svd); if ((unsigned) (dtd_GetCode(videoParams_GetDtd(video))) == shortVideoDesc_GetCode(&svd)) { valid = TRUE; break; } } } } if (!valid) { error_Set(ERR_SINK_DOES_NOT_SUPPORT_SELECTED_DTD); printk("Sink does NOT indicate support for selected DTD"); errorCode = FALSE; } /* check quantization range */ if (api_EdidVideoCapabilityDataBlock(&capability) == TRUE) { if (!videoCapabilityDataBlock_GetQuantizationRangeSelectable( &capability) && videoParams_GetRgbQuantizationRange(video) > 1) { printk("Sink does NOT indicate support for selected quantization range"); } } return errorCode; }
/** * Check audio parameters against read EDID structure to ensure * compatibility with sink. * @param audio audio parameters data structure */ static int api_CheckParamsAudio(audioParams_t * audio) { unsigned i = 0; int bitSupport = -1; shortAudioDesc_t sad; speakerAllocationDataBlock_t allocation; u8 errorCode = TRUE; int valid = FALSE; /* array to translate from AudioInfoFrame code to EDID Speaker Allocation data block bits */ const u8 sadb[] = { 1, 3, 5, 7, 17, 19, 21, 23, 9, 11, 13, 15, 25, 27, 29, 31, 73, 75, 77, 79, 33, 35, 37, 39, 49, 51, 53, 55, 41, 43, 45, 47 }; LOG_TRACE(); if (!api_EdidSupportsBasicAudio()) { error_Set(ERR_SINK_DOES_NOT_SUPPORT_AUDIO); printk("Sink does NOT support audio"); return FALSE; } /* check if audio type supported */ for (i = 0; i < api_EdidSadCount(); i++) { api_EdidSad(i, &sad); if (audioParams_GetCodingType(audio) == shortAudioDesc_GetFormatCode( &sad)) { bitSupport = i; break; } } if (bitSupport >= 0) { api_EdidSad(bitSupport, &sad); /* 192 kHz| 176.4 kHz| 96 kHz| 88.2 kHz| 48 kHz| 44.1 kHz| 32 kHz */ switch (audioParams_GetSamplingFrequency(audio)) { case 32000: valid = shortAudioDesc_Support32k(&sad); break; case 44100: valid = shortAudioDesc_Support44k1(&sad); break; case 48000: valid = shortAudioDesc_Support48k(&sad); break; case 88200: valid = shortAudioDesc_Support88k2(&sad); break; case 96000: valid = shortAudioDesc_Support96k(&sad); break; case 176400: valid = shortAudioDesc_Support176k4(&sad); break; case 192000: valid = shortAudioDesc_Support192k(&sad); break; default: valid = FALSE; break; } if (!valid) { error_Set(ERR_SINK_DOES_NOT_SUPPORT_AUDIO_SAMPLING_FREQ); LOG_WARNING2("Sink does NOT support audio sampling frequency", audioParams_GetSamplingFrequency(audio)); errorCode = FALSE; } if (audioParams_GetCodingType(audio) == PCM) { /* 24 bit| 20 bit| 16 bit */ switch (audioParams_GetSampleSize(audio)) { case 16: valid = shortAudioDesc_Support16bit(&sad); break; case 20: valid = shortAudioDesc_Support20bit(&sad); break; case 24: valid = shortAudioDesc_Support24bit(&sad); break; default: valid = FALSE; break; } if (!valid) { error_Set(ERR_SINK_DOES_NOT_SUPPORT_AUDIO_SAMPLE_SIZE); LOG_WARNING2("Sink does NOT support audio sample size", audioParams_GetSampleSize(audio)); errorCode = FALSE; } } /* check Speaker Allocation */ if (api_EdidSpeakerAllocationDataBlock(&allocation) == TRUE) { LOG_DEBUG2("Audio channel allocation sent", sadb[audioParams_GetChannelAllocation(audio)]); LOG_DEBUG2("Audio channel allocation accepted", speakerAllocationDataBlock_GetSpeakerAllocationByte(&allocation)); valid = (sadb[audioParams_GetChannelAllocation(audio)] & speakerAllocationDataBlock_GetSpeakerAllocationByte( &allocation)) == sadb[audioParams_GetChannelAllocation(audio)]; if (!valid) { error_Set(ERR_SINK_DOES_NOT_SUPPORT_ATTRIBUTED_CHANNELS); printk("Sink does NOT have attributed speakers"); errorCode = FALSE; } } } else { error_Set(ERR_SINK_DOES_NOT_SUPPORT_AUDIO_TYPE); printk("Sink does NOT support audio type"); errorCode = FALSE; } return errorCode; }
int packets_Configure(u16 baseAddr, videoParams_t * video, productParams_t * prod) { u8 send3d = FALSE; LOG_TRACE(); if (videoParams_GetHdmiVideoFormat(video) == 2) { if (videoParams_Get3dStructure(video) == 6 || videoParams_Get3dStructure(video) == 8) { u8 data[3]; data[0] = videoParams_GetHdmiVideoFormat(video) << 5; data[1] = videoParams_Get3dStructure(video) << 4; data[2] = videoParams_Get3dExtData(video) << 4; packets_VendorSpecificInfoFrame(baseAddr, 0x000C03, data, sizeof(data), 1); /* HDMI Licensing, LLC */ send3d = TRUE; } else { LOG_ERROR2("3D structure not supported", videoParams_Get3dStructure(video)); error_Set(ERR_3D_STRUCT_NOT_SUPPORTED); return FALSE; } } if (prod != 0) { if (productParams_IsSourceProductValid(prod)) { packets_SourceProductInfoFrame(baseAddr, productParams_GetVendorName(prod), productParams_GetVendorNameLength(prod), productParams_GetProductName(prod), productParams_GetProductNameLength(prod), productParams_GetSourceType(prod), 1); } if (productParams_IsVendorSpecificValid(prod)) { if (send3d) { LOG_WARNING("forcing Vendor Specific InfoFrame, 3D configuration will be ignored"); error_Set(ERR_FORCING_VSD_3D_IGNORED); } packets_VendorSpecificInfoFrame(baseAddr, productParams_GetOUI(prod), productParams_GetVendorPayload( prod), productParams_GetVendorPayloadLength(prod), 1); } } else { LOG_WARNING("No product info provided: not configured"); } /* set values that shall not change */ halFrameComposerPackets_MetadataFrameInterpolation(baseAddr + FC_BASE_ADDR, 1); halFrameComposerPackets_MetadataFramesPerPacket(baseAddr + FC_BASE_ADDR, 1); halFrameComposerPackets_MetadataLineSpacing(baseAddr + FC_BASE_ADDR, 1); halFrameComposerGcp_DefaultPhase(baseAddr + FC_BASE_ADDR, videoParams_GetPixelPackingDefaultPhase(video) == 1); /* default phase 1 = true */ halFrameComposerGamut_Profile(baseAddr + FC_BASE_ADDR + 0x100, 0x0); /* P0 */ halFrameComposerGamut_PacketsPerFrame(baseAddr + FC_BASE_ADDR + 0x100, 0x1); /* P0 */ halFrameComposerGamut_PacketLineSpacing(baseAddr + FC_BASE_ADDR + 0x100, 0x1); packets_AuxiliaryVideoInfoFrame(baseAddr, video); return TRUE; }
u8 edid_ParseDataBlock(u16 baseAddr, u8 * data) { u8 tag = bitOperation_BitField(data[0], 5, 3); u8 length = bitOperation_BitField(data[0], 0, 5); u8 c = 0; shortAudioDesc_t tmpSad; shortVideoDesc_t tmpSvd; LOG_TRACE3("TAG", tag, length); switch (tag) { case 0x1: /* Audio Data Block */ for (c = 1; c < (length + 1); c += 3) { shortAudioDesc_Parse(&tmpSad, data + c); if (edid_mSadIndex < (sizeof(edid_mSad) / sizeof(shortAudioDesc_t))) { edid_mSad[edid_mSadIndex++] = tmpSad; } else { error_Set(ERR_SHORT_AUDIO_DESC_BUFFER_FULL); LOG_WARNING("buffer full - SAD ignored"); } } break; case 0x2: /* Video Data Block */ for (c = 1; c < (length + 1); c++) { shortVideoDesc_Parse(&tmpSvd, data[c]); if (edid_mSvdIndex < (sizeof(edid_mSvd) / sizeof(shortVideoDesc_t))) { edid_mSvd[edid_mSvdIndex++] = tmpSvd; } else { error_Set(ERR_SHORT_VIDEO_DESC_BUFFER_FULL); LOG_WARNING("buffer full - SVD ignored"); } } break; case 0x3: /* Vendor Specific Data Block */ { u32 ieeeId = bitOperation_Bytes2Dword(0x00, data[3], data[2], data[1]); if (ieeeId == 0x000C03) { /* HDMI */ if (hdmivsdb_Parse(&edid_mHdmivsdb, data) != TRUE) { LOG_WARNING("HDMI Vendor Specific Data Block corrupt"); } } else { LOG_WARNING2("Vendor Specific Data Block not parsed", ieeeId); } break; } case 0x4: /* Speaker Allocation Data Block */ if (speakerAllocationDataBlock_Parse(&edid_mSpeakerAllocationDataBlock, data) != TRUE) { LOG_WARNING("Speaker Allocation Data Block corrupt"); } break; case 0x7: { u8 extendedTag = data[1]; switch (extendedTag) { case 0x00: /* Video Capability Data Block */ if (videoCapabilityDataBlock_Parse(&edid_mVideoCapabilityDataBlock, data) != TRUE) { LOG_WARNING("Video Capability Data Block corrupt"); } break; case 0x05: /* Colorimetry Data Block */ if (colorimetryDataBlock_Parse(&edid_mColorimetryDataBlock, data) != TRUE) { LOG_WARNING("Colorimetry Data Block corrupt"); } break; case 0x04: /* HDMI Video Data Block */ case 0x12: /* HDMI Audio Data Block */ break; default: LOG_WARNING2("Extended Data Block not parsed", extendedTag); break; } break; } default: LOG_WARNING2("Data Block not parsed", tag); break; } return length + 1; }
int edid_ParseBlock(u16 baseAddr, u8 * buffer) { const unsigned DTD_SIZE = 0x12; const unsigned TIMING_MODES = 0x36; dtd_t tmpDtd; unsigned c = 0; unsigned i = 0; LOG_TRACE(); if (edid_mCurrBlockNo == 0) { if (buffer[0] == 0x00) { /* parse block zero */ edid_mBlocksNo = buffer[126] + 1; /* parse DTD's */ for (i = TIMING_MODES; i < (TIMING_MODES + (DTD_SIZE * 4)); i += DTD_SIZE) { if (bitOperation_Bytes2Word(buffer[i + 1], buffer[i + 0]) > 0) { if (dtd_Parse(&tmpDtd, buffer + i) == TRUE) { if (edid_mDtdIndex < (sizeof(edid_mDtd) / sizeof(dtd_t))) { edid_mDtd[edid_mDtdIndex++] = tmpDtd; } else { error_Set(ERR_DTD_BUFFER_FULL); LOG_WARNING("buffer full - DTD ignored"); } } else { LOG_WARNING("DTD corrupt"); } } else if ((buffer[i + 2] == 0) && (buffer[i + 4] == 0)) { /* it is a Display-monitor Descriptor */ if (buffer[i + 3] == 0xFC) { /* Monitor Name */ for (c = 0; c < 13; c++) { edid_mMonitorName[c] = buffer[i + c + 5]; } } else if (buffer[i + 3] == 0xFD) { /* Monitor Range Limits */ if (monitorRangeLimits_Parse(&edid_mMonitorRangeLimits, buffer + i) != TRUE) { LOG_WARNING2("Monitor Range Limits corrupt", i); } } } } } } else if (buffer[0] == 0xF0) { /* Block Map Extension */ /* last is checksum */ for (i = 1; i < (sizeof(edid_mBuffer) - 1); i++) { if (buffer[i] == 0x00) { break; } } if (edid_mBlocksNo < 128) { if (i > edid_mBlocksNo) { /* N (no of extensions) does NOT include Block maps */ edid_mBlocksNo += 2; } else if (i == edid_mBlocksNo) { edid_mBlocksNo += 1; } } else { i += 127; if (i > edid_mBlocksNo) { /* N (no of extensions) does NOT include Block maps */ edid_mBlocksNo += 3; } else if (i == edid_mBlocksNo) { edid_mBlocksNo += 1; } } } else if (buffer[0] == 0x02) { /* CEA Extension block */ if (buffer[1] == 0x03) { /* revision number (only rev3 is allowed by HDMI spec) */ u8 offset = buffer[2]; edid_mYcc422Support = bitOperation_BitField(buffer[3], 4, 1) == 1; edid_mYcc444Support = bitOperation_BitField(buffer[3], 5, 1) == 1; edid_mBasicAudioSupport = bitOperation_BitField(buffer[3], 6, 1) == 1; edid_mUnderscanSupport = bitOperation_BitField(buffer[3], 7, 1) == 1; if (offset != 4) { for (i = 4; i < offset; i += edid_ParseDataBlock(baseAddr, buffer + i)) ; } /* last is checksum */ for (i = offset, c = 0; i < (sizeof(edid_mBuffer) - 1) && c < 6; i += DTD_SIZE, c++) { if (dtd_Parse(&tmpDtd, buffer + i) == TRUE) { if (edid_mDtdIndex < (sizeof(edid_mDtd) / sizeof(dtd_t))) { edid_mDtd[edid_mDtdIndex++] = tmpDtd; } else { error_Set(ERR_DTD_BUFFER_FULL); LOG_WARNING("buffer full - DTD ignored"); } } } } } return TRUE; }
u8 edid_EventHandler(u16 baseAddr, int hpd, u8 state) { LOG_TRACE2(hpd, state); if (edid_mStatus != EDID_READING) { return EDID_IDLE; } else if (!hpd) { /* hot plug detected without cable disconnection */ error_Set(ERR_HPD_LOST); LOG_WARNING("hpd"); edid_mStatus = EDID_ERROR; } else if ((state & BIT(0)) != 0) /* error */ { LOG_WARNING("error"); edid_mStatus = EDID_ERROR; } else if ((state & BIT(1)) != 0) /* done */ { if (edid_mCurrAddress >= sizeof(edid_mBuffer)) { error_Set(ERR_OVERFLOW); LOG_WARNING("overflow"); edid_mStatus = EDID_ERROR; } else { edid_mBuffer[edid_mCurrAddress] = halEdid_ReadData(baseAddr + I2CM_BASE_ADDR); edid_mBlockSum += edid_mBuffer[edid_mCurrAddress++]; if (edid_mCurrAddress >= sizeof(edid_mBuffer)) { /*check if checksum is correct (CEA-861 D Spec p108) */ if (edid_mBlockSum % 0x100 == 0) { LOG_NOTICE("block checksum correct"); edid_ParseBlock(baseAddr, edid_mBuffer); edid_mCurrAddress = 0; edid_mCurrBlockNo++; edid_mBlockSum = 0; if (edid_mCurrBlockNo >= edid_mBlocksNo) { edid_mStatus = EDID_DONE; } } else { error_Set(ERR_BLOCK_CHECKSUM_INVALID); LOG_WARNING("block checksum invalid"); edid_mStatus = EDID_ERROR; } } } } if (edid_mStatus == EDID_READING) { edid_ReadRequest(baseAddr, edid_mCurrAddress, edid_mCurrBlockNo); } else if (edid_mStatus == EDID_DONE) { edid_mBlocksNo = 1; edid_mCurrBlockNo = 0; edid_mCurrAddress = 0; edid_mBlockSum = 0; } return edid_mStatus; }
int dtd_Fill(dtd_t *dtd, u8 code, u32 refreshRate) { LOG_TRACE(); dtd->mCode = code; dtd->mHBorder = 0; dtd->mVBorder = 0; dtd->mPixelRepetitionInput = 0; dtd->mHImageSize = 16; dtd->mVImageSize = 9; #ifdef HDMI_JZ4780_DEBUG printk("jz4780 hmdi video code:%d\n",code); #endif switch (code) { case 1: /* 640x480p @ 59.94/60Hz 4:3 */ dtd->mHImageSize = 4; dtd->mVImageSize = 3; dtd->mHActive = 640; dtd->mVActive = 480; dtd->mHBlanking = 160; dtd->mVBlanking = 45; dtd->mHSyncOffset = 16; dtd->mVSyncOffset = 10; dtd->mHSyncPulseWidth = 96; dtd->mVSyncPulseWidth = 2; dtd->mHSyncPolarity = dtd->mVSyncPolarity = 0; dtd->mInterlaced = 0; /* not(progressive_nI) */ dtd->mPixelClock = (refreshRate == 59940) ? 2517 : 2520; break; case 2: /* 720x480p @ 59.94/60Hz 4:3 */ dtd->mHImageSize = 4; dtd->mVImageSize = 3; case 3: /* 720x480p @ 59.94/60Hz 16:9 */ dtd->mHActive = 720; dtd->mVActive = 480; dtd->mHBlanking = 138; dtd->mVBlanking = 45; dtd->mHSyncOffset = 16; dtd->mVSyncOffset = 9; dtd->mHSyncPulseWidth = 62; dtd->mVSyncPulseWidth = 6; dtd->mHSyncPolarity = dtd->mVSyncPolarity = 0; dtd->mInterlaced = 0; //dtd->mPixelClock = (refreshRate == 59940) ? 2700 : 2702; dtd->mPixelClock = (refreshRate == 59940) ? 2700 : 2700; break; case 4: /* 1280x720p @ 59.94/60Hz 16:9 */ dtd->mHActive = 1280; dtd->mVActive = 720; dtd->mHBlanking = 370; dtd->mVBlanking = 30; dtd->mHSyncOffset = 110; dtd->mVSyncOffset = 5; dtd->mHSyncPulseWidth = 40; dtd->mVSyncPulseWidth = 5; dtd->mHSyncPolarity = dtd->mVSyncPolarity = 1; dtd->mInterlaced = 0; dtd->mPixelClock = (refreshRate == 59940) ? 7417 : 7425; break; case 5: /* 1920x1080i @ 59.94/60Hz 16:9 */ dtd->mHActive = 1920; dtd->mVActive = 540; dtd->mHBlanking = 280; dtd->mVBlanking = 22; dtd->mHSyncOffset = 88; dtd->mVSyncOffset = 2; dtd->mHSyncPulseWidth = 44; dtd->mVSyncPulseWidth = 5; dtd->mHSyncPolarity = dtd->mVSyncPolarity = 1; dtd->mInterlaced = 1; dtd->mPixelClock = (refreshRate == 59940) ? 7417 : 7425; break; case 6: /* 720(1440)x480i @ 59.94/60Hz 4:3 */ dtd->mHImageSize = 4; dtd->mVImageSize = 3; case 7: /* 720(1440)x480i @ 59.94/60Hz 16:9 */ dtd->mHActive = 1440; dtd->mVActive = 240; dtd->mHBlanking = 276; dtd->mVBlanking = 22; dtd->mHSyncOffset = 38; dtd->mVSyncOffset = 4; dtd->mHSyncPulseWidth = 124; dtd->mVSyncPulseWidth = 3; dtd->mHSyncPolarity = dtd->mVSyncPolarity = 0; dtd->mInterlaced = 1; dtd->mPixelClock = (refreshRate == 59940) ? 2700 : 2702; dtd->mPixelRepetitionInput = 1; break; case 8: /* 720(1440)x240p @ 59.826/60.054/59.886/60.115Hz 4:3 */ dtd->mHImageSize = 4; dtd->mVImageSize = 3; case 9: /* 720(1440)x240p @ 59.826/60.054/59.886/60.115Hz 16:9 */ dtd->mHActive = 1440; dtd->mVActive = 240; dtd->mHBlanking = 276; dtd->mVBlanking = (refreshRate > 60000) ? 22 : 23; dtd->mHSyncOffset = 38; dtd->mVSyncOffset = (refreshRate > 60000) ? 4 : 5; dtd->mHSyncPulseWidth = 124; dtd->mVSyncPulseWidth = 3; dtd->mHSyncPolarity = dtd->mVSyncPolarity = 0; dtd->mInterlaced = 0; dtd->mPixelClock = ((refreshRate == 60054) || refreshRate == 59826) ? 2700 : 2702; /* else 60.115/59.886 Hz */ dtd->mPixelRepetitionInput = 1; break; case 10: /* 2880x480i @ 59.94/60Hz 4:3 */ dtd->mHImageSize = 4; dtd->mVImageSize = 3; case 11: /* 2880x480i @ 59.94/60Hz 16:9 */ dtd->mHActive = 2880; dtd->mVActive = 240; dtd->mHBlanking = 552; dtd->mVBlanking = 22; dtd->mHSyncOffset = 76; dtd->mVSyncOffset = 4; dtd->mHSyncPulseWidth = 248; dtd->mVSyncPulseWidth = 3; dtd->mHSyncPolarity = dtd->mVSyncPolarity = 0; dtd->mInterlaced = 1; dtd->mPixelClock = (refreshRate == 59940) ? 5400 : 5405; break; case 12: /* 2880x240p @ 59.826/60.054/59.886/60.115Hz 4:3 */ dtd->mHImageSize = 4; dtd->mVImageSize = 3; case 13: /* 2880x240p @ 59.826/60.054/59.886/60.115Hz 16:9 */ dtd->mHActive = 2880; dtd->mVActive = 240; dtd->mHBlanking = 552; dtd->mVBlanking = (refreshRate > 60000) ? 22 : 23; dtd->mHSyncOffset = 76; dtd->mVSyncOffset = (refreshRate > 60000) ? 4 : 5; dtd->mHSyncPulseWidth = 248; dtd->mVSyncPulseWidth = 3; dtd->mHSyncPolarity = dtd->mVSyncPolarity = 0; dtd->mInterlaced = 0; dtd->mPixelClock = ((refreshRate == 60054) || refreshRate == 59826) ? 5400 : 5405; /* else 60.115/59.886 Hz */ break; case 14: /* 1440x480p @ 59.94/60Hz 4:3 */ dtd->mHImageSize = 4; dtd->mVImageSize = 3; case 15: /* 1440x480p @ 59.94/60Hz 16:9 */ dtd->mHActive = 1440; dtd->mVActive = 480; dtd->mHBlanking = 276; dtd->mVBlanking = 45; dtd->mHSyncOffset = 32; dtd->mVSyncOffset = 9; dtd->mHSyncPulseWidth = 124; dtd->mVSyncPulseWidth = 6; dtd->mHSyncPolarity = dtd->mVSyncPolarity = 0; dtd->mInterlaced = 0; dtd->mPixelClock = (refreshRate == 59940) ? 5400 : 5405; break; case 16: /* 1920x1080p @ 59.94/60Hz 16:9 */ dtd->mHActive = 1920; dtd->mVActive = 1080; dtd->mHBlanking = 280; dtd->mVBlanking = 45; dtd->mHSyncOffset = 88; dtd->mVSyncOffset = 4; dtd->mHSyncPulseWidth = 44; dtd->mVSyncPulseWidth = 5; dtd->mHSyncPolarity = dtd->mVSyncPolarity = 1; dtd->mInterlaced = 0; dtd->mPixelClock = (refreshRate == 59940) ? 14835 : 14850; break; case 17: /* 720x576p @ 50Hz 4:3 */ dtd->mHImageSize = 4; dtd->mVImageSize = 3; case 18: /* 720x576p @ 50Hz 16:9 */ dtd->mHActive = 720; dtd->mVActive = 576; dtd->mHBlanking = 144; dtd->mVBlanking = 49; dtd->mHSyncOffset = 12; dtd->mVSyncOffset = 5; dtd->mHSyncPulseWidth = 64; dtd->mVSyncPulseWidth = 5; dtd->mHSyncPolarity = dtd->mVSyncPolarity = 0; dtd->mInterlaced = 0; dtd->mPixelClock = 2700; break; case 19: /* 1280x720p @ 50Hz 16:9 */ dtd->mHActive = 1280; dtd->mVActive = 720; dtd->mHBlanking = 700; dtd->mVBlanking = 30; dtd->mHSyncOffset = 440; dtd->mVSyncOffset = 5; dtd->mHSyncPulseWidth = 40; dtd->mVSyncPulseWidth = 5; dtd->mHSyncPolarity = dtd->mVSyncPolarity = 1; dtd->mInterlaced = 0; dtd->mPixelClock = 7425; break; case 20: /* 1920x1080i @ 50Hz 16:9 */ dtd->mHActive = 1920; dtd->mVActive = 540; dtd->mHBlanking = 720; dtd->mVBlanking = 22; dtd->mHSyncOffset = 528; dtd->mVSyncOffset = 2; dtd->mHSyncPulseWidth = 44; dtd->mVSyncPulseWidth = 5; dtd->mHSyncPolarity = dtd->mVSyncPolarity = 1; dtd->mInterlaced = 1; dtd->mPixelClock = 7425; break; case 21: /* 720(1440)x576i @ 50Hz 4:3 */ dtd->mHImageSize = 4; dtd->mVImageSize = 3; case 22: /* 720(1440)x576i @ 50Hz 16:9 */ dtd->mHActive = 1440; dtd->mVActive = 288; dtd->mHBlanking = 288; dtd->mVBlanking = 24; dtd->mHSyncOffset = 24; dtd->mVSyncOffset = 2; dtd->mHSyncPulseWidth = 126; dtd->mVSyncPulseWidth = 3; dtd->mHSyncPolarity = dtd->mVSyncPolarity = 0; dtd->mInterlaced = 1; dtd->mPixelClock = 2700; dtd->mPixelRepetitionInput = 1; break; case 23: /* 720(1440)x288p @ 50Hz 4:3 */ dtd->mHImageSize = 4; dtd->mVImageSize = 3; case 24: /* 720(1440)x288p @ 50Hz 16:9 */ dtd->mHActive = 1440; dtd->mVActive = 288; dtd->mHBlanking = 288; dtd->mVBlanking = (refreshRate == 50080) ? 24 : ((refreshRate == 49920) ? 25 : 26); dtd->mHSyncOffset = 24; dtd->mVSyncOffset = (refreshRate == 50080) ? 2 : ((refreshRate == 49920) ? 3 : 4); dtd->mHSyncPulseWidth = 126; dtd->mVSyncPulseWidth = 3; dtd->mHSyncPolarity = dtd->mVSyncPolarity = 0; dtd->mInterlaced = 0; dtd->mPixelClock = 2700; dtd->mPixelRepetitionInput = 1; break; case 25: /* 2880x576i @ 50Hz 4:3 */ dtd->mHImageSize = 4; dtd->mVImageSize = 3; case 26: /* 2880x576i @ 50Hz 16:9 */ dtd->mHActive = 2880; dtd->mVActive = 288; dtd->mHBlanking = 576; dtd->mVBlanking = 24; dtd->mHSyncOffset = 48; dtd->mVSyncOffset = 2; dtd->mHSyncPulseWidth = 252; dtd->mVSyncPulseWidth = 3; dtd->mHSyncPolarity = dtd->mVSyncPolarity = 0; dtd->mInterlaced = 1; dtd->mPixelClock = 5400; break; case 27: /* 2880x288p @ 50Hz 4:3 */ dtd->mHImageSize = 4; dtd->mVImageSize = 3; case 28: /* 2880x288p @ 50Hz 16:9 */ dtd->mHActive = 2880; dtd->mVActive = 288; dtd->mHBlanking = 576; dtd->mVBlanking = (refreshRate == 50080) ? 24 : ((refreshRate == 49920) ? 25 : 26); dtd->mHSyncOffset = 48; dtd->mVSyncOffset = (refreshRate == 50080) ? 2 : ((refreshRate == 49920) ? 3 : 4); dtd->mHSyncPulseWidth = 252; dtd->mVSyncPulseWidth = 3; dtd->mHSyncPolarity = dtd->mVSyncPolarity = 0; dtd->mInterlaced = 0; dtd->mPixelClock = 5400; break; case 29: /* 1440x576p @ 50Hz 4:3 */ dtd->mHImageSize = 4; dtd->mVImageSize = 3; case 30: /* 1440x576p @ 50Hz 16:9 */ dtd->mHActive = 1440; dtd->mVActive = 576; dtd->mHBlanking = 288; dtd->mVBlanking = 49; dtd->mHSyncOffset = 24; dtd->mVSyncOffset = 5; dtd->mHSyncPulseWidth = 128; dtd->mVSyncPulseWidth = 5; dtd->mHSyncPolarity = dtd->mVSyncPolarity = 0; dtd->mInterlaced = 0; dtd->mPixelClock = 5400; break; case 31: /* 1920x1080p @ 50Hz 16:9 */ dtd->mHActive = 1920; dtd->mVActive = 1080; dtd->mHBlanking = 720; dtd->mVBlanking = 45; dtd->mHSyncOffset = 528; dtd->mVSyncOffset = 4; dtd->mHSyncPulseWidth = 44; dtd->mVSyncPulseWidth = 5; dtd->mHSyncPolarity = dtd->mVSyncPolarity = 1; dtd->mInterlaced = 0; dtd->mPixelClock = 14850; break; case 32: /* 1920x1080p @ 23.976/24Hz 16:9 */ dtd->mHActive = 1920; dtd->mVActive = 1080; dtd->mHBlanking = 830; dtd->mVBlanking = 45; dtd->mHSyncOffset = 638; dtd->mVSyncOffset = 4; dtd->mHSyncPulseWidth = 44; dtd->mVSyncPulseWidth = 5; dtd->mHSyncPolarity = dtd->mVSyncPolarity = 1; dtd->mInterlaced = 0; dtd->mPixelClock = (refreshRate == 23976) ? 7417 : 7425; break; case 33: /* 1920x1080p @ 25Hz 16:9 */ dtd->mHActive = 1920; dtd->mVActive = 1080; dtd->mHBlanking = 720; dtd->mVBlanking = 45; dtd->mHSyncOffset = 528; dtd->mVSyncOffset = 4; dtd->mHSyncPulseWidth = 44; dtd->mVSyncPulseWidth = 5; dtd->mHSyncPolarity = dtd->mVSyncPolarity = 1; dtd->mInterlaced = 0; dtd->mPixelClock = 7425; break; case 34: /* 1920x1080p @ 29.97/30Hz 16:9 */ dtd->mHActive = 1920; dtd->mVActive = 1080; dtd->mHBlanking = 280; dtd->mVBlanking = 45; dtd->mHSyncOffset = 88; dtd->mVSyncOffset = 4; dtd->mHSyncPulseWidth = 44; dtd->mVSyncPulseWidth = 5; dtd->mHSyncPolarity = dtd->mVSyncPolarity = 1; dtd->mInterlaced = 0; dtd->mPixelClock = (refreshRate == 29970) ? 7417 : 7425; break; case 35: /* 2880x480p @ 60Hz 4:3 */ dtd->mHImageSize = 4; dtd->mVImageSize = 3; case 36: /* 2880x480p @ 60Hz 16:9 */ dtd->mHActive = 2880; dtd->mVActive = 480; dtd->mHBlanking = 552; dtd->mVBlanking = 45; dtd->mHSyncOffset = 64; dtd->mVSyncOffset = 9; dtd->mHSyncPulseWidth = 248; dtd->mVSyncPulseWidth = 6; dtd->mHSyncPolarity = dtd->mVSyncPolarity = 0; dtd->mInterlaced = 0; dtd->mPixelClock = (refreshRate == 59940) ? 10800 : 10810; break; case 37: /* 2880x576p @ 50Hz 4:3 */ dtd->mHImageSize = 4; dtd->mVImageSize = 3; case 38: /* 2880x576p @ 50Hz 16:9 */ dtd->mHActive = 2880; dtd->mVActive = 576; dtd->mHBlanking = 576; dtd->mVBlanking = 49; dtd->mHSyncOffset = 48; dtd->mVSyncOffset = 5; dtd->mHSyncPulseWidth = 256; dtd->mVSyncPulseWidth = 5; dtd->mHSyncPolarity = dtd->mVSyncPolarity = 0; dtd->mInterlaced = 0; dtd->mPixelClock = 10800; break; case 39: /* 1920x1080i (1250 total) @ 50Hz 16:9 */ dtd->mHActive = 1920; dtd->mVActive = 540; dtd->mHBlanking = 384; dtd->mVBlanking = 85; dtd->mHSyncOffset = 32; dtd->mVSyncOffset = 23; dtd->mHSyncPulseWidth = 168; dtd->mVSyncPulseWidth = 5; dtd->mHSyncPolarity = dtd->mVSyncPolarity = 1; dtd->mInterlaced = 1; dtd->mPixelClock = 7200; break; case 40: /* 1920x1080i @ 100Hz 16:9 */ dtd->mHActive = 1920; dtd->mVActive = 540; dtd->mHBlanking = 720; dtd->mVBlanking = 22; dtd->mHSyncOffset = 528; dtd->mVSyncOffset = 2; dtd->mHSyncPulseWidth = 44; dtd->mVSyncPulseWidth = 5; dtd->mHSyncPolarity = dtd->mVSyncPolarity = 1; dtd->mInterlaced = 1; dtd->mPixelClock = 14850; break; case 41: /* 1280x720p @ 100Hz 16:9 */ dtd->mHActive = 1280; dtd->mVActive = 720; dtd->mHBlanking = 700; dtd->mVBlanking = 30; dtd->mHSyncOffset = 440; dtd->mVSyncOffset = 5; dtd->mHSyncPulseWidth = 40; dtd->mVSyncPulseWidth = 5; dtd->mHSyncPolarity = dtd->mVSyncPolarity = 1; dtd->mInterlaced = 0; dtd->mPixelClock = 14850; break; case 42: /* 720x576p @ 100Hz 4:3 */ dtd->mHImageSize = 4; dtd->mVImageSize = 3; case 43: /* 720x576p @ 100Hz 16:9 */ dtd->mHActive = 720; dtd->mVActive = 576; dtd->mHBlanking = 144; dtd->mVBlanking = 49; dtd->mHSyncOffset = 12; dtd->mVSyncOffset = 5; dtd->mHSyncPulseWidth = 64; dtd->mVSyncPulseWidth = 5; dtd->mHSyncPolarity = dtd->mVSyncPolarity = 0; dtd->mInterlaced = 0; dtd->mPixelClock = 5400; break; case 44: /* 720(1440)x576i @ 100Hz 4:3 */ dtd->mHImageSize = 4; dtd->mVImageSize = 3; case 45: /* 720(1440)x576i @ 100Hz 16:9 */ dtd->mHActive = 1440; dtd->mVActive = 288; dtd->mHBlanking = 288; dtd->mVBlanking = 24; dtd->mHSyncOffset = 24; dtd->mVSyncOffset = 2; dtd->mHSyncPulseWidth = 126; dtd->mVSyncPulseWidth = 3; dtd->mHSyncPolarity = dtd->mVSyncPolarity = 0; dtd->mInterlaced = 1; dtd->mPixelClock = 5400; dtd->mPixelRepetitionInput = 1; break; case 46: /* 1920x1080i @ 119.88/120Hz 16:9 */ dtd->mHActive = 1920; dtd->mVActive = 540; dtd->mHBlanking = 288; dtd->mVBlanking = 22; dtd->mHSyncOffset = 88; dtd->mVSyncOffset = 2; dtd->mHSyncPulseWidth = 44; dtd->mVSyncPulseWidth = 5; dtd->mHSyncPolarity = dtd->mVSyncPolarity = 1; dtd->mInterlaced = 1; dtd->mPixelClock = (refreshRate == 119880) ? 14835 : 14850; break; case 47: /* 1280x720p @ 119.88/120Hz 16:9 */ dtd->mHActive = 1280; dtd->mVActive = 720; dtd->mHBlanking = 370; dtd->mVBlanking = 30; dtd->mHSyncOffset = 110; dtd->mVSyncOffset = 5; dtd->mHSyncPulseWidth = 40; dtd->mVSyncPulseWidth = 5; dtd->mHSyncPolarity = dtd->mVSyncPolarity = 1; dtd->mInterlaced = 0; dtd->mPixelClock = (refreshRate == 119880) ? 14835 : 14850; break; case 48: /* 720x480p @ 119.88/120Hz 4:3 */ dtd->mHImageSize = 4; dtd->mVImageSize = 3; case 49: /* 720x480p @ 119.88/120Hz 16:9 */ dtd->mHActive = 720; dtd->mVActive = 480; dtd->mHBlanking = 138; dtd->mVBlanking = 45; dtd->mHSyncOffset = 16; dtd->mVSyncOffset = 9; dtd->mHSyncPulseWidth = 62; dtd->mVSyncPulseWidth = 6; dtd->mHSyncPolarity = dtd->mVSyncPolarity = 0; dtd->mInterlaced = 0; dtd->mPixelClock = (refreshRate == 119880) ? 5400 : 5405; break; case 50: /* 720(1440)x480i @ 119.88/120Hz 4:3 */ dtd->mHImageSize = 4; dtd->mVImageSize = 3; case 51: /* 720(1440)x480i @ 119.88/120Hz 16:9 */ dtd->mHActive = 1440; dtd->mVActive = 240; dtd->mHBlanking = 276; dtd->mVBlanking = 22; dtd->mHSyncOffset = 38; dtd->mVSyncOffset = 4; dtd->mHSyncPulseWidth = 124; dtd->mVSyncPulseWidth = 3; dtd->mHSyncPolarity = dtd->mVSyncPolarity = 0; dtd->mInterlaced = 1; dtd->mPixelClock = (refreshRate == 119880) ? 5400 : 5405; dtd->mPixelRepetitionInput = 1; break; case 52: /* 720X576p @ 200Hz 4:3 */ dtd->mHImageSize = 4; dtd->mVImageSize = 3; case 53: /* 720X576p @ 200Hz 16:9 */ dtd->mHActive = 720; dtd->mVActive = 576; dtd->mHBlanking = 144; dtd->mVBlanking = 49; dtd->mHSyncOffset = 12; dtd->mVSyncOffset = 5; dtd->mHSyncPulseWidth = 64; dtd->mVSyncPulseWidth = 5; dtd->mHSyncPolarity = dtd->mVSyncPolarity = 0; dtd->mInterlaced = 0; dtd->mPixelClock = 10800; break; case 54: /* 720(1440)x576i @ 200Hz 4:3 */ dtd->mHImageSize = 4; dtd->mVImageSize = 3; case 55: /* 720(1440)x576i @ 200Hz 16:9 */ dtd->mHActive = 1440; dtd->mVActive = 288; dtd->mHBlanking = 288; dtd->mVBlanking = 24; dtd->mHSyncOffset = 24; dtd->mVSyncOffset = 2; dtd->mHSyncPulseWidth = 126; dtd->mVSyncPulseWidth = 3; dtd->mHSyncPolarity = dtd->mVSyncPolarity = 0; dtd->mInterlaced = 1; dtd->mPixelClock = 10800; dtd->mPixelRepetitionInput = 1; break; case 56: /* 720x480p @ 239.76/240Hz 4:3 */ dtd->mHImageSize = 4; dtd->mVImageSize = 3; case 57: /* 720x480p @ 239.76/240Hz 16:9 */ dtd->mHActive = 720; dtd->mVActive = 480; dtd->mHBlanking = 138; dtd->mVBlanking = 45; dtd->mHSyncOffset = 16; dtd->mVSyncOffset = 9; dtd->mHSyncPulseWidth = 62; dtd->mVSyncPulseWidth = 6; dtd->mHSyncPolarity = dtd->mVSyncPolarity = 0; dtd->mInterlaced = 0; dtd->mPixelClock = (refreshRate == 239760) ? 10800 : 10810; break; case 58: /* 720(1440)x480i @ 239.76/240Hz 4:3 */ dtd->mHImageSize = 4; dtd->mVImageSize = 3; case 59: /* 720(1440)x480i @ 239.76/240Hz 16:9 */ dtd->mHActive = 1440; dtd->mVActive = 240; dtd->mHBlanking = 276; dtd->mVBlanking = 22; dtd->mHSyncOffset = 38; dtd->mVSyncOffset = 4; dtd->mHSyncPulseWidth = 124; dtd->mVSyncPulseWidth = 3; dtd->mHSyncPolarity = dtd->mVSyncPolarity = 0; dtd->mInterlaced = 1; dtd->mPixelClock = (refreshRate == 239760) ? 10800 : 10810; dtd->mPixelRepetitionInput = 1; break; case 60: /* 1280x720p @ 23.97/24Hz 16:9 */ dtd->mHActive = 1280; dtd->mVActive = 720; dtd->mHBlanking = 2020; dtd->mVBlanking = 30; dtd->mHSyncOffset = 1760; dtd->mVSyncOffset = 5; dtd->mHSyncPulseWidth = 40; dtd->mVSyncPulseWidth = 5; dtd->mHSyncPolarity = dtd->mVSyncPolarity = 1; dtd->mInterlaced = 0; dtd->mPixelClock = (refreshRate == 23970) ? 5934 : 5940; break; case 61: /* 1280x720p @ 25Hz 16:9 */ dtd->mHActive = 1280; dtd->mVActive = 720; dtd->mHBlanking = 2680; dtd->mVBlanking = 30; dtd->mHSyncOffset = 2420; dtd->mVSyncOffset = 5; dtd->mHSyncPulseWidth = 40; dtd->mVSyncPulseWidth = 5; dtd->mHSyncPolarity = dtd->mVSyncPolarity = 1; dtd->mInterlaced = 0; dtd->mPixelClock = 7425; break; case 62: /* 1280x720p @ 29.97/30Hz 16:9 */ dtd->mHActive = 1280; dtd->mVActive = 720; dtd->mHBlanking = 2020; dtd->mVBlanking = 30; dtd->mHSyncOffset = 1760; dtd->mVSyncOffset = 5; dtd->mHSyncPulseWidth = 40; dtd->mVSyncPulseWidth = 5; dtd->mHSyncPolarity = dtd->mVSyncPolarity = 1; dtd->mInterlaced = 0; dtd->mPixelClock = (refreshRate == 29970) ? 7417: 7425; break; case 63: /* 1920x1080p @ 119.88/120Hz 16:9 */ dtd->mHActive = 1920; dtd->mVActive = 1080; dtd->mHBlanking = 280; dtd->mVBlanking = 45; dtd->mHSyncOffset = 88; dtd->mVSyncOffset = 4; dtd->mHSyncPulseWidth = 44; dtd->mVSyncPulseWidth = 5; dtd->mHSyncPolarity = dtd->mVSyncPolarity = 1; dtd->mInterlaced = 0; dtd->mPixelClock = (refreshRate == 119880) ? 29670: 29700; break; case 64: /* 1920x1080p @ 100Hz 16:9 */ dtd->mHActive = 1920; dtd->mVActive = 1080; dtd->mHBlanking = 720; dtd->mVBlanking = 45; dtd->mHSyncOffset = 528; dtd->mVSyncOffset = 4; dtd->mHSyncPulseWidth = 44; dtd->mVSyncPulseWidth = 5; dtd->mHSyncPolarity = dtd->mVSyncPolarity = 1; dtd->mInterlaced = 0; dtd->mPixelClock = 29700; break; default: dtd->mCode = -1; error_Set(ERR_DTD_INVALID_CODE); LOG_ERROR("invalid code"); return FALSE; } return TRUE; }