src/lib/adapter/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 "USBCECAdapterCommunication.h"
  34 #include "../platform/sockets/serialport.h"
  35 #include "../platform/util/timeutils.h"
  36 #include "../LibCEC.h"
  37 #include "../CECProcessor.h"
  38
  39 using namespace std;
  40 using namespace CEC;
  41 using namespace PLATFORM;
  42
  43 #define CEC_ADAPTER_PING_TIMEOUT 15000
  44
  45 void *CUSBCECAdapterProcessor::Process(void)
  46 {
  47   cec_command command;
  48   while (!IsStopped())
  49   {
  50     if (m_inBuffer.Pop(command))
  51       m_callback->OnCommandReceived(command);
  52     Sleep(5);
  53   }
  54
  55   return NULL;
  56 }
  57
  58 void CUSBCECAdapterProcessor::AddCommand(cec_command command)
  59 {
  60   m_inBuffer.Push(command);
  61 }
  62
  63 CUSBCECAdapterCommunication::CUSBCECAdapterCommunication(CCECProcessor *processor, const char *strPort, uint16_t iBaudRate /* = 38400 */) :
  64     m_port(NULL),
  65     m_processor(processor),
  66     m_bHasData(false),
  67     m_iLineTimeout(0),
  68     m_iFirmwareVersion(CEC_FW_VERSION_UNKNOWN),
  69     m_lastInitiator(CECDEVICE_UNKNOWN),
  70     m_bNextIsEscaped(false),
  71     m_bGotStart(false),
  72     m_messageProcessor(NULL),
  73     m_bInitialised(false)
  74 {
  75   m_port = new CSerialPort(strPort, iBaudRate);
  76 }
  77
  78 CUSBCECAdapterCommunication::~CUSBCECAdapterCommunication(void)
  79 {
  80   Close();
  81 }
  82
  83 bool CUSBCECAdapterCommunication::CheckAdapter(uint32_t iTimeoutMs /* = 10000 */)
  84 {
  85   bool bReturn(false);
  86   uint64_t iNow = GetTimeMs();
  87   uint64_t iTarget = iTimeoutMs > 0 ? iNow + iTimeoutMs : iNow + CEC_DEFAULT_TRANSMIT_WAIT;
  88
  89   /* try to ping the adapter */
  90   bool bPinged(false);
  91   unsigned iPingTry(0);
  92   while (iNow < iTarget && (bPinged = PingAdapter()) == false)
  93   {
  94     CLibCEC::AddLog(CEC_LOG_ERROR, "the adapter did not respond correctly to a ping (try %d)", ++iPingTry);
  95     CEvent::Sleep(500);
  96     iNow = GetTimeMs();
  97   }
  98
  99   /* try to read the firmware version */
 100   m_iFirmwareVersion = CEC_FW_VERSION_UNKNOWN;
 101   unsigned iFwVersionTry(0);
 102   while (bPinged && iNow < iTarget && (m_iFirmwareVersion = GetFirmwareVersion()) == CEC_FW_VERSION_UNKNOWN && iFwVersionTry < 3)
 103   {
 104     CLibCEC::AddLog(CEC_LOG_WARNING, "the adapter did not respond with a correct firmware version (try %d)", ++iFwVersionTry);
 105     CEvent::Sleep(500);
 106     iNow = GetTimeMs();
 107   }
 108
 109   if (m_iFirmwareVersion == CEC_FW_VERSION_UNKNOWN)
 110   {
 111     CLibCEC::AddLog(CEC_LOG_DEBUG, "defaulting to firmware version 1");
 112     m_iFirmwareVersion = 1;
 113   }
 114
 115   if (m_iFirmwareVersion >= 2)
 116   {
 117     /* try to set controlled mode */
 118     unsigned iControlledTry(0);
 119     bool bControlled(false);
 120     while (iNow < iTarget && (bControlled = SetControlledMode(true)) == false)
 121     {
 122       CLibCEC::AddLog(CEC_LOG_ERROR, "the adapter did not respond correctly to setting controlled mode (try %d)", ++iControlledTry);
 123       CEvent::Sleep(500);
 124       iNow = GetTimeMs();
 125     }
 126     bReturn = bControlled;
 127   }
 128   else
 129     bReturn = true;
 130
 131   {
 132     CLockObject lock(m_mutex);
 133     m_bInitialised = bReturn;
 134   }
 135
 136   return bReturn;
 137 }
 138
 139 bool CUSBCECAdapterCommunication::Open(IAdapterCommunicationCallback *cb, uint32_t iTimeoutMs /* = 10000 */, bool bSkipChecks /* = false */)
 140 {
 141   uint64_t iNow = GetTimeMs();
 142   uint64_t iTimeout = iNow + iTimeoutMs;
 143
 144   {
 145     CLockObject lock(m_mutex);
 146
 147     if (!m_port)
 148     {
 149       CLibCEC::AddLog(CEC_LOG_ERROR, "port is NULL");
 150       return false;
 151     }
 152
 153     if (IsOpen())
 154     {
 155       CLibCEC::AddLog(CEC_LOG_ERROR, "port is already open");
 156       return true;
 157     }
 158
 159     m_callback = cb;
 160     CStdString strError;
 161     bool bConnected(false);
 162     while (!bConnected && iNow < iTimeout)
 163     {
 164       if ((bConnected = m_port->Open(iTimeout)) == false)
 165       {
 166         strError.Format("error opening serial port '%s': %s", m_port->GetName().c_str(), m_port->GetError().c_str());
 167         Sleep(250);
 168         iNow = GetTimeMs();
 169       }
 170     }
 171
 172     if (!bConnected)
 173     {
 174       CLibCEC::AddLog(CEC_LOG_ERROR, strError);
 175       return false;
 176     }
 177
 178     CLibCEC::AddLog(CEC_LOG_DEBUG, "connection opened, clearing any previous input and waiting for active transmissions to end before starting");
 179
 180     if (!bSkipChecks)
 181     {
 182       //clear any input bytes
 183       uint8_t buff[1024];
 184       while (m_port->Read(buff, 1024, 100) > 0)
 185       {
 186         CLibCEC::AddLog(CEC_LOG_DEBUG, "data received, clearing it");
 187         Sleep(250);
 188       }
 189     }
 190   }
 191
 192   if (!bSkipChecks && !CheckAdapter())
 193   {
 194     CLibCEC::AddLog(CEC_LOG_ERROR, "the adapter failed to pass basic checks");
 195     return false;
 196   }
 197   else
 198   {
 199     if (CreateThread())
 200     {
 201       CLibCEC::AddLog(CEC_LOG_DEBUG, "communication thread started");
 202       return true;
 203     }
 204     else
 205     {
 206       CLibCEC::AddLog(CEC_LOG_ERROR, "could not create a communication thread");
 207     }
 208   }
 209
 210   return false;
 211 }
 212
 213 void CUSBCECAdapterCommunication::Close(void)
 214 {
 215   StopThread();
 216 }
 217
 218 void *CUSBCECAdapterCommunication::Process(void)
 219 {
 220   m_messageProcessor = new CUSBCECAdapterProcessor(m_callback);
 221   m_messageProcessor->CreateThread();
 222
 223   cec_command command;
 224   command.Clear();
 225   bool bCommandReceived(false);
 226   CTimeout pingTimeout(CEC_ADAPTER_PING_TIMEOUT);
 227   while (!IsStopped())
 228   {
 229     {
 230       CLockObject lock(m_mutex);
 231       ReadFromDevice(50);
 232       bCommandReceived = m_callback && Read(command, 0) && m_bInitialised;
 233     }
 234
 235     /* push the next command to the callback method if there is one */
 236     if (!IsStopped() && bCommandReceived)
 237       m_messageProcessor->AddCommand(command);
 238
 239     /* ping the adapter every 15 seconds */
 240     if (pingTimeout.TimeLeft() == 0)
 241     {
 242       pingTimeout.Init(CEC_ADAPTER_PING_TIMEOUT);
 243       PingAdapter();
 244     }
 245
 246     if (!IsStopped())
 247     {
 248       Sleep(5);
 249       WriteNextCommand();
 250     }
 251   }
 252
 253   /* stop the message processor */
 254   m_messageProcessor->StopThread();
 255   delete m_messageProcessor;
 256
 257   /* notify all threads that are waiting on messages to be sent */
 258   CCECAdapterMessage *msg(NULL);
 259   while (m_outBuffer.Pop(msg))
 260     msg->event.Broadcast();
 261
 262   /* set the ackmask to 0 before closing the connection */
 263   SetAckMaskInternal(0, true);
 264
 265   if (m_iFirmwareVersion >= 2)
 266     SetControlledMode(false);
 267
 268   if (m_port)
 269   {
 270     delete m_port;
 271     m_port = NULL;
 272   }
 273
 274   return NULL;
 275 }
 276
 277 cec_adapter_message_state CUSBCECAdapterCommunication::Write(const cec_command &data, uint8_t iMaxTries, uint8_t iLineTimeout /* = 3 */, uint8_t iRetryLineTimeout /* = 3 */)
 278 {
 279   cec_adapter_message_state retVal(ADAPTER_MESSAGE_STATE_UNKNOWN);
 280   if (!IsRunning())
 281     return retVal;
 282
 283   CCECAdapterMessage *output = new CCECAdapterMessage(data);
 284
 285   /* set the number of retries */
 286   if (data.opcode == CEC_OPCODE_NONE) //TODO
 287     output->maxTries = 1;
 288   else if (data.initiator != CECDEVICE_BROADCAST)
 289     output->maxTries = iMaxTries;
 290
 291   output->lineTimeout = iLineTimeout;
 292   output->retryTimeout = iRetryLineTimeout;
 293   output->tries = 0;
 294
 295   bool bRetry(true);
 296   while (bRetry && ++output->tries < output->maxTries)
 297   {
 298     bRetry = (!Write(output) || output->NeedsRetry()) && output->transmit_timeout > 0;
 299     if (bRetry)
 300       Sleep(CEC_DEFAULT_TRANSMIT_RETRY_WAIT);
 301   }
 302   retVal = output->state;
 303
 304   delete output;
 305   return retVal;
 306 }
 307
 308 bool CUSBCECAdapterCommunication::Write(CCECAdapterMessage *data)
 309 {
 310   data->state = ADAPTER_MESSAGE_STATE_WAITING_TO_BE_SENT;
 311   m_outBuffer.Push(data);
 312   data->event.Wait(5000);
 313
 314   if ((data->expectControllerAck && data->state != ADAPTER_MESSAGE_STATE_SENT_ACKED) ||
 315       (!data->expectControllerAck && data->state != ADAPTER_MESSAGE_STATE_SENT))
 316   {
 317     CLibCEC::AddLog(CEC_LOG_DEBUG, "command was not %s", data->state == ADAPTER_MESSAGE_STATE_SENT_NOT_ACKED ? "acked" : "sent");
 318     return false;
 319   }
 320
 321   return true;
 322 }
 323
 324 bool CUSBCECAdapterCommunication::Read(cec_command &command, uint32_t iTimeout)
 325 {
 326   if (!IsRunning())
 327     return false;
 328
 329   CCECAdapterMessage msg;
 330   if (Read(msg, iTimeout))
 331   {
 332     if (ParseMessage(msg))
 333     {
 334       command = m_currentframe;
 335       m_currentframe.Clear();
 336       return true;
 337     }
 338   }
 339   return false;
 340 }
 341
 342 bool CUSBCECAdapterCommunication::Read(CCECAdapterMessage &msg, uint32_t iTimeout)
 343 {
 344   CLockObject lock(m_mutex);
 345
 346   msg.Clear();
 347   CCECAdapterMessage *buf(NULL);
 348
 349   if (!m_inBuffer.Pop(buf))
 350   {
 351     if (iTimeout == 0 || !m_rcvCondition.Wait(m_mutex, m_bHasData, iTimeout))
 352       return false;
 353     m_inBuffer.Pop(buf);
 354     m_bHasData = !m_inBuffer.IsEmpty();
 355   }
 356
 357   if (buf)
 358   {
 359     msg.packet = buf->packet;
 360     msg.state = ADAPTER_MESSAGE_STATE_INCOMING;
 361     delete buf;
 362     return true;
 363   }
 364   return false;
 365 }
 366
 367 CStdString CUSBCECAdapterCommunication::GetError(void) const
 368 {
 369   CStdString strError;
 370   strError = m_port->GetError();
 371   return strError;
 372 }
 373
 374 bool CUSBCECAdapterCommunication::StartBootloader(void)
 375 {
 376   bool bReturn(false);
 377   if (!IsRunning())
 378     return bReturn;
 379
 380   CLibCEC::AddLog(CEC_LOG_DEBUG, "starting the bootloader");
 381
 382   CCECAdapterMessage params;
 383   return SendCommand(MSGCODE_START_BOOTLOADER, params, false);
 384 }
 385
 386 bool CUSBCECAdapterCommunication::PingAdapter(void)
 387 {
 388   CLockObject lock(m_mutex);
 389   CLibCEC::AddLog(CEC_LOG_DEBUG, "sending ping");
 390
 391   CCECAdapterMessage params;
 392   return SendCommand(MSGCODE_PING, params);
 393 }
 394
 395 bool CUSBCECAdapterCommunication::ParseMessage(const CCECAdapterMessage &msg)
 396 {
 397   bool bEom(false);
 398   bool bIsError(msg.IsError());
 399
 400   if (msg.IsEmpty())
 401     return bEom;
 402
 403   CLockObject adapterLock(m_mutex);
 404   switch(msg.Message())
 405   {
 406   case MSGCODE_FRAME_START:
 407     {
 408       m_currentframe.Clear();
 409       if (msg.Size() >= 2)
 410       {
 411         m_currentframe.initiator   = msg.Initiator();
 412         m_currentframe.destination = msg.Destination();
 413         m_currentframe.ack         = msg.IsACK();
 414         m_currentframe.eom         = msg.IsEOM();
 415       }
 416       if (m_currentframe.ack == 0x1)
 417       {
 418         m_lastInitiator    = m_currentframe.initiator;
 419         m_currentframe.eom = 1;
 420         bEom = true;
 421       }
 422     }
 423     break;
 424   case MSGCODE_RECEIVE_FAILED:
 425     {
 426       m_currentframe.Clear();
 427       if (m_lastInitiator != CECDEVICE_UNKNOWN)
 428         bIsError = m_processor->HandleReceiveFailed(m_lastInitiator);
 429     }
 430     break;
 431   case MSGCODE_FRAME_DATA:
 432     {
 433       if (msg.Size() >= 2)
 434       {
 435         m_currentframe.PushBack(msg[1]);
 436         m_currentframe.eom = msg.IsEOM();
 437       }
 438     }
 439     break;
 440   default:
 441     break;
 442   }
 443
 444   CLibCEC::AddLog(bIsError ? CEC_LOG_WARNING : CEC_LOG_DEBUG, msg.ToString());
 445   return msg.IsEOM() || bEom;
 446 }
 447
 448 uint16_t CUSBCECAdapterCommunication::GetFirmwareVersion(void)
 449 {
 450   uint16_t iReturn(m_iFirmwareVersion);
 451
 452   if (iReturn == CEC_FW_VERSION_UNKNOWN)
 453   {
 454     CLockObject lock(m_mutex);
 455     CLibCEC::AddLog(CEC_LOG_DEBUG, "requesting the firmware version");
 456     cec_datapacket response = GetSetting(MSGCODE_FIRMWARE_VERSION, 2);
 457     if (response.size == 2)
 458     {
 459       m_iFirmwareVersion = (response[0] << 8 | response[1]);
 460       iReturn = m_iFirmwareVersion;
 461       CLibCEC::AddLog(CEC_LOG_DEBUG, "firmware version %d", m_iFirmwareVersion);
 462     }
 463   }
 464
 465   return iReturn;
 466 }
 467
 468 bool CUSBCECAdapterCommunication::SetLineTimeout(uint8_t iTimeout)
 469 {
 470   m_iLineTimeout = iTimeout;
 471   bool bReturn(m_iLineTimeout != iTimeout);
 472
 473   if (!bReturn)
 474   {
 475     CLibCEC::AddLog(CEC_LOG_DEBUG, "setting the line timeout to %d", iTimeout);
 476     CCECAdapterMessage params;
 477     params.PushEscaped(iTimeout);
 478     bReturn = SendCommand(MSGCODE_TRANSMIT_IDLETIME, params);
 479   }
 480
 481   return bReturn;
 482 }
 483
 484 bool CUSBCECAdapterCommunication::SetAckMask(uint16_t iMask)
 485 {
 486   return SetAckMaskInternal(iMask, IsRunning());
 487 }
 488
 489 bool CUSBCECAdapterCommunication::SetAckMaskInternal(uint16_t iMask, bool bWriteDirectly /* = false */)
 490 {
 491   CLibCEC::AddLog(CEC_LOG_DEBUG, "setting ackmask to %2x", iMask);
 492
 493   CCECAdapterMessage params;
 494   params.PushEscaped(iMask >> 8);
 495   params.PushEscaped((uint8_t)iMask);
 496   return SendCommand(MSGCODE_SET_ACK_MASK, params, true, false, bWriteDirectly);
 497 }
 498
 499 bool CUSBCECAdapterCommunication::PersistConfiguration(libcec_configuration *configuration)
 500 {
 501   if (m_iFirmwareVersion < 2)
 502     return false;
 503
 504   bool bReturn(true);
 505   bReturn &= SetSettingAutoEnabled(true);
 506   bReturn &= SetSettingDeviceType(CLibCEC::GetType(configuration->logicalAddresses.primary));
 507   bReturn &= SetSettingDefaultLogicalAddress(configuration->logicalAddresses.primary);
 508   bReturn &= SetSettingLogicalAddressMask(CLibCEC::GetMaskForType(configuration->logicalAddresses.primary));
 509   bReturn &= SetSettingPhysicalAddress(configuration->iPhysicalAddress);
 510   bReturn &= SetSettingCECVersion(CEC_VERSION_1_3A);
 511   bReturn &= SetSettingOSDName(configuration->strDeviceName);
 512   if (bReturn)
 513     bReturn = WriteEEPROM();
 514   return bReturn;
 515 }
 516
 517 bool CUSBCECAdapterCommunication::GetConfiguration(libcec_configuration *configuration)
 518 {
 519   if (m_iFirmwareVersion < 2)
 520     return false;
 521
 522   bool bReturn(true);
 523   cec_device_type type;
 524   if (GetSettingDeviceType(type))
 525   {
 526     CLibCEC::AddLog(CEC_LOG_DEBUG, "using persisted device type setting %s", m_processor->ToString(type));
 527     configuration->deviceTypes.Clear();
 528     configuration->deviceTypes.Add(type);
 529   }
 530   else
 531   {
 532     CLibCEC::AddLog(CEC_LOG_DEBUG, "no persisted device type setting");
 533     bReturn = false;
 534   }
 535
 536   if (GetSettingPhysicalAddress(configuration->iPhysicalAddress))
 537   {
 538     CLibCEC::AddLog(CEC_LOG_DEBUG, "using persisted physical address setting %4x", configuration->iPhysicalAddress);
 539   }
 540   else
 541   {
 542     CLibCEC::AddLog(CEC_LOG_DEBUG, "no persisted physical address setting");
 543     bReturn = false;
 544   }
 545
 546   CStdString strDeviceName;
 547   if (GetSettingOSDName(strDeviceName))
 548   {
 549     snprintf(configuration->strDeviceName, 13, "%s", strDeviceName.c_str());
 550     CLibCEC::AddLog(CEC_LOG_DEBUG, "using persisted device name setting %s", configuration->strDeviceName);
 551   }
 552   else
 553   {
 554     CLibCEC::AddLog(CEC_LOG_DEBUG, "no persisted device name setting");
 555     bReturn = false;
 556   }
 557
 558   // don't read the following settings:
 559   // - auto enabled (always enabled)
 560   // - default logical address (autodetected)
 561   // - logical address mask (autodetected)
 562   // - CEC version (1.3a)
 563
 564   // TODO to be added to the firmware:
 565   // - base device (4 bits)
 566   // - HDMI port number (4 bits)
 567   // - TV vendor id (12 bits)
 568   // - wake devices (8 bits)
 569   // - standby devices (8 bits)
 570   // - use TV menu language (1 bit)
 571   // - activate source (1 bit)
 572   // - power off screensaver (1 bit)
 573   // - power off on standby (1 bit)
 574   // - send inactive source (1 bit)
 575   return bReturn;
 576 }
 577
 578 bool CUSBCECAdapterCommunication::SetControlledMode(bool controlled)
 579 {
 580   CLockObject lock(m_mutex);
 581   CLibCEC::AddLog(CEC_LOG_DEBUG, "turning controlled mode %s", controlled ? "on" : "off");
 582
 583   CCECAdapterMessage params;
 584   params.PushEscaped(controlled ? 1 : 0);
 585   return SendCommand(MSGCODE_SET_CONTROLLED, params);
 586 }
 587
 588 bool CUSBCECAdapterCommunication::SetSettingAutoEnabled(bool enabled)
 589 {
 590   CLockObject lock(m_mutex);
 591   CLibCEC::AddLog(CEC_LOG_DEBUG, "turning autonomous mode %s", enabled ? "on" : "off");
 592
 593   CCECAdapterMessage params;
 594   params.PushEscaped(enabled ? 1 : 0);
 595   return SendCommand(MSGCODE_SET_AUTO_ENABLED, params);
 596 }
 597
 598 bool CUSBCECAdapterCommunication::GetSettingAutoEnabled(bool &enabled)
 599 {
 600   CLockObject lock(m_mutex);
 601   CLibCEC::AddLog(CEC_LOG_DEBUG, "requesting autonomous mode setting");
 602
 603   cec_datapacket response = GetSetting(MSGCODE_GET_AUTO_ENABLED, 1);
 604   if (response.size == 1)
 605   {
 606     enabled = response[0] == 1;
 607     return true;
 608   }
 609   return false;
 610 }
 611
 612 bool CUSBCECAdapterCommunication::SetSettingDeviceType(cec_device_type type)
 613 {
 614   CLockObject lock(m_mutex);
 615   CLibCEC::AddLog(CEC_LOG_DEBUG, "setting the device type to %1X", (uint8_t)type);
 616
 617   CCECAdapterMessage params;
 618   params.PushEscaped((uint8_t)type);
 619   return SendCommand(MSGCODE_SET_DEVICE_TYPE, params);
 620 }
 621
 622 bool CUSBCECAdapterCommunication::GetSettingDeviceType(cec_device_type &value)
 623 {
 624   CLockObject lock(m_mutex);
 625   CLibCEC::AddLog(CEC_LOG_DEBUG, "requesting device type setting");
 626
 627   cec_datapacket response = GetSetting(MSGCODE_GET_DEVICE_TYPE, 1);
 628   if (response.size == 1)
 629   {
 630     value = (cec_device_type)response[0];
 631     return true;
 632   }
 633   return false;
 634 }
 635
 636 bool CUSBCECAdapterCommunication::SetSettingDefaultLogicalAddress(cec_logical_address address)
 637 {
 638   CLockObject lock(m_mutex);
 639   CLibCEC::AddLog(CEC_LOG_DEBUG, "setting the default logical address to %1X", address);
 640
 641   CCECAdapterMessage params;
 642   params.PushEscaped((uint8_t)address);
 643   return SendCommand(MSGCODE_SET_DEFAULT_LOGICAL_ADDRESS, params);
 644 }
 645
 646 bool CUSBCECAdapterCommunication::GetSettingDefaultLogicalAddress(cec_logical_address &address)
 647 {
 648   CLockObject lock(m_mutex);
 649   CLibCEC::AddLog(CEC_LOG_DEBUG, "requesting default logical address setting");
 650
 651   cec_datapacket response = GetSetting(MSGCODE_GET_DEFAULT_LOGICAL_ADDRESS, 1);
 652   if (response.size == 1)
 653   {
 654     address = (cec_logical_address)response[0];
 655     return true;
 656   }
 657   return false;
 658 }
 659
 660 bool CUSBCECAdapterCommunication::SetSettingLogicalAddressMask(uint16_t iMask)
 661 {
 662   CLockObject lock(m_mutex);
 663   CLibCEC::AddLog(CEC_LOG_DEBUG, "setting the logical address mask to %2X", iMask);
 664
 665   CCECAdapterMessage params;
 666   params.PushEscaped(iMask >> 8);
 667   params.PushEscaped((uint8_t)iMask);
 668   return SendCommand(MSGCODE_SET_LOGICAL_ADDRESS_MASK, params);
 669 }
 670
 671 bool CUSBCECAdapterCommunication::GetSettingLogicalAddressMask(uint16_t &iMask)
 672 {
 673   CLockObject lock(m_mutex);
 674   CLibCEC::AddLog(CEC_LOG_DEBUG, "requesting logical address mask setting");
 675
 676   cec_datapacket response = GetSetting(MSGCODE_GET_LOGICAL_ADDRESS_MASK, 2);
 677   if (response.size == 2)
 678   {
 679     iMask = ((uint16_t)response[0] << 8) | ((uint16_t)response[1]);
 680     return true;
 681   }
 682   return false;
 683 }
 684
 685 bool CUSBCECAdapterCommunication::SetSettingPhysicalAddress(uint16_t iPhysicalAddress)
 686 {
 687   CLockObject lock(m_mutex);
 688   CLibCEC::AddLog(CEC_LOG_DEBUG, "setting the physical address to %04X", iPhysicalAddress);
 689
 690   CCECAdapterMessage params;
 691   params.PushEscaped(iPhysicalAddress >> 8);
 692   params.PushEscaped((uint8_t)iPhysicalAddress);
 693   return SendCommand(MSGCODE_SET_PHYSICAL_ADDRESS, params);
 694 }
 695
 696 bool CUSBCECAdapterCommunication::GetSettingPhysicalAddress(uint16_t &iPhysicalAddress)
 697 {
 698   CLockObject lock(m_mutex);
 699   CLibCEC::AddLog(CEC_LOG_DEBUG, "requesting physical address setting");
 700
 701   cec_datapacket response = GetSetting(MSGCODE_GET_PHYSICAL_ADDRESS, 2);
 702   if (response.size == 2)
 703   {
 704     iPhysicalAddress = ((uint16_t)response[0] << 8) | ((uint16_t)response[1]);
 705     return true;
 706   }
 707   return false;
 708 }
 709
 710 bool CUSBCECAdapterCommunication::SetSettingCECVersion(cec_version version)
 711 {
 712   CLockObject lock(m_mutex);
 713   CLibCEC::AddLog(CEC_LOG_DEBUG, "setting the CEC version to %s", CLibCEC::GetInstance()->ToString(version));
 714
 715   CCECAdapterMessage params;
 716   params.PushEscaped((uint8_t)version);
 717   return SendCommand(MSGCODE_SET_HDMI_VERSION, params);
 718 }
 719
 720 bool CUSBCECAdapterCommunication::GetSettingCECVersion(cec_version &version)
 721 {
 722   CLockObject lock(m_mutex);
 723   CLibCEC::AddLog(CEC_LOG_DEBUG, "requesting CEC version setting");
 724
 725   cec_datapacket response = GetSetting(MSGCODE_GET_HDMI_VERSION, 1);
 726   if (response.size == 1)
 727   {
 728     version = (cec_version)response[0];
 729     return true;
 730   }
 731   return false;
 732 }
 733
 734 bool CUSBCECAdapterCommunication::SetSettingOSDName(const char *strOSDName)
 735 {
 736   CLockObject lock(m_mutex);
 737   CLibCEC::AddLog(CEC_LOG_DEBUG, "setting the OSD name to %s", strOSDName);
 738
 739   CCECAdapterMessage params;
 740   for (size_t iPtr = 0; iPtr < strlen(strOSDName); iPtr++)
 741     params.PushEscaped(strOSDName[iPtr]);
 742   return SendCommand(MSGCODE_SET_OSD_NAME, params);
 743 }
 744
 745 bool CUSBCECAdapterCommunication::GetSettingOSDName(CStdString &strOSDName)
 746 {
 747   CLockObject lock(m_mutex);
 748   CLibCEC::AddLog(CEC_LOG_DEBUG, "requesting OSD name setting");
 749
 750   cec_datapacket response = GetSetting(MSGCODE_GET_OSD_NAME, 13);
 751   if (response.size == 0)
 752     return false;
 753
 754   char buf[14];
 755   for (uint8_t iPtr = 0; iPtr < response.size && iPtr < 13; iPtr++)
 756     buf[iPtr] = (char)response[iPtr];
 757   buf[response.size] = 0;
 758
 759   strOSDName.Format("%s", buf);
 760   return true;
 761 }
 762
 763 bool CUSBCECAdapterCommunication::WriteEEPROM(void)
 764 {
 765   CLockObject lock(m_mutex);
 766   CLibCEC::AddLog(CEC_LOG_DEBUG, "writing settings in the EEPROM");
 767
 768   CCECAdapterMessage params;
 769   return SendCommand(MSGCODE_WRITE_EEPROM, params);
 770 }
 771
 772 bool CUSBCECAdapterCommunication::IsOpen(void)
 773 {
 774   return !IsStopped() && m_port->IsOpen() && IsRunning();
 775 }
 776
 777 bool CUSBCECAdapterCommunication::WaitForAck(CCECAdapterMessage &message)
 778 {
 779   bool bError(false);
 780   bool bTransmitSucceeded(false);
 781   uint8_t iPacketsLeft(message.isTransmission ? message.Size() / 4 : 1);
 782
 783   int64_t iNow = GetTimeMs();
 784   int64_t iTargetTime = iNow + (message.transmit_timeout <= 5 ? CEC_DEFAULT_TRANSMIT_WAIT : message.transmit_timeout);
 785
 786   while (!bTransmitSucceeded && !bError && iNow < iTargetTime)
 787   {
 788     ReadFromDevice(50);
 789     CCECAdapterMessage msg;
 790     if (!Read(msg, 0))
 791     {
 792       iNow = GetTimeMs();
 793       continue;
 794     }
 795
 796     if (msg.Message() == MSGCODE_FRAME_START && msg.IsACK())
 797     {
 798       m_processor->HandlePoll(msg.Initiator(), msg.Destination());
 799       m_lastInitiator = msg.Initiator();
 800       iNow = GetTimeMs();
 801       continue;
 802     }
 803
 804     if (msg.Message() == MSGCODE_RECEIVE_FAILED &&
 805         m_lastInitiator != CECDEVICE_UNKNOWN &&
 806         m_processor->HandleReceiveFailed(m_lastInitiator))
 807     {
 808       iNow = GetTimeMs();
 809       continue;
 810     }
 811
 812     bError = msg.IsError();
 813     if (bError)
 814     {
 815       message.reply = msg.Message();
 816       CLibCEC::AddLog(CEC_LOG_DEBUG, msg.ToString());
 817     }
 818     else
 819     {
 820       switch(msg.Message())
 821       {
 822       case MSGCODE_COMMAND_ACCEPTED:
 823         if (iPacketsLeft > 0)
 824           iPacketsLeft--;
 825         if (!message.isTransmission && iPacketsLeft == 0)
 826           bTransmitSucceeded = true;
 827         CLibCEC::AddLog(CEC_LOG_DEBUG, "%s - waiting for %d more", msg.ToString().c_str(), iPacketsLeft);
 828         break;
 829       case MSGCODE_TRANSMIT_SUCCEEDED:
 830         CLibCEC::AddLog(CEC_LOG_DEBUG, msg.ToString());
 831         bTransmitSucceeded = (iPacketsLeft == 0);
 832         bError = !bTransmitSucceeded;
 833         message.reply = MSGCODE_TRANSMIT_SUCCEEDED;
 834         break;
 835       default:
 836         // ignore other data while waiting
 837         break;
 838       }
 839
 840       iNow = GetTimeMs();
 841     }
 842   }
 843
 844   message.state = bTransmitSucceeded && !bError ?
 845       ADAPTER_MESSAGE_STATE_SENT_ACKED :
 846       ADAPTER_MESSAGE_STATE_SENT_NOT_ACKED;
 847
 848   return bTransmitSucceeded && !bError;
 849 }
 850
 851 void CUSBCECAdapterCommunication::AddData(uint8_t *data, size_t iLen)
 852 {
 853   CLockObject lock(m_mutex);
 854   for (size_t iPtr = 0; iPtr < iLen; iPtr++)
 855   {
 856     if (!m_bGotStart)
 857     {
 858       if (data[iPtr] == MSGSTART)
 859         m_bGotStart = true;
 860     }
 861     else if (data[iPtr] == MSGSTART) //we found a msgstart before msgend, this is not right, remove
 862     {
 863       if (m_currentAdapterMessage.Size() > 0)
 864         CLibCEC::AddLog(CEC_LOG_WARNING, "received MSGSTART before MSGEND, removing previous buffer contents");
 865       m_currentAdapterMessage.Clear();
 866       m_bGotStart = true;
 867     }
 868     else if (data[iPtr] == MSGEND)
 869     {
 870       CCECAdapterMessage *newMessage = new CCECAdapterMessage;
 871       newMessage->packet = m_currentAdapterMessage.packet;
 872       m_inBuffer.Push(newMessage);
 873       m_currentAdapterMessage.Clear();
 874       m_bGotStart = false;
 875       m_bNextIsEscaped = false;
 876       m_bHasData = true;
 877       m_rcvCondition.Broadcast();
 878     }
 879     else if (m_bNextIsEscaped)
 880     {
 881       m_currentAdapterMessage.PushBack(data[iPtr] + (uint8_t)ESCOFFSET);
 882       m_bNextIsEscaped = false;
 883     }
 884     else if (data[iPtr] == MSGESC)
 885     {
 886       m_bNextIsEscaped = true;
 887     }
 888     else
 889     {
 890       m_currentAdapterMessage.PushBack(data[iPtr]);
 891     }
 892   }
 893 }
 894
 895 bool CUSBCECAdapterCommunication::ReadFromDevice(uint32_t iTimeout, size_t iSize /* = 256 */)
 896 {
 897   ssize_t iBytesRead;
 898   uint8_t buff[256];
 899   if (!m_port)
 900     return false;
 901   if (iSize > 256)
 902     iSize = 256;
 903
 904   CLockObject lock(m_mutex);
 905   iBytesRead = m_port->Read(buff, sizeof(uint8_t) * iSize, iTimeout);
 906   if (iBytesRead < 0 || iBytesRead > 256)
 907   {
 908     CLibCEC::AddLog(CEC_LOG_ERROR, "error reading from serial port: %s", m_port->GetError().c_str());
 909     StopThread(false);
 910     return false;
 911   }
 912   else if (iBytesRead > 0)
 913   {
 914     AddData(buff, iBytesRead);
 915   }
 916
 917   return iBytesRead > 0;
 918 }
 919
 920 void CUSBCECAdapterCommunication::SendMessageToAdapter(CCECAdapterMessage *msg)
 921 {
 922   CLockObject adapterLock(m_mutex);
 923   if (!m_port->IsOpen())
 924   {
 925     CLibCEC::AddLog(CEC_LOG_ERROR, "error writing to serial port: the connection is closed");
 926     msg->state = ADAPTER_MESSAGE_STATE_ERROR;
 927     return;
 928   }
 929
 930   if (msg->isTransmission && (msg->Size() < 2 || msg->At(1) != MSGCODE_TRANSMIT_IDLETIME))
 931   {
 932     if (msg->tries == 1)
 933       SetLineTimeout(msg->lineTimeout);
 934     else
 935       SetLineTimeout(msg->retryTimeout);
 936   }
 937
 938   if (m_port->Write(msg->packet.data, msg->Size()) != (ssize_t) msg->Size())
 939   {
 940     CLibCEC::AddLog(CEC_LOG_ERROR, "error writing to serial port: %s", m_port->GetError().c_str());
 941     msg->state = ADAPTER_MESSAGE_STATE_ERROR;
 942   }
 943   else
 944   {
 945     CLibCEC::AddLog(CEC_LOG_DEBUG, "command sent");
 946     msg->state = ADAPTER_MESSAGE_STATE_SENT;
 947
 948     if (msg->expectControllerAck)
 949     {
 950       if (!WaitForAck(*msg))
 951         CLibCEC::AddLog(CEC_LOG_DEBUG, "did not receive ack");
 952     }
 953   }
 954   msg->event.Signal();
 955 }
 956
 957 void CUSBCECAdapterCommunication::WriteNextCommand(void)
 958 {
 959   CCECAdapterMessage *msg(NULL);
 960   if (m_outBuffer.Pop(msg))
 961     SendMessageToAdapter(msg);
 962 }
 963
 964 CStdString CUSBCECAdapterCommunication::GetPortName(void)
 965 {
 966   CStdString strName;
 967   strName = m_port->GetName();
 968   return strName;
 969 }
 970
 971 bool CUSBCECAdapterCommunication::SendCommand(cec_adapter_messagecode msgCode, CCECAdapterMessage &params, bool bExpectAck /* = true */, bool bIsTransmission /* = false */, bool bSendDirectly /* = true */, bool bIsRetry /* = false */)
 972 {
 973   CLockObject lock(m_mutex);
 974
 975   CCECAdapterMessage *output = new CCECAdapterMessage;
 976
 977   output->PushBack(MSGSTART);
 978   output->PushEscaped((uint8_t)msgCode);
 979   output->Append(params);
 980   output->PushBack(MSGEND);
 981   output->isTransmission = bIsTransmission;
 982   output->expectControllerAck = bExpectAck;
 983
 984   if (bSendDirectly)
 985     SendMessageToAdapter(output);
 986   else
 987     Write(output);
 988
 989   bool bWriteOk = output->state == (output->expectControllerAck ? ADAPTER_MESSAGE_STATE_SENT_ACKED : ADAPTER_MESSAGE_STATE_SENT);
 990   if (!bWriteOk)
 991   {
 992     CLibCEC::AddLog(CEC_LOG_ERROR, "'%s' failed", CCECAdapterMessage::ToString(msgCode));
 993     delete output;
 994
 995     if (!bIsRetry && output->reply == MSGCODE_COMMAND_REJECTED && msgCode != MSGCODE_SET_CONTROLLED)
 996     {
 997       CLibCEC::AddLog(CEC_LOG_DEBUG, "setting controlled mode and retrying");
 998       if (SetControlledMode(true))
 999         return SendCommand(msgCode, params, bExpectAck, bIsTransmission, bSendDirectly, true);
1000     }
1001     return false;
1002   }
1003
1004   delete output;
1005   return true;
1006 }
1007
1008 cec_datapacket CUSBCECAdapterCommunication::GetSetting(cec_adapter_messagecode msgCode, uint8_t iResponseLength)
1009 {
1010   cec_datapacket retVal;
1011   retVal.Clear();
1012
1013   CCECAdapterMessage params;
1014   if (!SendCommand(msgCode, params, false))
1015   {
1016     CLibCEC::AddLog(CEC_LOG_ERROR, "%s failed", CCECAdapterMessage::ToString(msgCode));
1017     return retVal;
1018   }
1019
1020   Sleep(250); // TODO ReadFromDevice() isn't waiting for the timeout to pass on win32
1021   ReadFromDevice(CEC_DEFAULT_TRANSMIT_WAIT, iResponseLength + 3 /* start + msgcode + iResponseLength + end */);
1022   CCECAdapterMessage input;
1023   if (Read(input, 0))
1024   {
1025     if (input.Message() != msgCode)
1026       CLibCEC::AddLog(CEC_LOG_ERROR, "invalid response to %s received (%s)", CCECAdapterMessage::ToString(msgCode), CCECAdapterMessage::ToString(input.Message()));
1027     else
1028     {
1029       for (uint8_t iPtr = 1; iPtr < input.Size(); iPtr++)
1030         retVal.PushBack(input[iPtr]);
1031     }
1032   }
1033   else
1034   {
1035     CLibCEC::AddLog(CEC_LOG_ERROR, "no response to %s received", CCECAdapterMessage::ToString(msgCode));
1036   }
1037
1038   return retVal;
1039 }