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