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