#define CEC_ADAPTER_PING_TIMEOUT 15000
+// firmware version 2
+#define CEC_LATEST_ADAPTER_FW_VERSION 2
+// firmware date Thu Apr 26 20:14:49 2012 +0000
+#define CEC_LATEST_ADAPTER_FW_DATE 0x4F99ACB9
+
+#define LIB_CEC m_callback->GetLib()
+
CUSBCECAdapterCommunication::CUSBCECAdapterCommunication(IAdapterCommunicationCallback *callback, const char *strPort, uint16_t iBaudRate /* = CEC_SERIAL_DEFAULT_BAUDRATE */) :
IAdapterCommunication(callback),
m_port(NULL),
m_bInitialised(false),
m_pingThread(NULL),
m_commands(NULL),
- m_adapterMessageQueue(NULL)
+ m_adapterMessageQueue(NULL),
+ m_iAckMask(0xFFFF)
{
- for (unsigned int iPtr = 0; iPtr < 15; iPtr++)
+ for (unsigned int iPtr = CECDEVICE_TV; iPtr < CECDEVICE_BROADCAST; iPtr++)
m_bWaitingForAck[iPtr] = false;
m_port = new CSerialPort(strPort, iBaudRate);
}
/* we need the port settings here */
if (!m_port)
{
- CLibCEC::AddLog(CEC_LOG_ERROR, "port is NULL");
+ LIB_CEC->AddLog(CEC_LOG_ERROR, "port is NULL");
return bConnectionOpened;
}
/* return true when the port is already open */
if (IsOpen())
{
- CLibCEC::AddLog(CEC_LOG_WARNING, "port is already open");
+ LIB_CEC->AddLog(CEC_LOG_WARNING, "port is already open");
return true;
}
/* return false when we couldn't connect */
if (!bConnectionOpened)
{
- CLibCEC::AddLog(CEC_LOG_ERROR, strError);
+ LIB_CEC->AddLog(CEC_LOG_ERROR, strError);
+
+ if (m_port->GetErrorNumber() == EACCES)
+ {
+ libcec_parameter param;
+ param.paramType = CEC_PARAMETER_TYPE_STRING;
+ param.paramData = (void*)"No permission to open the device";
+ LIB_CEC->Alert(CEC_ALERT_PERMISSION_ERROR, param);
+ }
+ else if (m_port->GetErrorNumber() == EBUSY)
+ {
+ libcec_parameter param;
+ param.paramType = CEC_PARAMETER_TYPE_STRING;
+ param.paramData = (void*)"The serial port is busy. Only one program can access the device directly.";
+ LIB_CEC->Alert(CEC_ALERT_PORT_BUSY, param);
+ }
return false;
}
- CLibCEC::AddLog(CEC_LOG_DEBUG, "connection opened, clearing any previous input and waiting for active transmissions to end before starting");
+ LIB_CEC->AddLog(CEC_LOG_DEBUG, "connection opened, clearing any previous input and waiting for active transmissions to end before starting");
ClearInputBytes();
}
if (!CreateThread())
{
bConnectionOpened = false;
- CLibCEC::AddLog(CEC_LOG_ERROR, "could not create a communication thread");
+ LIB_CEC->AddLog(CEC_LOG_ERROR, "could not create a communication thread");
}
else if (!bSkipChecks && !CheckAdapter())
{
bConnectionOpened = false;
- CLibCEC::AddLog(CEC_LOG_ERROR, "the adapter failed to pass basic checks");
+ LIB_CEC->AddLog(CEC_LOG_ERROR, "the adapter failed to pass basic checks");
}
else if (bStartListening)
{
else
{
bConnectionOpened = false;
- CLibCEC::AddLog(CEC_LOG_ERROR, "could not create a ping thread");
+ LIB_CEC->AddLog(CEC_LOG_ERROR, "could not create a ping thread");
}
}
CLockObject lock(m_mutex);
/* set the ackmask to 0 before closing the connection */
- if (IsRunning() && m_port->IsOpen() && m_port->GetErrorNumber() == 0)
+ if (IsOpen() && m_port->GetErrorNumber() == 0)
{
- CLibCEC::AddLog(CEC_LOG_DEBUG, "%s - closing the connection", __FUNCTION__);
+ LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - closing the connection", __FUNCTION__);
SetAckMask(0);
if (m_commands->GetFirmwareVersion() >= 2)
SetControlledMode(false);
/* close and delete the com port connection */
if (m_port)
m_port->Close();
-
- libcec_parameter param;
- CLibCEC::Alert(CEC_ALERT_CONNECTION_LOST, param);
}
cec_adapter_message_state CUSBCECAdapterCommunication::Write(const cec_command &data, bool &bRetry, uint8_t iLineTimeout)
void *CUSBCECAdapterCommunication::Process(void)
{
CCECAdapterMessage msg;
- CLibCEC::AddLog(CEC_LOG_DEBUG, "communication thread started");
+ LIB_CEC->AddLog(CEC_LOG_DEBUG, "communication thread started");
while (!IsStopped())
{
/* read from the serial port */
if (!ReadFromDevice(50, 5))
+ {
+ libcec_parameter param;
+ param.paramData = NULL; param.paramType = CEC_PARAMETER_TYPE_UNKOWN;
+ LIB_CEC->Alert(CEC_ALERT_CONNECTION_LOST, param);
+
break;
+ }
/* TODO sleep 5 ms so other threads can get a lock */
Sleep(5);
}
m_adapterMessageQueue->Clear();
- CLibCEC::AddLog(CEC_LOG_DEBUG, "communication thread ended");
+ LIB_CEC->AddLog(CEC_LOG_DEBUG, "communication thread ended");
return NULL;
}
bool CUSBCECAdapterCommunication::WriteToDevice(CCECAdapterMessage *message)
{
CLockObject adapterLock(m_mutex);
- if (!m_port->IsOpen())
+ if (!IsOpen())
{
- CLibCEC::AddLog(CEC_LOG_DEBUG, "error writing command '%s' to serial port '%s': the connection is closed", CCECAdapterMessage::ToString(message->Message()), m_port->GetName().c_str());
+ LIB_CEC->AddLog(CEC_LOG_DEBUG, "error writing command '%s' to serial port '%s': the connection is closed", CCECAdapterMessage::ToString(message->Message()), m_port->GetName().c_str());
message->state = ADAPTER_MESSAGE_STATE_ERROR;
return false;
}
/* write the message */
if (m_port->Write(message->packet.data, message->Size()) != (ssize_t) message->Size())
{
- CLibCEC::AddLog(CEC_LOG_DEBUG, "error writing command '%s' to serial port '%s': %s", CCECAdapterMessage::ToString(message->Message()), m_port->GetName().c_str(), m_port->GetError().c_str());
+ LIB_CEC->AddLog(CEC_LOG_DEBUG, "error writing command '%s' to serial port '%s': %s", CCECAdapterMessage::ToString(message->Message()), m_port->GetName().c_str(), m_port->GetError().c_str());
message->state = ADAPTER_MESSAGE_STATE_ERROR;
- Close();
+ // this will trigger an alert in the reader thread
+ m_port->Close();
return false;
}
- CLibCEC::AddLog(CEC_LOG_DEBUG, "command '%s' sent", message->IsTranmission() ? "CEC transmission" : CCECAdapterMessage::ToString(message->Message()));
+ LIB_CEC->AddLog(CEC_LOG_DEBUG, "command '%s' sent", message->IsTranmission() ? "CEC transmission" : CCECAdapterMessage::ToString(message->Message()));
message->state = ADAPTER_MESSAGE_STATE_SENT;
return true;
}
/* read from the serial port */
{
CLockObject lock(m_mutex);
- if (!m_port || !m_port->IsOpen())
+ if (!IsOpen())
return false;
iBytesRead = m_port->Read(buff, sizeof(uint8_t) * iSize, iTimeout);
if (m_port->GetErrorNumber())
{
- CLibCEC::AddLog(CEC_LOG_ERROR, "error reading from serial port: %s", m_port->GetError().c_str());
+ LIB_CEC->AddLog(CEC_LOG_ERROR, "error reading from serial port: %s", m_port->GetError().c_str());
m_port->Close();
return false;
}
CCECAdapterMessage *CUSBCECAdapterCommunication::SendCommand(cec_adapter_messagecode msgCode, CCECAdapterMessage ¶ms, bool bIsRetry /* = false */)
{
- if (!m_port || !m_port->IsOpen() ||
- !m_adapterMessageQueue)
+ if (!IsOpen() || !m_adapterMessageQueue)
return NULL;
/* create the adapter message for this command */
/* write the command */
if (!m_adapterMessageQueue->Write(output))
{
+ // this will trigger an alert in the reader thread
if (output->state == ADAPTER_MESSAGE_STATE_ERROR)
- Close();
+ m_port->Close();
return output;
}
else
/* if the controller reported that the command was rejected, and we didn't send the command
to set controlled mode, then the controller probably switched to auto mode. set controlled
mode and retry */
- CLibCEC::AddLog(CEC_LOG_DEBUG, "setting controlled mode and retrying");
+ LIB_CEC->AddLog(CEC_LOG_DEBUG, "setting controlled mode and retrying");
delete output;
if (SetControlledMode(true))
return SendCommand(msgCode, params, true);
unsigned iPingTry(0);
while (timeout.TimeLeft() > 0 && (bPinged = PingAdapter()) == false)
{
- CLibCEC::AddLog(CEC_LOG_ERROR, "the adapter did not respond correctly to a ping (try %d)", ++iPingTry);
+ LIB_CEC->AddLog(CEC_LOG_ERROR, "the adapter did not respond correctly to a ping (try %d)", ++iPingTry);
CEvent::Sleep(500);
}
bool bControlled(false);
while (timeout.TimeLeft() > 0 && (bControlled = SetControlledMode(true)) == false)
{
- CLibCEC::AddLog(CEC_LOG_ERROR, "the adapter did not respond correctly to setting controlled mode (try %d)", ++iControlledTry);
+ LIB_CEC->AddLog(CEC_LOG_ERROR, "the adapter did not respond correctly to setting controlled mode (try %d)", ++iControlledTry);
CEvent::Sleep(500);
}
bReturn = bControlled;
{
if (m_port->IsOpen() && m_commands->StartBootloader())
{
- Close();
+ m_port->Close();
return true;
}
return false;
bool CUSBCECAdapterCommunication::SetAckMask(uint16_t iMask)
{
- return m_port->IsOpen() ? m_commands->SetAckMask(iMask) : false;
+ if (m_iAckMask == iMask)
+ return true;
+
+ if (IsOpen() && m_commands->SetAckMask(iMask))
+ {
+ m_iAckMask = iMask;
+ return true;
+ }
+
+ LIB_CEC->AddLog(CEC_LOG_ERROR, "couldn't change the ackmask: the connection is closed");
+ return false;
+}
+
+uint16_t CUSBCECAdapterCommunication::GetAckMask(void)
+{
+ return m_iAckMask;
}
bool CUSBCECAdapterCommunication::PingAdapter(void)
{
- return m_port->IsOpen() ? m_commands->PingAdapter() : false;
+ return IsOpen() ? m_commands->PingAdapter() : false;
}
uint16_t CUSBCECAdapterCommunication::GetFirmwareVersion(void)
{
- return m_commands->GetFirmwareVersion();
+ return IsOpen() ? m_commands->GetFirmwareVersion() : CEC_FW_VERSION_UNKNOWN;
}
uint32_t CUSBCECAdapterCommunication::GetFirmwareBuildDate(void)
{
- return m_commands->RequestBuildDate();
+ return IsOpen() ? m_commands->RequestBuildDate() : 0;
+}
+
+bool CUSBCECAdapterCommunication::IsRunningLatestFirmware(void)
+{
+ return GetFirmwareVersion() >= CEC_LATEST_ADAPTER_FW_VERSION &&
+ GetFirmwareBuildDate() >= CEC_LATEST_ADAPTER_FW_DATE;
}
-bool CUSBCECAdapterCommunication::PersistConfiguration(libcec_configuration *configuration)
+bool CUSBCECAdapterCommunication::PersistConfiguration(const libcec_configuration &configuration)
{
- return m_port->IsOpen() ? m_commands->PersistConfiguration(configuration) : false;
+ return IsOpen() ? m_commands->PersistConfiguration(configuration) : false;
}
-bool CUSBCECAdapterCommunication::GetConfiguration(libcec_configuration *configuration)
+bool CUSBCECAdapterCommunication::GetConfiguration(libcec_configuration &configuration)
{
- return m_port->IsOpen() ? m_commands->GetConfiguration(configuration) : false;
+ return IsOpen() ? m_commands->GetConfiguration(configuration) : false;
}
CStdString CUSBCECAdapterCommunication::GetPortName(void)
bool CUSBCECAdapterCommunication::SetControlledMode(bool controlled)
{
- return m_port->IsOpen() ? m_commands->SetControlledMode(controlled) : false;
+ return IsOpen() ? m_commands->SetControlledMode(controlled) : false;
}
void *CAdapterPingThread::Process(void)
if (iFailedCounter == 3)
{
/* failed to ping the adapter 3 times in a row. something must be wrong with the connection */
- CLibCEC::AddLog(CEC_LOG_ERROR, "failed to ping the adapter 3 times in a row. closing the connection.");
+ m_com->LIB_CEC->AddLog(CEC_LOG_ERROR, "failed to ping the adapter 3 times in a row. closing the connection.");
m_com->StopThread(false);
break;
}
repositories / deb_libcec.git / blobdiff