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     if (!IsStopped())
 288       Sleep(5);
 289   }
 290
 291   m_adapterMessageQueue->Clear();
 292   LIB_CEC->AddLog(CEC_LOG_DEBUG, "communication thread ended");
 293   return NULL;
 294 }
 295
 296 bool CUSBCECAdapterCommunication::HandlePoll(const CCECAdapterMessage &msg)
 297 {
 298   bool bIsError(msg.IsError());
 299   cec_adapter_messagecode messageCode(msg.Message());
 300   CLockObject lock(m_mutex);
 301
 302   if (messageCode == MSGCODE_FRAME_START && msg.IsACK())
 303   {
 304     m_lastPollDestination = msg.Destination();
 305     if (msg.Destination() < CECDEVICE_BROADCAST)
 306     {
 307       if (!m_bWaitingForAck[msg.Destination()] && !msg.IsEOM())
 308       {
 309         if (m_callback)
 310           m_callback->HandlePoll(msg.Initiator(), msg.Destination());
 311       }
 312       else
 313         m_bWaitingForAck[msg.Destination()] = false;
 314     }
 315   }
 316   else if (messageCode == MSGCODE_RECEIVE_FAILED)
 317   {
 318     /* hack to suppress warnings when an LG is polling */
 319     if (m_lastPollDestination != CECDEVICE_UNKNOWN)
 320       bIsError = m_callback->HandleReceiveFailed(m_lastPollDestination);
 321   }
 322
 323   return bIsError;
 324 }
 325
 326 void CUSBCECAdapterCommunication::MarkAsWaiting(const cec_logical_address dest)
 327 {
 328   /* mark as waiting for an ack from the destination */
 329   if (dest < CECDEVICE_BROADCAST)
 330   {
 331     CLockObject lock(m_mutex);
 332     m_bWaitingForAck[dest] = true;
 333   }
 334 }
 335
 336 void CUSBCECAdapterCommunication::ClearInputBytes(uint32_t iTimeout /* = CEC_CLEAR_INPUT_DEFAULT_WAIT */)
 337 {
 338   CTimeout timeout(iTimeout);
 339   uint8_t buff[1024];
 340   ssize_t iBytesRead(0);
 341   bool bGotMsgEnd(true);
 342
 343   while (timeout.TimeLeft() > 0 && ((iBytesRead = m_port->Read(buff, 1024, 5)) > 0 || !bGotMsgEnd))
 344   {
 345     bGotMsgEnd = false;
 346     /* if something was received, wait for MSGEND */
 347     for (ssize_t iPtr = 0; iPtr < iBytesRead; iPtr++)
 348       bGotMsgEnd = buff[iPtr] == MSGEND;
 349   }
 350 }
 351
 352 bool CUSBCECAdapterCommunication::SetLineTimeout(uint8_t iTimeout)
 353 {
 354   bool bReturn(true);
 355   bool bChanged(false);
 356
 357   /* only send the command if the timeout changed */
 358   {
 359     CLockObject lock(m_mutex);
 360     bChanged = (m_iLineTimeout != iTimeout);
 361     m_iLineTimeout = iTimeout;
 362   }
 363
 364   if (bChanged)
 365     bReturn = m_commands->SetLineTimeout(iTimeout);
 366
 367   return bReturn;
 368 }
 369
 370 bool CUSBCECAdapterCommunication::WriteToDevice(CCECAdapterMessage *message)
 371 {
 372   CLockObject adapterLock(m_mutex);
 373   if (!IsOpen())
 374   {
 375     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());
 376     message->state = ADAPTER_MESSAGE_STATE_ERROR;
 377     return false;
 378   }
 379
 380   /* write the message */
 381   if (m_port->Write(message->packet.data, message->Size()) != (ssize_t) message->Size())
 382   {
 383     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());
 384     message->state = ADAPTER_MESSAGE_STATE_ERROR;
 385     // this will trigger an alert in the reader thread
 386     m_port->Close();
 387     return false;
 388   }
 389
 390 #ifdef CEC_DEBUGGING
 391   LIB_CEC->AddLog(CEC_LOG_DEBUG, "command '%s' sent", message->IsTranmission() ? "CEC transmission" : CCECAdapterMessage::ToString(message->Message()));
 392 #endif
 393   message->state = ADAPTER_MESSAGE_STATE_SENT;
 394   return true;
 395 }
 396
 397 bool CUSBCECAdapterCommunication::ReadFromDevice(uint32_t iTimeout, size_t iSize /* = 256 */)
 398 {
 399   ssize_t iBytesRead(0);
 400   uint8_t buff[256];
 401   if (iSize > 256)
 402     iSize = 256;
 403
 404   /* read from the serial port */
 405   {
 406     CLockObject lock(m_mutex);
 407     if (!IsOpen())
 408       return false;
 409
 410     do {
 411       /* retry Read() if it was interrupted */
 412       iBytesRead = m_port->Read(buff, sizeof(uint8_t) * iSize, iTimeout);
 413     } while(m_port->GetErrorNumber() == EINTR);
 414
 415
 416     if (m_port->GetErrorNumber())
 417     {
 418       LIB_CEC->AddLog(CEC_LOG_ERROR, "error reading from serial port: %s", m_port->GetError().c_str());
 419       m_port->Close();
 420       return false;
 421     }
 422   }
 423
 424   if (iBytesRead < 0 || iBytesRead > 256)
 425     return false;
 426   else if (iBytesRead > 0)
 427   {
 428     /* add the data to the current frame */
 429     m_adapterMessageQueue->AddData(buff, iBytesRead);
 430   }
 431
 432   return true;
 433 }
 434
 435 CCECAdapterMessage *CUSBCECAdapterCommunication::SendCommand(cec_adapter_messagecode msgCode, CCECAdapterMessage &params, bool bIsRetry /* = false */)
 436 {
 437   if (!IsOpen() || !m_adapterMessageQueue)
 438     return NULL;
 439
 440   /* create the adapter message for this command */
 441   CCECAdapterMessage *output = new CCECAdapterMessage;
 442   output->PushBack(MSGSTART);
 443   output->PushEscaped((uint8_t)msgCode);
 444   output->Append(params);
 445   output->PushBack(MSGEND);
 446
 447   /* write the command */
 448   if (!m_adapterMessageQueue->Write(output))
 449   {
 450     // this will trigger an alert in the reader thread
 451     if (output->state == ADAPTER_MESSAGE_STATE_ERROR)
 452       m_port->Close();
 453     return output;
 454   }
 455   else
 456   {
 457     if (!bIsRetry && output->Reply() == MSGCODE_COMMAND_REJECTED && msgCode != MSGCODE_SET_CONTROLLED &&
 458         msgCode != MSGCODE_GET_BUILDDATE /* same messagecode value had a different meaning in older fw builds */)
 459     {
 460       /* if the controller reported that the command was rejected, and we didn't send the command
 461          to set controlled mode, then the controller probably switched to auto mode. set controlled
 462          mode and retry */
 463       LIB_CEC->AddLog(CEC_LOG_DEBUG, "setting controlled mode and retrying");
 464       delete output;
 465       if (SetControlledMode(true))
 466         return SendCommand(msgCode, params, true);
 467     }
 468   }
 469
 470   return output;
 471 }
 472
 473 bool CUSBCECAdapterCommunication::CheckAdapter(uint32_t iTimeoutMs /* = CEC_DEFAULT_CONNECT_TIMEOUT */)
 474 {
 475   bool bReturn(false);
 476   CTimeout timeout(iTimeoutMs > 0 ? iTimeoutMs : CEC_DEFAULT_TRANSMIT_WAIT);
 477
 478   /* try to ping the adapter */
 479   bool bPinged(false);
 480   unsigned iPingTry(0);
 481   while (timeout.TimeLeft() > 0 && (bPinged = PingAdapter()) == false)
 482   {
 483     LIB_CEC->AddLog(CEC_LOG_ERROR, "the adapter did not respond correctly to a ping (try %d)", ++iPingTry);
 484     CEvent::Sleep(500);
 485   }
 486
 487   /* try to read the firmware version */
 488   if (bPinged && timeout.TimeLeft() > 0 && m_commands->RequestFirmwareVersion() >= 2)
 489   {
 490     /* try to set controlled mode for v2+ firmwares */
 491     unsigned iControlledTry(0);
 492     bool bControlled(false);
 493     while (timeout.TimeLeft() > 0 && (bControlled = SetControlledMode(true)) == false)
 494     {
 495       LIB_CEC->AddLog(CEC_LOG_ERROR, "the adapter did not respond correctly to setting controlled mode (try %d)", ++iControlledTry);
 496       CEvent::Sleep(500);
 497     }
 498     bReturn = bControlled;
 499   }
 500   else
 501     bReturn = true;
 502
 503   if (m_commands->GetFirmwareVersion() >= 2)
 504   {
 505     /* try to read the build date */
 506     m_commands->RequestBuildDate();
 507
 508     /* try to read the adapter type */
 509     m_commands->RequestAdapterType();
 510   }
 511
 512   SetInitialised(bReturn);
 513   return bReturn;
 514 }
 515
 516 bool CUSBCECAdapterCommunication::IsOpen(void)
 517 {
 518   /* thread is not being stopped, the port is open and the thread is running */
 519   return !IsStopped() && m_port->IsOpen() && IsRunning();
 520 }
 521
 522 std::string CUSBCECAdapterCommunication::GetError(void) const
 523 {
 524   return m_port->GetError();
 525 }
 526
 527 void CUSBCECAdapterCommunication::SetInitialised(bool bSetTo /* = true */)
 528 {
 529   CLockObject lock(m_mutex);
 530   m_bInitialised = bSetTo;
 531 }
 532
 533 bool CUSBCECAdapterCommunication::IsInitialised(void)
 534 {
 535   CLockObject lock(m_mutex);
 536   return m_bInitialised;
 537 }
 538
 539 bool CUSBCECAdapterCommunication::StartBootloader(void)
 540 {
 541   if (m_port->IsOpen() && m_commands->StartBootloader())
 542   {
 543     m_port->Close();
 544     return true;
 545   }
 546   return false;
 547 }
 548
 549 bool CUSBCECAdapterCommunication::SetLogicalAddresses(const cec_logical_addresses &addresses)
 550 {
 551   {
 552     CLockObject lock(m_mutex);
 553     if (m_logicalAddresses == addresses)
 554       return true;
 555   }
 556
 557   if (IsOpen() && m_commands->SetAckMask(addresses.AckMask()))
 558   {
 559     CLockObject lock(m_mutex);
 560     m_logicalAddresses = addresses;
 561     return true;
 562   }
 563
 564   LIB_CEC->AddLog(CEC_LOG_DEBUG, "couldn't change the ackmask: the connection is closed");
 565   return false;
 566 }
 567
 568 cec_logical_addresses CUSBCECAdapterCommunication::GetLogicalAddresses(void)
 569 {
 570   cec_logical_addresses addresses;
 571   CLockObject lock(m_mutex);
 572   addresses = m_logicalAddresses;
 573   return addresses;
 574 }
 575
 576 bool CUSBCECAdapterCommunication::PingAdapter(void)
 577 {
 578   return IsOpen() ? m_commands->PingAdapter() : false;
 579 }
 580
 581 uint16_t CUSBCECAdapterCommunication::GetFirmwareVersion(void)
 582 {
 583   return m_commands ? m_commands->GetFirmwareVersion() : CEC_FW_VERSION_UNKNOWN;
 584 }
 585
 586 uint32_t CUSBCECAdapterCommunication::GetFirmwareBuildDate(void)
 587 {
 588   uint32_t iBuildDate(0);
 589   if (m_commands)
 590     iBuildDate = m_commands->GetPersistedBuildDate();
 591   if (iBuildDate == 0 && IsOpen())
 592     iBuildDate = m_commands->RequestBuildDate();
 593
 594   return iBuildDate;
 595 }
 596
 597 cec_adapter_type CUSBCECAdapterCommunication::GetAdapterType(void)
 598 {
 599   cec_adapter_type type(ADAPTERTYPE_UNKNOWN);
 600   if (m_commands)
 601     type = (cec_adapter_type)m_commands->GetPersistedAdapterType();
 602   if (type == ADAPTERTYPE_UNKNOWN && IsOpen())
 603     type = (cec_adapter_type)m_commands->RequestAdapterType();
 604
 605   return type;
 606 }
 607
 608 bool CUSBCECAdapterCommunication::ProvidesExtendedResponse(void)
 609 {
 610   uint32_t iBuildDate(0);
 611   if (m_commands)
 612     iBuildDate = m_commands->GetPersistedBuildDate();
 613
 614   return iBuildDate >= CEC_FW_DATE_EXTENDED_RESPONSE;
 615 }
 616
 617 uint16_t CUSBCECAdapterCommunication::GetAdapterVendorId(void) const
 618 {
 619   return CEC_VID;
 620 }
 621
 622 uint16_t CUSBCECAdapterCommunication::GetAdapterProductId(void) const
 623 {
 624   uint32_t iBuildDate(0);
 625   if (m_commands)
 626     iBuildDate = m_commands->GetPersistedBuildDate();
 627
 628   return iBuildDate >= CEC_FW_DATE_DESCRIPTOR2 ? CEC_PID2 : CEC_PID;
 629 }
 630
 631 bool CUSBCECAdapterCommunication::IsRunningLatestFirmware(void)
 632 {
 633   return GetFirmwareBuildDate() >= CEC_LATEST_ADAPTER_FW_DATE &&
 634       GetFirmwareVersion() >= CEC_LATEST_ADAPTER_FW_VERSION;
 635 }
 636
 637 bool CUSBCECAdapterCommunication::PersistConfiguration(const libcec_configuration &configuration)
 638 {
 639   return IsOpen() ?
 640       m_commands->PersistConfiguration(configuration) && m_eepromWriteThread->Write() :
 641       false;
 642 }
 643
 644 bool CUSBCECAdapterCommunication::GetConfiguration(libcec_configuration &configuration)
 645 {
 646   return IsOpen() ? m_commands->GetConfiguration(configuration) : false;
 647 }
 648
 649 std::string CUSBCECAdapterCommunication::GetPortName(void)
 650 {
 651   return m_port->GetName();
 652 }
 653
 654 bool CUSBCECAdapterCommunication::SetControlledMode(bool controlled)
 655 {
 656   return IsOpen() ? m_commands->SetControlledMode(controlled) : false;
 657 }
 658
 659 uint16_t CUSBCECAdapterCommunication::GetPhysicalAddress(void)
 660 {
 661   uint16_t iPA(0);
 662
 663   // try to get the PA from ADL
 664 #if defined(HAS_ADL_EDID_PARSER)
 665   {
 666     LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - trying to get the physical address via ADL", __FUNCTION__);
 667     CADLEdidParser adl;
 668     iPA = adl.GetPhysicalAddress();
 669     LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - ADL returned physical address %04x", __FUNCTION__, iPA);
 670   }
 671 #endif
 672
 673   // try to get the PA from the nvidia driver
 674 #if defined(HAS_NVIDIA_EDID_PARSER)
 675   if (iPA == 0)
 676   {
 677     LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - trying to get the physical address via nvidia driver", __FUNCTION__);
 678     CNVEdidParser nv;
 679     iPA = nv.GetPhysicalAddress();
 680     LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - nvidia driver returned physical address %04x", __FUNCTION__, iPA);
 681   }
 682 #endif
 683
 684   // try to get the PA from the OS
 685   if (iPA == 0)
 686   {
 687     LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - trying to get the physical address from the OS", __FUNCTION__);
 688     iPA = CEDIDParser::GetPhysicalAddress();
 689     LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - OS returned physical address %04x", __FUNCTION__, iPA);
 690   }
 691
 692   return iPA;
 693 }
 694
 695 void *CAdapterPingThread::Process(void)
 696 {
 697   while (!IsStopped())
 698   {
 699     if (m_timeout.TimeLeft() == 0)
 700     {
 701       /* reinit the timeout */
 702       m_timeout.Init(CEC_ADAPTER_PING_TIMEOUT);
 703
 704       /* send a ping to the adapter */
 705       bool bPinged(false);
 706       int iFailedCounter(0);
 707       while (!bPinged && iFailedCounter < 3)
 708       {
 709         if (!m_com->PingAdapter())
 710         {
 711           /* sleep and retry */
 712           Sleep(CEC_DEFAULT_TRANSMIT_RETRY_WAIT);
 713           ++iFailedCounter;
 714         }
 715         else
 716         {
 717           bPinged = true;
 718         }
 719       }
 720
 721       if (iFailedCounter == 3)
 722       {
 723         /* failed to ping the adapter 3 times in a row. something must be wrong with the connection */
 724         m_com->LIB_CEC->AddLog(CEC_LOG_ERROR, "failed to ping the adapter 3 times in a row. closing the connection.");
 725         m_com->StopThread(false);
 726         break;
 727       }
 728     }
 729
 730     Sleep(5);
 731   }
 732   return NULL;
 733 }
 734
 735 void CAdapterEepromWriteThread::Stop(void)
 736 {
 737   StopThread(-1);
 738   {
 739     CLockObject lock(m_mutex);
 740     if (m_iScheduleEepromWrite > 0)
 741       m_com->LIB_CEC->AddLog(CEC_LOG_WARNING, "write thread stopped while a write was queued");
 742     m_bWrite = true;
 743     m_condition.Signal();
 744   }
 745   StopThread();
 746 }
 747
 748 void *CAdapterEepromWriteThread::Process(void)
 749 {
 750   while (!IsStopped())
 751   {
 752     CLockObject lock(m_mutex);
 753     if ((m_iScheduleEepromWrite > 0 && m_iScheduleEepromWrite < GetTimeMs()) ||
 754         m_condition.Wait(m_mutex, m_bWrite, 100))
 755     {
 756       if (IsStopped())
 757         break;
 758       m_bWrite = false;
 759       if (m_com->m_commands->WriteEEPROM())
 760       {
 761         m_iLastEepromWrite = GetTimeMs();
 762         m_iScheduleEepromWrite = 0;
 763       }
 764       else
 765       {
 766         m_iScheduleEepromWrite = GetTimeMs() + CEC_ADAPTER_EEPROM_WRITE_RETRY;
 767       }
 768     }
 769   }
 770   return NULL;
 771 }
 772
 773 bool CAdapterEepromWriteThread::Write(void)
 774 {
 775   CLockObject lock(m_mutex);
 776   if (m_iScheduleEepromWrite == 0)
 777   {
 778     int64_t iNow = GetTimeMs();
 779     if (m_iLastEepromWrite + CEC_ADAPTER_EEPROM_WRITE_INTERVAL > iNow)
 780     {
 781       m_com->LIB_CEC->AddLog(CEC_LOG_DEBUG, "delaying eeprom write by %ld ms", m_iLastEepromWrite + CEC_ADAPTER_EEPROM_WRITE_INTERVAL - iNow);
 782       m_iScheduleEepromWrite = m_iLastEepromWrite + CEC_ADAPTER_EEPROM_WRITE_INTERVAL;
 783     }
 784     else
 785     {
 786       m_bWrite = true;
 787       m_condition.Signal();
 788     }
 789   }
 790   return true;
 791 }