src/lib/adapter/Pulse-Eight/USBCECAdapterCommunication.cpp

   1 /*
   2  * This file is part of the libCEC(R) library.
   3  *
   4  * libCEC(R) is Copyright (C) 2011-2012 Pulse-Eight Limited.  All rights reserved.
   5  * libCEC(R) is an original work, containing original code.
   6  *
   7  * libCEC(R) is a trademark of Pulse-Eight Limited.
   8  *
   9  * This program is dual-licensed; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  22  *
  23  *
  24  * Alternatively, you can license this library under a commercial license,
  25  * please contact Pulse-Eight Licensing for more information.
  26  *
  27  * For more information contact:
  28  * Pulse-Eight Licensing       <license@pulse-eight.com>
  29  *     http://www.pulse-eight.com/
  30  *     http://www.pulse-eight.net/
  31  */
  32
  33 #include "env.h"
  34 #include "USBCECAdapterCommunication.h"
  35
  36 #include "USBCECAdapterCommands.h"
  37 #include "USBCECAdapterMessageQueue.h"
  38 #include "USBCECAdapterMessage.h"
  39 #include "lib/platform/sockets/serialport.h"
  40 #include "lib/platform/util/timeutils.h"
  41 #include "lib/platform/util/util.h"
  42 #include "lib/platform/util/edid.h"
  43 #include "lib/platform/adl/adl-edid.h"
  44 #include "lib/platform/nvidia/nv-edid.h"
  45 #include "lib/LibCEC.h"
  46 #include "lib/CECProcessor.h"
  47
  48 using namespace std;
  49 using namespace CEC;
  50 using namespace PLATFORM;
  51
  52 #define CEC_ADAPTER_PING_TIMEOUT          15000
  53 #define CEC_ADAPTER_EEPROM_WRITE_INTERVAL 30000
  54 #define CEC_ADAPTER_EEPROM_WRITE_RETRY    5000
  55
  56 // firmware version 2
  57 #define CEC_LATEST_ADAPTER_FW_VERSION 2
  58 // firmware date Thu Aug  2 08:31:24 UTC 2012
  59 #define CEC_LATEST_ADAPTER_FW_DATE    0x501a4b0c
  60
  61 #define CEC_FW_DATE_EXTENDED_RESPONSE 0x501a4b0c
  62
  63 #define LIB_CEC m_callback->GetLib()
  64
  65 CUSBCECAdapterCommunication::CUSBCECAdapterCommunication(IAdapterCommunicationCallback *callback, const char *strPort, uint16_t iBaudRate /* = CEC_SERIAL_DEFAULT_BAUDRATE */) :
  66     IAdapterCommunication(callback),
  67     m_port(NULL),
  68     m_iLineTimeout(0),
  69     m_lastPollDestination(CECDEVICE_UNKNOWN),
  70     m_bInitialised(false),
  71     m_pingThread(NULL),
  72     m_eepromWriteThread(NULL),
  73     m_commands(NULL),
  74     m_adapterMessageQueue(NULL)
  75 {
  76   m_logicalAddresses.Clear();
  77   for (unsigned int iPtr = CECDEVICE_TV; iPtr < CECDEVICE_BROADCAST; iPtr++)
  78     m_bWaitingForAck[iPtr] = false;
  79   m_port = new CSerialPort(strPort, iBaudRate);
  80   m_commands = new CUSBCECAdapterCommands(this);
  81 }
  82
  83 CUSBCECAdapterCommunication::~CUSBCECAdapterCommunication(void)
  84 {
  85   Close();
  86   DELETE_AND_NULL(m_commands);
  87   DELETE_AND_NULL(m_adapterMessageQueue);
  88   DELETE_AND_NULL(m_port);
  89 }
  90
  91 void CUSBCECAdapterCommunication::ResetMessageQueue(void)
  92 {
  93   DELETE_AND_NULL(m_adapterMessageQueue);
  94   m_adapterMessageQueue = new CCECAdapterMessageQueue(this);
  95   m_adapterMessageQueue->CreateThread();
  96 }
  97
  98 bool CUSBCECAdapterCommunication::Open(uint32_t iTimeoutMs /* = CEC_DEFAULT_CONNECT_TIMEOUT */, bool bSkipChecks /* = false */, bool bStartListening /* = true */)
  99 {
 100   bool bConnectionOpened(false);
 101   {
 102     CLockObject lock(m_mutex);
 103
 104     /* we need the port settings here */
 105     if (!m_port)
 106     {
 107       LIB_CEC->AddLog(CEC_LOG_ERROR, "port is NULL");
 108       return bConnectionOpened;
 109     }
 110
 111     /* return true when the port is already open */
 112     if (IsOpen())
 113     {
 114       LIB_CEC->AddLog(CEC_LOG_WARNING, "port is already open");
 115       return true;
 116     }
 117
 118     ResetMessageQueue();
 119
 120     /* try to open the connection */
 121     CStdString strError;
 122     CTimeout timeout(iTimeoutMs);
 123     while (!bConnectionOpened && timeout.TimeLeft() > 0)
 124     {
 125       if ((bConnectionOpened = m_port->Open(timeout.TimeLeft())) == false)
 126       {
 127         strError.Format("error opening serial port '%s': %s", m_port->GetName().c_str(), m_port->GetError().c_str());
 128         Sleep(250);
 129       }
 130       /* and retry every 250ms until the timeout passed */
 131     }
 132
 133     /* return false when we couldn't connect */
 134     if (!bConnectionOpened)
 135     {
 136       LIB_CEC->AddLog(CEC_LOG_ERROR, strError);
 137
 138       if (m_port->GetErrorNumber() == EACCES)
 139       {
 140         libcec_parameter param;
 141         param.paramType = CEC_PARAMETER_TYPE_STRING;
 142         param.paramData = (void*)"No permission to open the device";
 143         LIB_CEC->Alert(CEC_ALERT_PERMISSION_ERROR, param);
 144       }
 145       else if (m_port->GetErrorNumber() == EBUSY)
 146       {
 147         libcec_parameter param;
 148         param.paramType = CEC_PARAMETER_TYPE_STRING;
 149         param.paramData = (void*)"The serial port is busy. Only one program can access the device directly.";
 150         LIB_CEC->Alert(CEC_ALERT_PORT_BUSY, param);
 151       }
 152       return false;
 153     }
 154
 155     LIB_CEC->AddLog(CEC_LOG_DEBUG, "connection opened, clearing any previous input and waiting for active transmissions to end before starting");
 156     ClearInputBytes();
 157   }
 158
 159   // always start by setting the ackmask to 0, to clear previous values
 160   cec_logical_addresses addresses; addresses.Clear();
 161   SetLogicalAddresses(addresses);
 162
 163   if (!CreateThread())
 164   {
 165     bConnectionOpened = false;
 166     LIB_CEC->AddLog(CEC_LOG_ERROR, "could not create a communication thread");
 167   }
 168   else if (!bSkipChecks && !CheckAdapter())
 169   {
 170     bConnectionOpened = false;
 171     LIB_CEC->AddLog(CEC_LOG_ERROR, "the adapter failed to pass basic checks");
 172   }
 173   else if (bStartListening)
 174   {
 175     /* start the eeprom write thread, that handles all eeprom writes async */
 176     m_eepromWriteThread = new CAdapterEepromWriteThread(this);
 177     if (!m_eepromWriteThread->CreateThread())
 178     {
 179       bConnectionOpened = false;
 180       LIB_CEC->AddLog(CEC_LOG_ERROR, "could not create the eeprom write thread");
 181     }
 182     else
 183     {
 184       /* start a ping thread, that will ping the adapter every 15 seconds
 185          if it doesn't receive any ping for 30 seconds, it'll switch to auto mode */
 186       m_pingThread = new CAdapterPingThread(this, CEC_ADAPTER_PING_TIMEOUT);
 187       if (m_pingThread->CreateThread())
 188       {
 189         bConnectionOpened = true;
 190       }
 191       else
 192       {
 193         bConnectionOpened = false;
 194         LIB_CEC->AddLog(CEC_LOG_ERROR, "could not create a ping thread");
 195       }
 196     }
 197   }
 198
 199   if (!bConnectionOpened || !bStartListening)
 200     StopThread(0);
 201
 202   return bConnectionOpened;
 203 }
 204
 205 void CUSBCECAdapterCommunication::Close(void)
 206 {
 207   /* stop the reader thread */
 208   StopThread(0);
 209
 210   CLockObject lock(m_mutex);
 211
 212   /* set the ackmask to 0 before closing the connection */
 213   if (IsOpen() && m_port->GetErrorNumber() == 0)
 214   {
 215     LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - closing the connection", __FUNCTION__);
 216     cec_logical_addresses addresses; addresses.Clear();
 217     SetLogicalAddresses(addresses);
 218     if (m_commands->GetFirmwareVersion() >= 2)
 219       SetControlledMode(false);
 220   }
 221
 222   m_adapterMessageQueue->Clear();
 223
 224   /* stop and delete the write thread */
 225   if (m_eepromWriteThread)
 226     m_eepromWriteThread->Stop();
 227   DELETE_AND_NULL(m_eepromWriteThread);
 228
 229   /* stop and delete the ping thread */
 230   DELETE_AND_NULL(m_pingThread);
 231
 232   /* close and delete the com port connection */
 233   if (m_port)
 234     m_port->Close();
 235 }
 236
 237 cec_adapter_message_state CUSBCECAdapterCommunication::Write(const cec_command &data, bool &bRetry, uint8_t iLineTimeout, bool bIsReply)
 238 {
 239   cec_adapter_message_state retVal(ADAPTER_MESSAGE_STATE_UNKNOWN);
 240   if (!IsRunning())
 241     return retVal;
 242
 243   CCECAdapterMessage *output = new CCECAdapterMessage(data, iLineTimeout);
 244   output->bFireAndForget = bIsReply;
 245
 246   /* mark as waiting for an ack from the destination */
 247   MarkAsWaiting(data.destination);
 248
 249   /* send the message */
 250   if (bIsReply)
 251   {
 252     retVal = m_adapterMessageQueue->Write(output) ?
 253         ADAPTER_MESSAGE_STATE_WAITING_TO_BE_SENT : ADAPTER_MESSAGE_STATE_ERROR;
 254   }
 255   else
 256   {
 257     bRetry = (!m_adapterMessageQueue->Write(output) || output->NeedsRetry()) && output->transmit_timeout > 0;
 258     if (bRetry)
 259       Sleep(CEC_DEFAULT_TRANSMIT_RETRY_WAIT);
 260     retVal = output->state;
 261
 262     delete output;
 263   }
 264   return retVal;
 265 }
 266
 267 void *CUSBCECAdapterCommunication::Process(void)
 268 {
 269   CCECAdapterMessage msg;
 270   LIB_CEC->AddLog(CEC_LOG_DEBUG, "communication thread started");
 271
 272   while (!IsStopped())
 273   {
 274     /* read from the serial port */
 275     if (!ReadFromDevice(50, 5))
 276     {
 277       libcec_parameter param;
 278       param.paramData = NULL; param.paramType = CEC_PARAMETER_TYPE_UNKOWN;
 279       LIB_CEC->Alert(CEC_ALERT_CONNECTION_LOST, param);
 280
 281       break;
 282     }
 283
 284     /* TODO sleep 5 ms so other threads can get a lock */
 285     Sleep(5);
 286   }
 287
 288   m_adapterMessageQueue->Clear();
 289   LIB_CEC->AddLog(CEC_LOG_DEBUG, "communication thread ended");
 290   return NULL;
 291 }
 292
 293 bool CUSBCECAdapterCommunication::HandlePoll(const CCECAdapterMessage &msg)
 294 {
 295   bool bIsError(msg.IsError());
 296   cec_adapter_messagecode messageCode(msg.Message());
 297   CLockObject lock(m_mutex);
 298
 299   if (messageCode == MSGCODE_FRAME_START && msg.IsACK())
 300   {
 301     m_lastPollDestination = msg.Destination();
 302     if (msg.Destination() < CECDEVICE_BROADCAST)
 303     {
 304       if (!m_bWaitingForAck[msg.Destination()] && !msg.IsEOM())
 305       {
 306         if (m_callback)
 307           m_callback->HandlePoll(msg.Initiator(), msg.Destination());
 308       }
 309       else
 310         m_bWaitingForAck[msg.Destination()] = false;
 311     }
 312   }
 313   else if (messageCode == MSGCODE_RECEIVE_FAILED)
 314   {
 315     /* hack to suppress warnings when an LG is polling */
 316     if (m_lastPollDestination != CECDEVICE_UNKNOWN)
 317       bIsError = m_callback->HandleReceiveFailed(m_lastPollDestination);
 318   }
 319
 320   return bIsError;
 321 }
 322
 323 void CUSBCECAdapterCommunication::MarkAsWaiting(const cec_logical_address dest)
 324 {
 325   /* mark as waiting for an ack from the destination */
 326   if (dest < CECDEVICE_BROADCAST)
 327   {
 328     CLockObject lock(m_mutex);
 329     m_bWaitingForAck[dest] = true;
 330   }
 331 }
 332
 333 void CUSBCECAdapterCommunication::ClearInputBytes(uint32_t iTimeout /* = CEC_CLEAR_INPUT_DEFAULT_WAIT */)
 334 {
 335   CTimeout timeout(iTimeout);
 336   uint8_t buff[1024];
 337   ssize_t iBytesRead(0);
 338   bool bGotMsgEnd(true);
 339
 340   while (timeout.TimeLeft() > 0 && ((iBytesRead = m_port->Read(buff, 1024, 5)) > 0 || !bGotMsgEnd))
 341   {
 342     bGotMsgEnd = false;
 343     /* if something was received, wait for MSGEND */
 344     for (ssize_t iPtr = 0; iPtr < iBytesRead; iPtr++)
 345       bGotMsgEnd = buff[iPtr] == MSGEND;
 346   }
 347 }
 348
 349 bool CUSBCECAdapterCommunication::SetLineTimeout(uint8_t iTimeout)
 350 {
 351   bool bReturn(true);
 352   bool bChanged(false);
 353
 354   /* only send the command if the timeout changed */
 355   {
 356     CLockObject lock(m_mutex);
 357     bChanged = (m_iLineTimeout != iTimeout);
 358     m_iLineTimeout = iTimeout;
 359   }
 360
 361   if (bChanged)
 362     bReturn = m_commands->SetLineTimeout(iTimeout);
 363
 364   return bReturn;
 365 }
 366
 367 bool CUSBCECAdapterCommunication::WriteToDevice(CCECAdapterMessage *message)
 368 {
 369   CLockObject adapterLock(m_mutex);
 370   if (!IsOpen())
 371   {
 372     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());
 373     message->state = ADAPTER_MESSAGE_STATE_ERROR;
 374     return false;
 375   }
 376
 377   /* write the message */
 378   if (m_port->Write(message->packet.data, message->Size()) != (ssize_t) message->Size())
 379   {
 380     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());
 381     message->state = ADAPTER_MESSAGE_STATE_ERROR;
 382     // this will trigger an alert in the reader thread
 383     m_port->Close();
 384     return false;
 385   }
 386
 387   LIB_CEC->AddLog(CEC_LOG_DEBUG, "command '%s' sent", message->IsTranmission() ? "CEC transmission" : CCECAdapterMessage::ToString(message->Message()));
 388   message->state = ADAPTER_MESSAGE_STATE_SENT;
 389   return true;
 390 }
 391
 392 bool CUSBCECAdapterCommunication::ReadFromDevice(uint32_t iTimeout, size_t iSize /* = 256 */)
 393 {
 394   ssize_t iBytesRead(0);
 395   uint8_t buff[256];
 396   if (iSize > 256)
 397     iSize = 256;
 398
 399   /* read from the serial port */
 400   {
 401     CLockObject lock(m_mutex);
 402     if (!IsOpen())
 403       return false;
 404
 405     do {
 406       /* retry Read() if it was interrupted */
 407       iBytesRead = m_port->Read(buff, sizeof(uint8_t) * iSize, iTimeout);
 408     } while(m_port->GetErrorNumber() == EINTR);
 409
 410
 411     if (m_port->GetErrorNumber())
 412     {
 413       LIB_CEC->AddLog(CEC_LOG_ERROR, "error reading from serial port: %s", m_port->GetError().c_str());
 414       m_port->Close();
 415       return false;
 416     }
 417   }
 418
 419   if (iBytesRead < 0 || iBytesRead > 256)
 420     return false;
 421   else if (iBytesRead > 0)
 422   {
 423     /* add the data to the current frame */
 424     m_adapterMessageQueue->AddData(buff, iBytesRead);
 425   }
 426
 427   return true;
 428 }
 429
 430 CCECAdapterMessage *CUSBCECAdapterCommunication::SendCommand(cec_adapter_messagecode msgCode, CCECAdapterMessage &params, bool bIsRetry /* = false */)
 431 {
 432   if (!IsOpen() || !m_adapterMessageQueue)
 433     return NULL;
 434
 435   /* create the adapter message for this command */
 436   CCECAdapterMessage *output = new CCECAdapterMessage;
 437   output->PushBack(MSGSTART);
 438   output->PushEscaped((uint8_t)msgCode);
 439   output->Append(params);
 440   output->PushBack(MSGEND);
 441
 442   /* write the command */
 443   if (!m_adapterMessageQueue->Write(output))
 444   {
 445     // this will trigger an alert in the reader thread
 446     if (output->state == ADAPTER_MESSAGE_STATE_ERROR)
 447       m_port->Close();
 448     return output;
 449   }
 450   else
 451   {
 452     if (!bIsRetry && output->Reply() == MSGCODE_COMMAND_REJECTED && msgCode != MSGCODE_SET_CONTROLLED &&
 453         msgCode != MSGCODE_GET_BUILDDATE /* same messagecode value had a different meaning in older fw builds */)
 454     {
 455       /* if the controller reported that the command was rejected, and we didn't send the command
 456          to set controlled mode, then the controller probably switched to auto mode. set controlled
 457          mode and retry */
 458       LIB_CEC->AddLog(CEC_LOG_DEBUG, "setting controlled mode and retrying");
 459       delete output;
 460       if (SetControlledMode(true))
 461         return SendCommand(msgCode, params, true);
 462     }
 463   }
 464
 465   return output;
 466 }
 467
 468 bool CUSBCECAdapterCommunication::CheckAdapter(uint32_t iTimeoutMs /* = CEC_DEFAULT_CONNECT_TIMEOUT */)
 469 {
 470   bool bReturn(false);
 471   CTimeout timeout(iTimeoutMs > 0 ? iTimeoutMs : CEC_DEFAULT_TRANSMIT_WAIT);
 472
 473   /* try to ping the adapter */
 474   bool bPinged(false);
 475   unsigned iPingTry(0);
 476   while (timeout.TimeLeft() > 0 && (bPinged = PingAdapter()) == false)
 477   {
 478     LIB_CEC->AddLog(CEC_LOG_ERROR, "the adapter did not respond correctly to a ping (try %d)", ++iPingTry);
 479     CEvent::Sleep(500);
 480   }
 481
 482   /* try to read the firmware version */
 483   if (bPinged && timeout.TimeLeft() > 0 && m_commands->RequestFirmwareVersion() >= 2)
 484   {
 485     /* try to set controlled mode for v2+ firmwares */
 486     unsigned iControlledTry(0);
 487     bool bControlled(false);
 488     while (timeout.TimeLeft() > 0 && (bControlled = SetControlledMode(true)) == false)
 489     {
 490       LIB_CEC->AddLog(CEC_LOG_ERROR, "the adapter did not respond correctly to setting controlled mode (try %d)", ++iControlledTry);
 491       CEvent::Sleep(500);
 492     }
 493     bReturn = bControlled;
 494   }
 495   else
 496     bReturn = true;
 497
 498   if (m_commands->GetFirmwareVersion() >= 2)
 499   {
 500     /* try to read the build date */
 501     m_commands->RequestBuildDate();
 502
 503     /* try to read the adapter type */
 504     m_commands->RequestAdapterType();
 505   }
 506
 507   SetInitialised(bReturn);
 508   return bReturn;
 509 }
 510
 511 bool CUSBCECAdapterCommunication::IsOpen(void)
 512 {
 513   /* thread is not being stopped, the port is open and the thread is running */
 514   return !IsStopped() && m_port->IsOpen() && IsRunning();
 515 }
 516
 517 std::string CUSBCECAdapterCommunication::GetError(void) const
 518 {
 519   return m_port->GetError();
 520 }
 521
 522 void CUSBCECAdapterCommunication::SetInitialised(bool bSetTo /* = true */)
 523 {
 524   CLockObject lock(m_mutex);
 525   m_bInitialised = bSetTo;
 526 }
 527
 528 bool CUSBCECAdapterCommunication::IsInitialised(void)
 529 {
 530   CLockObject lock(m_mutex);
 531   return m_bInitialised;
 532 }
 533
 534 bool CUSBCECAdapterCommunication::StartBootloader(void)
 535 {
 536   if (m_port->IsOpen() && m_commands->StartBootloader())
 537   {
 538     m_port->Close();
 539     return true;
 540   }
 541   return false;
 542 }
 543
 544 bool CUSBCECAdapterCommunication::SetLogicalAddresses(const cec_logical_addresses &addresses)
 545 {
 546   {
 547     CLockObject lock(m_mutex);
 548     if (m_logicalAddresses == addresses)
 549       return true;
 550   }
 551
 552   if (IsOpen() && m_commands->SetAckMask(addresses.AckMask()))
 553   {
 554     CLockObject lock(m_mutex);
 555     m_logicalAddresses = addresses;
 556     return true;
 557   }
 558
 559   LIB_CEC->AddLog(CEC_LOG_DEBUG, "couldn't change the ackmask: the connection is closed");
 560   return false;
 561 }
 562
 563 cec_logical_addresses CUSBCECAdapterCommunication::GetLogicalAddresses(void)
 564 {
 565   cec_logical_addresses addresses;
 566   CLockObject lock(m_mutex);
 567   addresses = m_logicalAddresses;
 568   return addresses;
 569 }
 570
 571 bool CUSBCECAdapterCommunication::PingAdapter(void)
 572 {
 573   return IsOpen() ? m_commands->PingAdapter() : false;
 574 }
 575
 576 uint16_t CUSBCECAdapterCommunication::GetFirmwareVersion(void)
 577 {
 578   return m_commands ? m_commands->GetFirmwareVersion() : CEC_FW_VERSION_UNKNOWN;
 579 }
 580
 581 uint32_t CUSBCECAdapterCommunication::GetFirmwareBuildDate(void)
 582 {
 583   uint32_t iBuildDate(0);
 584   if (m_commands)
 585     iBuildDate = m_commands->GetPersistedBuildDate();
 586   if (iBuildDate == 0 && IsOpen())
 587     iBuildDate = m_commands->RequestBuildDate();
 588
 589   return iBuildDate;
 590 }
 591
 592 cec_adapter_type CUSBCECAdapterCommunication::GetAdapterType(void)
 593 {
 594   cec_adapter_type type(ADAPTERTYPE_UNKNOWN);
 595   if (m_commands)
 596     type = (cec_adapter_type)m_commands->GetPersistedAdapterType();
 597   if (type == ADAPTERTYPE_UNKNOWN && IsOpen())
 598     type = (cec_adapter_type)m_commands->RequestAdapterType();
 599
 600   return type;
 601 }
 602
 603 bool CUSBCECAdapterCommunication::ProvidesExtendedResponse(void)
 604 {
 605   uint32_t iBuildDate(0);
 606   if (m_commands)
 607     iBuildDate = m_commands->GetPersistedBuildDate();
 608
 609   return iBuildDate >= CEC_FW_DATE_EXTENDED_RESPONSE;
 610 }
 611
 612 bool CUSBCECAdapterCommunication::IsRunningLatestFirmware(void)
 613 {
 614   return GetFirmwareBuildDate() >= CEC_LATEST_ADAPTER_FW_DATE &&
 615       GetFirmwareVersion() >= CEC_LATEST_ADAPTER_FW_VERSION;
 616 }
 617
 618 bool CUSBCECAdapterCommunication::PersistConfiguration(const libcec_configuration &configuration)
 619 {
 620   return IsOpen() ?
 621       m_commands->PersistConfiguration(configuration) && m_eepromWriteThread->Write() :
 622       false;
 623 }
 624
 625 bool CUSBCECAdapterCommunication::GetConfiguration(libcec_configuration &configuration)
 626 {
 627   return IsOpen() ? m_commands->GetConfiguration(configuration) : false;
 628 }
 629
 630 std::string CUSBCECAdapterCommunication::GetPortName(void)
 631 {
 632   return m_port->GetName();
 633 }
 634
 635 bool CUSBCECAdapterCommunication::SetControlledMode(bool controlled)
 636 {
 637   return IsOpen() ? m_commands->SetControlledMode(controlled) : false;
 638 }
 639
 640 uint16_t CUSBCECAdapterCommunication::GetPhysicalAddress(void)
 641 {
 642   uint16_t iPA(0);
 643
 644   // try to get the PA from ADL
 645 #if defined(HAS_ADL_EDID_PARSER)
 646   {
 647     LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - trying to get the physical address via ADL", __FUNCTION__);
 648     CADLEdidParser adl;
 649     iPA = adl.GetPhysicalAddress();
 650     LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - ADL returned physical address %04x", __FUNCTION__, iPA);
 651   }
 652 #endif
 653
 654   // try to get the PA from the nvidia driver
 655 #if defined(HAS_NVIDIA_EDID_PARSER)
 656   if (iPA == 0)
 657   {
 658     LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - trying to get the physical address via nvidia driver", __FUNCTION__);
 659     CNVEdidParser nv;
 660     iPA = nv.GetPhysicalAddress();
 661     LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - nvidia driver returned physical address %04x", __FUNCTION__, iPA);
 662   }
 663 #endif
 664
 665   // try to get the PA from the OS
 666   if (iPA == 0)
 667   {
 668     LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - trying to get the physical address from the OS", __FUNCTION__);
 669     iPA = CEDIDParser::GetPhysicalAddress();
 670     LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - OS returned physical address %04x", __FUNCTION__, iPA);
 671   }
 672
 673   return iPA;
 674 }
 675
 676 void *CAdapterPingThread::Process(void)
 677 {
 678   while (!IsStopped())
 679   {
 680     if (m_timeout.TimeLeft() == 0)
 681     {
 682       /* reinit the timeout */
 683       m_timeout.Init(CEC_ADAPTER_PING_TIMEOUT);
 684
 685       /* send a ping to the adapter */
 686       bool bPinged(false);
 687       int iFailedCounter(0);
 688       while (!bPinged && iFailedCounter < 3)
 689       {
 690         if (!m_com->PingAdapter())
 691         {
 692           /* sleep and retry */
 693           Sleep(CEC_DEFAULT_TRANSMIT_RETRY_WAIT);
 694           ++iFailedCounter;
 695         }
 696         else
 697         {
 698           bPinged = true;
 699         }
 700       }
 701
 702       if (iFailedCounter == 3)
 703       {
 704         /* failed to ping the adapter 3 times in a row. something must be wrong with the connection */
 705         m_com->LIB_CEC->AddLog(CEC_LOG_ERROR, "failed to ping the adapter 3 times in a row. closing the connection.");
 706         m_com->StopThread(false);
 707         break;
 708       }
 709     }
 710
 711     Sleep(5);
 712   }
 713   return NULL;
 714 }
 715
 716 void CAdapterEepromWriteThread::Stop(void)
 717 {
 718   StopThread(-1);
 719   {
 720     CLockObject lock(m_mutex);
 721     if (m_iScheduleEepromWrite > 0)
 722       m_com->LIB_CEC->AddLog(CEC_LOG_WARNING, "write thread stopped while a write was queued");
 723     m_condition.Signal();
 724   }
 725   StopThread();
 726 }
 727
 728 void *CAdapterEepromWriteThread::Process(void)
 729 {
 730   while (!IsStopped())
 731   {
 732     CLockObject lock(m_mutex);
 733     if ((m_iScheduleEepromWrite > 0 && m_iScheduleEepromWrite < GetTimeMs()) ||
 734         m_condition.Wait(m_mutex, m_bWrite, 100))
 735     {
 736       m_bWrite = false;
 737       if (m_com->m_commands->WriteEEPROM())
 738       {
 739         m_iLastEepromWrite = GetTimeMs();
 740         m_iScheduleEepromWrite = 0;
 741       }
 742       else
 743       {
 744         m_iScheduleEepromWrite = GetTimeMs() + CEC_ADAPTER_EEPROM_WRITE_RETRY;
 745       }
 746     }
 747   }
 748   return NULL;
 749 }
 750
 751 bool CAdapterEepromWriteThread::Write(void)
 752 {
 753   CLockObject lock(m_mutex);
 754   if (m_iScheduleEepromWrite == 0)
 755   {
 756     int64_t iNow = GetTimeMs();
 757     if (m_iLastEepromWrite + CEC_ADAPTER_EEPROM_WRITE_INTERVAL > iNow)
 758     {
 759       m_com->LIB_CEC->AddLog(CEC_LOG_DEBUG, "delaying eeprom write by %ld ms", m_iLastEepromWrite + CEC_ADAPTER_EEPROM_WRITE_INTERVAL - iNow);
 760       m_iScheduleEepromWrite = m_iLastEepromWrite + CEC_ADAPTER_EEPROM_WRITE_INTERVAL;
 761     }
 762     else
 763     {
 764       m_bWrite = true;
 765       m_condition.Signal();
 766     }
 767   }
 768   return true;
 769 }