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