X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=src%2Flib%2Fadapter%2FPulse-Eight%2FUSBCECAdapterCommands.cpp;h=b037e1cab9f9a2d0975a8dc5e8b175648141a228;hb=a5a5f6f5437c662e7f8d8e52d32e5cddacc89784;hp=bbd15d4b0b230edf42b76e0042396f35489f6ffe;hpb=2b44051cbfa70deafc30d9767323214debbc1a75;p=deb_libcec.git diff --git a/src/lib/adapter/Pulse-Eight/USBCECAdapterCommands.cpp b/src/lib/adapter/Pulse-Eight/USBCECAdapterCommands.cpp index bbd15d4..b037e1c 100644 --- a/src/lib/adapter/Pulse-Eight/USBCECAdapterCommands.cpp +++ b/src/lib/adapter/Pulse-Eight/USBCECAdapterCommands.cpp @@ -53,7 +53,9 @@ CUSBCECAdapterCommands::CUSBCECAdapterCommands(CUSBCECAdapterCommunication *comm m_settingCecVersion(CEC_VERSION_UNKNOWN), m_iSettingLAMask(0), m_bNeedsWrite(false), - m_iBuildDate(CEC_FW_BUILD_UNKNOWN) + m_iBuildDate(CEC_FW_BUILD_UNKNOWN), + m_bControlledMode(false), + m_adapterType(P8_ADAPTERTYPE_UNKNOWN) { m_persistedConfiguration.Clear(); } @@ -83,13 +85,15 @@ uint16_t CUSBCECAdapterCommands::RequestFirmwareVersion(void) while (m_persistedConfiguration.iFirmwareVersion == CEC_FW_VERSION_UNKNOWN && iFwVersionTry++ < 3) { +#ifdef CEC_DEBUGGING LIB_CEC->AddLog(CEC_LOG_DEBUG, "requesting the firmware version"); +#endif cec_datapacket response = RequestSetting(MSGCODE_FIRMWARE_VERSION); if (response.size == 2) m_persistedConfiguration.iFirmwareVersion = (response[0] << 8 | response[1]); else { - LIB_CEC->AddLog(CEC_LOG_WARNING, "the adapter did not respond with a correct firmware version (try %d)", iFwVersionTry); + LIB_CEC->AddLog(CEC_LOG_WARNING, "the adapter did not respond with a correct firmware version (try %d, size = %d)", iFwVersionTry, response.size); CEvent::Sleep(500); } } @@ -100,12 +104,18 @@ uint16_t CUSBCECAdapterCommands::RequestFirmwareVersion(void) m_persistedConfiguration.iFirmwareVersion = 1; } + // firmware versions < 2 don't have an autonomous mode + if (m_persistedConfiguration.iFirmwareVersion < 2) + m_bControlledMode = true; + return m_persistedConfiguration.iFirmwareVersion; } bool CUSBCECAdapterCommands::RequestSettingAutoEnabled(void) { +#ifdef CEC_DEBUGGING LIB_CEC->AddLog(CEC_LOG_DEBUG, "requesting autonomous mode setting"); +#endif cec_datapacket response = RequestSetting(MSGCODE_GET_AUTO_ENABLED); if (response.size == 1) @@ -119,7 +129,9 @@ bool CUSBCECAdapterCommands::RequestSettingAutoEnabled(void) bool CUSBCECAdapterCommands::RequestSettingCECVersion(void) { +#ifdef CEC_DEBUGGING LIB_CEC->AddLog(CEC_LOG_DEBUG, "requesting CEC version setting"); +#endif cec_datapacket response = RequestSetting(MSGCODE_GET_HDMI_VERSION); if (response.size == 1) @@ -131,11 +143,28 @@ bool CUSBCECAdapterCommands::RequestSettingCECVersion(void) return false; } +p8_cec_adapter_type CUSBCECAdapterCommands::RequestAdapterType(void) +{ + if (m_adapterType == P8_ADAPTERTYPE_UNKNOWN) + { +#ifdef CEC_DEBUGGING + LIB_CEC->AddLog(CEC_LOG_DEBUG, "requesting adapter type"); +#endif + + cec_datapacket response = RequestSetting(MSGCODE_GET_ADAPTER_TYPE); + if (response.size == 1) + m_adapterType = (p8_cec_adapter_type)response[0]; + } + return m_adapterType; +} + uint32_t CUSBCECAdapterCommands::RequestBuildDate(void) { if (m_iBuildDate == CEC_FW_BUILD_UNKNOWN) { +#ifdef CEC_DEBUGGING LIB_CEC->AddLog(CEC_LOG_DEBUG, "requesting firmware build date"); +#endif cec_datapacket response = RequestSetting(MSGCODE_GET_BUILDDATE); if (response.size == 4) @@ -146,7 +175,9 @@ uint32_t CUSBCECAdapterCommands::RequestBuildDate(void) bool CUSBCECAdapterCommands::RequestSettingDefaultLogicalAddress(void) { +#ifdef CEC_DEBUGGING LIB_CEC->AddLog(CEC_LOG_DEBUG, "requesting default logical address setting"); +#endif cec_datapacket response = RequestSetting(MSGCODE_GET_DEFAULT_LOGICAL_ADDRESS); if (response.size == 1) @@ -160,7 +191,9 @@ bool CUSBCECAdapterCommands::RequestSettingDefaultLogicalAddress(void) bool CUSBCECAdapterCommands::RequestSettingDeviceType(void) { +#ifdef CEC_DEBUGGING LIB_CEC->AddLog(CEC_LOG_DEBUG, "requesting device type setting"); +#endif m_persistedConfiguration.deviceTypes.Clear(); cec_datapacket response = RequestSetting(MSGCODE_GET_DEVICE_TYPE); @@ -176,7 +209,9 @@ bool CUSBCECAdapterCommands::RequestSettingDeviceType(void) bool CUSBCECAdapterCommands::RequestSettingLogicalAddressMask(void) { +#ifdef CEC_DEBUGGING LIB_CEC->AddLog(CEC_LOG_DEBUG, "requesting logical address mask setting"); +#endif cec_datapacket response = RequestSetting(MSGCODE_GET_LOGICAL_ADDRESS_MASK); if (response.size == 2) @@ -190,7 +225,9 @@ bool CUSBCECAdapterCommands::RequestSettingLogicalAddressMask(void) bool CUSBCECAdapterCommands::RequestSettingOSDName(void) { +#ifdef CEC_DEBUGGING LIB_CEC->AddLog(CEC_LOG_DEBUG, "requesting OSD name setting"); +#endif memset(m_persistedConfiguration.strDeviceName, 0, 13); cec_datapacket response = RequestSetting(MSGCODE_GET_OSD_NAME); @@ -212,7 +249,9 @@ bool CUSBCECAdapterCommands::RequestSettingOSDName(void) bool CUSBCECAdapterCommands::RequestSettingPhysicalAddress(void) { +#ifdef CEC_DEBUGGING LIB_CEC->AddLog(CEC_LOG_DEBUG, "requesting physical address setting"); +#endif cec_datapacket response = RequestSetting(MSGCODE_GET_PHYSICAL_ADDRESS); if (response.size == 2) @@ -230,10 +269,13 @@ bool CUSBCECAdapterCommands::SetSettingAutoEnabled(bool enabled) bool bReturn(false); /* check whether this value was changed */ - if (m_bSettingAutoEnabled == enabled) - return bReturn; + { + CLockObject lock(m_mutex); + if (m_bSettingAutoEnabled == enabled) + return bReturn; + m_bNeedsWrite = true; + } - m_bNeedsWrite = true; LIB_CEC->AddLog(CEC_LOG_DEBUG, "turning autonomous mode %s", enabled ? "on" : "off"); CCECAdapterMessage params; @@ -243,7 +285,10 @@ bool CUSBCECAdapterCommands::SetSettingAutoEnabled(bool enabled) delete message; if (bReturn) + { + CLockObject lock(m_mutex); m_bSettingAutoEnabled = enabled; + } return bReturn; } @@ -253,10 +298,13 @@ bool CUSBCECAdapterCommands::SetSettingDeviceType(cec_device_type type) bool bReturn(false); /* check whether this value was changed */ - if (m_persistedConfiguration.deviceTypes.types[0] == type) - return bReturn; + { + CLockObject lock(m_mutex); + if (m_persistedConfiguration.deviceTypes.types[0] == type) + return bReturn; + m_bNeedsWrite = true; + } - m_bNeedsWrite = true; LIB_CEC->AddLog(CEC_LOG_DEBUG, "setting the device type to %X (previous: %X)", (uint8_t)type, (uint8_t)m_persistedConfiguration.deviceTypes.types[0]); CCECAdapterMessage params; @@ -265,6 +313,12 @@ bool CUSBCECAdapterCommands::SetSettingDeviceType(cec_device_type type) bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED; delete message; + if (bReturn) + { + CLockObject lock(m_mutex); + m_persistedConfiguration.deviceTypes.types[0] = type; + } + return bReturn; } @@ -273,10 +327,13 @@ bool CUSBCECAdapterCommands::SetSettingDefaultLogicalAddress(cec_logical_address bool bReturn(false); /* check whether this value was changed */ - if (m_persistedConfiguration.logicalAddresses.primary == address) - return bReturn; + { + CLockObject lock(m_mutex); + if (m_persistedConfiguration.logicalAddresses.primary == address) + return bReturn; + m_bNeedsWrite = true; + } - m_bNeedsWrite = true; LIB_CEC->AddLog(CEC_LOG_DEBUG, "setting the default logical address to %X (previous: %X)", (uint8_t)address, (uint8_t)m_persistedConfiguration.logicalAddresses.primary); CCECAdapterMessage params; @@ -286,7 +343,10 @@ bool CUSBCECAdapterCommands::SetSettingDefaultLogicalAddress(cec_logical_address delete message; if (bReturn) + { + CLockObject lock(m_mutex); m_persistedConfiguration.logicalAddresses.primary = address; + } return bReturn; } @@ -296,10 +356,13 @@ bool CUSBCECAdapterCommands::SetSettingLogicalAddressMask(uint16_t iMask) bool bReturn(false); /* check whether this value was changed */ - if (m_iSettingLAMask == iMask) - return bReturn; + { + CLockObject lock(m_mutex); + if (m_iSettingLAMask == iMask) + return bReturn; + m_bNeedsWrite = true; + } - m_bNeedsWrite = true; LIB_CEC->AddLog(CEC_LOG_DEBUG, "setting the logical address mask to %2X (previous: %2X)", iMask, m_iSettingLAMask); CCECAdapterMessage params; @@ -310,7 +373,10 @@ bool CUSBCECAdapterCommands::SetSettingLogicalAddressMask(uint16_t iMask) delete message; if (bReturn) + { + CLockObject lock(m_mutex); m_iSettingLAMask = iMask; + } return bReturn; } @@ -320,10 +386,13 @@ bool CUSBCECAdapterCommands::SetSettingPhysicalAddress(uint16_t iPhysicalAddress bool bReturn(false); /* check whether this value was changed */ - if (m_persistedConfiguration.iPhysicalAddress == iPhysicalAddress) - return bReturn; + { + CLockObject lock(m_mutex); + if (m_persistedConfiguration.iPhysicalAddress == iPhysicalAddress) + return bReturn; + m_bNeedsWrite = true; + } - m_bNeedsWrite = true; LIB_CEC->AddLog(CEC_LOG_DEBUG, "setting the physical address to %04X (previous: %04X)", iPhysicalAddress, m_persistedConfiguration.iPhysicalAddress); CCECAdapterMessage params; @@ -334,7 +403,10 @@ bool CUSBCECAdapterCommands::SetSettingPhysicalAddress(uint16_t iPhysicalAddress delete message; if (bReturn) + { + CLockObject lock(m_mutex); m_persistedConfiguration.iPhysicalAddress = iPhysicalAddress; + } return bReturn; } @@ -344,10 +416,13 @@ bool CUSBCECAdapterCommands::SetSettingCECVersion(cec_version version) bool bReturn(false); /* check whether this value was changed */ - if (m_settingCecVersion == version) - return bReturn; + { + CLockObject lock(m_mutex); + if (m_settingCecVersion == version) + return bReturn; + m_bNeedsWrite = true; + } - m_bNeedsWrite = true; LIB_CEC->AddLog(CEC_LOG_DEBUG, "setting the CEC version to %s (previous: %s)", ToString(version), ToString(m_settingCecVersion)); CCECAdapterMessage params; @@ -357,7 +432,10 @@ bool CUSBCECAdapterCommands::SetSettingCECVersion(cec_version version) delete message; if (bReturn) + { + CLockObject lock(m_mutex); m_settingCecVersion = version; + } return bReturn; } @@ -387,16 +465,26 @@ bool CUSBCECAdapterCommands::SetSettingOSDName(const char *strOSDName) bool CUSBCECAdapterCommands::WriteEEPROM(void) { - if (!m_bNeedsWrite) - return true; + { + CLockObject lock(m_mutex); + if (!m_bNeedsWrite) + return true; + } LIB_CEC->AddLog(CEC_LOG_DEBUG, "writing settings in the EEPROM"); CCECAdapterMessage params; CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_WRITE_EEPROM, params); - m_bNeedsWrite = !(message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED); + bool bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED; delete message; - return m_bNeedsWrite; + + if (bReturn) + { + CLockObject lock(m_mutex); + m_bNeedsWrite = false; + } + + return bReturn; } bool CUSBCECAdapterCommands::PersistConfiguration(const libcec_configuration &configuration) @@ -480,7 +568,9 @@ bool CUSBCECAdapterCommands::GetConfiguration(libcec_configuration &configuratio bool CUSBCECAdapterCommands::PingAdapter(void) { +#ifdef CEC_DEBUGGING LIB_CEC->AddLog(CEC_LOG_DEBUG, "sending ping"); +#endif CCECAdapterMessage params; CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_PING, params); @@ -502,6 +592,19 @@ bool CUSBCECAdapterCommands::SetAckMask(uint16_t iMask) return bReturn; } +void CUSBCECAdapterCommands::SetActiveSource(bool bSetTo, bool bClientUnregistered) +{ + if (bClientUnregistered) return; + if (m_persistedConfiguration.iFirmwareVersion >= 3) + { + LIB_CEC->AddLog(CEC_LOG_DEBUG, "marking the adapter as %s source", bSetTo ? "active" : "inactive"); + CCECAdapterMessage params; + params.PushEscaped(bSetTo ? 1 : 0); + CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_SET_ACTIVE_SOURCE, params); + delete message; + } +} + bool CUSBCECAdapterCommands::StartBootloader(void) { LIB_CEC->AddLog(CEC_LOG_DEBUG, "starting the bootloader"); @@ -526,6 +629,12 @@ bool CUSBCECAdapterCommands::SetLineTimeout(uint8_t iTimeout) bool CUSBCECAdapterCommands::SetControlledMode(bool controlled) { + { + CLockObject lock(m_mutex); + if (m_bControlledMode == controlled) + return true; + } + LIB_CEC->AddLog(CEC_LOG_DEBUG, "turning controlled mode %s", controlled ? "on" : "off"); CCECAdapterMessage params; @@ -533,5 +642,12 @@ bool CUSBCECAdapterCommands::SetControlledMode(bool controlled) CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_SET_CONTROLLED, params); bool bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED; delete message; + + if (bReturn) + { + CLockObject lock(m_mutex); + m_bControlledMode = controlled; + } + return bReturn; }