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   bool bReturn(true);
 491
 492   if (m_iLineTimeout != iTimeout)
 493   {
 494     CLibCEC::AddLog(CEC_LOG_DEBUG, "setting the line timeout to %d", iTimeout);
 495     CCECAdapterMessage params;
 496     params.PushEscaped(iTimeout);
 497     bReturn = SendCommand(MSGCODE_TRANSMIT_IDLETIME, params);
 498     if (bReturn)
 499       m_iLineTimeout = iTimeout;
 500   }
 501
 502   return bReturn;
 503 }
 504
 505 bool CUSBCECAdapterCommunication::SetAckMask(uint16_t iMask)
 506 {
 507   return SetAckMaskInternal(iMask, IsRunning());
 508 }
 509
 510 bool CUSBCECAdapterCommunication::SetAckMaskInternal(uint16_t iMask, bool bWriteDirectly /* = false */)
 511 {
 512   CLibCEC::AddLog(CEC_LOG_DEBUG, "setting ackmask to %2x", iMask);
 513
 514   CCECAdapterMessage params;
 515   params.PushEscaped(iMask >> 8);
 516   params.PushEscaped((uint8_t)iMask);
 517   return SendCommand(MSGCODE_SET_ACK_MASK, params, true, false, bWriteDirectly);
 518 }
 519
 520 bool CUSBCECAdapterCommunication::PersistConfiguration(libcec_configuration *configuration)
 521 {
 522   if (m_iFirmwareVersion < 2)
 523     return false;
 524
 525   bool bReturn(true);
 526   bReturn &= SetSettingAutoEnabled(true);
 527   bReturn &= SetSettingDeviceType(CLibCEC::GetType(configuration->logicalAddresses.primary));
 528   bReturn &= SetSettingDefaultLogicalAddress(configuration->logicalAddresses.primary);
 529   bReturn &= SetSettingLogicalAddressMask(CLibCEC::GetMaskForType(configuration->logicalAddresses.primary));
 530   bReturn &= SetSettingPhysicalAddress(configuration->iPhysicalAddress);
 531   bReturn &= SetSettingCECVersion(CEC_VERSION_1_3A);
 532   bReturn &= SetSettingOSDName(configuration->strDeviceName);
 533   if (bReturn)
 534     bReturn = WriteEEPROM();
 535   return bReturn;
 536 }
 537
 538 bool CUSBCECAdapterCommunication::GetConfiguration(libcec_configuration *configuration)
 539 {
 540   if (m_iFirmwareVersion < 2)
 541     return false;
 542
 543   bool bReturn(true);
 544   cec_device_type type;
 545   if (GetSettingDeviceType(type))
 546   {
 547     CLibCEC::AddLog(CEC_LOG_DEBUG, "using persisted device type setting %s", m_processor->ToString(type));
 548     configuration->deviceTypes.Clear();
 549     configuration->deviceTypes.Add(type);
 550   }
 551   else
 552   {
 553     CLibCEC::AddLog(CEC_LOG_DEBUG, "no persisted device type setting");
 554     bReturn = false;
 555   }
 556
 557   if (GetSettingPhysicalAddress(configuration->iPhysicalAddress))
 558   {
 559     CLibCEC::AddLog(CEC_LOG_DEBUG, "using persisted physical address setting %4x", configuration->iPhysicalAddress);
 560   }
 561   else
 562   {
 563     CLibCEC::AddLog(CEC_LOG_DEBUG, "no persisted physical address setting");
 564     bReturn = false;
 565   }
 566
 567   CStdString strDeviceName;
 568   if (GetSettingOSDName(strDeviceName))
 569   {
 570     snprintf(configuration->strDeviceName, 13, "%s", strDeviceName.c_str());
 571     CLibCEC::AddLog(CEC_LOG_DEBUG, "using persisted device name setting %s", configuration->strDeviceName);
 572   }
 573   else
 574   {
 575     CLibCEC::AddLog(CEC_LOG_DEBUG, "no persisted device name setting");
 576     bReturn = false;
 577   }
 578
 579   // don't read the following settings:
 580   // - auto enabled (always enabled)
 581   // - default logical address (autodetected)
 582   // - logical address mask (autodetected)
 583   // - CEC version (1.3a)
 584
 585   // TODO to be added to the firmware:
 586   // - base device (4 bits)
 587   // - HDMI port number (4 bits)
 588   // - TV vendor id (12 bits)
 589   // - wake devices (8 bits)
 590   // - standby devices (8 bits)
 591   // - use TV menu language (1 bit)
 592   // - activate source (1 bit)
 593   // - power off screensaver (1 bit)
 594   // - power off on standby (1 bit)
 595   // - send inactive source (1 bit)
 596   return bReturn;
 597 }
 598
 599 bool CUSBCECAdapterCommunication::SetControlledMode(bool controlled)
 600 {
 601   CLockObject lock(m_mutex);
 602   CLibCEC::AddLog(CEC_LOG_DEBUG, "turning controlled mode %s", controlled ? "on" : "off");
 603
 604   CCECAdapterMessage params;
 605   params.PushEscaped(controlled ? 1 : 0);
 606   return SendCommand(MSGCODE_SET_CONTROLLED, params);
 607 }
 608
 609 bool CUSBCECAdapterCommunication::SetSettingAutoEnabled(bool enabled)
 610 {
 611   CLockObject lock(m_mutex);
 612   CLibCEC::AddLog(CEC_LOG_DEBUG, "turning autonomous mode %s", enabled ? "on" : "off");
 613
 614   CCECAdapterMessage params;
 615   params.PushEscaped(enabled ? 1 : 0);
 616   return SendCommand(MSGCODE_SET_AUTO_ENABLED, params);
 617 }
 618
 619 bool CUSBCECAdapterCommunication::GetSettingAutoEnabled(bool &enabled)
 620 {
 621   CLockObject lock(m_mutex);
 622   CLibCEC::AddLog(CEC_LOG_DEBUG, "requesting autonomous mode setting");
 623
 624   cec_datapacket response = GetSetting(MSGCODE_GET_AUTO_ENABLED, 1);
 625   if (response.size == 1)
 626   {
 627     enabled = response[0] == 1;
 628     return true;
 629   }
 630   return false;
 631 }
 632
 633 bool CUSBCECAdapterCommunication::SetSettingDeviceType(cec_device_type type)
 634 {
 635   CLockObject lock(m_mutex);
 636   CLibCEC::AddLog(CEC_LOG_DEBUG, "setting the device type to %1X", (uint8_t)type);
 637
 638   CCECAdapterMessage params;
 639   params.PushEscaped((uint8_t)type);
 640   return SendCommand(MSGCODE_SET_DEVICE_TYPE, params);
 641 }
 642
 643 bool CUSBCECAdapterCommunication::GetSettingDeviceType(cec_device_type &value)
 644 {
 645   CLockObject lock(m_mutex);
 646   CLibCEC::AddLog(CEC_LOG_DEBUG, "requesting device type setting");
 647
 648   cec_datapacket response = GetSetting(MSGCODE_GET_DEVICE_TYPE, 1);
 649   if (response.size == 1)
 650   {
 651     value = (cec_device_type)response[0];
 652     return true;
 653   }
 654   return false;
 655 }
 656
 657 bool CUSBCECAdapterCommunication::SetSettingDefaultLogicalAddress(cec_logical_address address)
 658 {
 659   CLockObject lock(m_mutex);
 660   CLibCEC::AddLog(CEC_LOG_DEBUG, "setting the default logical address to %1X", address);
 661
 662   CCECAdapterMessage params;
 663   params.PushEscaped((uint8_t)address);
 664   return SendCommand(MSGCODE_SET_DEFAULT_LOGICAL_ADDRESS, params);
 665 }
 666
 667 bool CUSBCECAdapterCommunication::GetSettingDefaultLogicalAddress(cec_logical_address &address)
 668 {
 669   CLockObject lock(m_mutex);
 670   CLibCEC::AddLog(CEC_LOG_DEBUG, "requesting default logical address setting");
 671
 672   cec_datapacket response = GetSetting(MSGCODE_GET_DEFAULT_LOGICAL_ADDRESS, 1);
 673   if (response.size == 1)
 674   {
 675     address = (cec_logical_address)response[0];
 676     return true;
 677   }
 678   return false;
 679 }
 680
 681 bool CUSBCECAdapterCommunication::SetSettingLogicalAddressMask(uint16_t iMask)
 682 {
 683   CLockObject lock(m_mutex);
 684   CLibCEC::AddLog(CEC_LOG_DEBUG, "setting the logical address mask to %2X", iMask);
 685
 686   CCECAdapterMessage params;
 687   params.PushEscaped(iMask >> 8);
 688   params.PushEscaped((uint8_t)iMask);
 689   return SendCommand(MSGCODE_SET_LOGICAL_ADDRESS_MASK, params);
 690 }
 691
 692 bool CUSBCECAdapterCommunication::GetSettingLogicalAddressMask(uint16_t &iMask)
 693 {
 694   CLockObject lock(m_mutex);
 695   CLibCEC::AddLog(CEC_LOG_DEBUG, "requesting logical address mask setting");
 696
 697   cec_datapacket response = GetSetting(MSGCODE_GET_LOGICAL_ADDRESS_MASK, 2);
 698   if (response.size == 2)
 699   {
 700     iMask = ((uint16_t)response[0] << 8) | ((uint16_t)response[1]);
 701     return true;
 702   }
 703   return false;
 704 }
 705
 706 bool CUSBCECAdapterCommunication::SetSettingPhysicalAddress(uint16_t iPhysicalAddress)
 707 {
 708   CLockObject lock(m_mutex);
 709   CLibCEC::AddLog(CEC_LOG_DEBUG, "setting the physical address to %04X", iPhysicalAddress);
 710
 711   CCECAdapterMessage params;
 712   params.PushEscaped(iPhysicalAddress >> 8);
 713   params.PushEscaped((uint8_t)iPhysicalAddress);
 714   return SendCommand(MSGCODE_SET_PHYSICAL_ADDRESS, params);
 715 }
 716
 717 bool CUSBCECAdapterCommunication::GetSettingPhysicalAddress(uint16_t &iPhysicalAddress)
 718 {
 719   CLockObject lock(m_mutex);
 720   CLibCEC::AddLog(CEC_LOG_DEBUG, "requesting physical address setting");
 721
 722   cec_datapacket response = GetSetting(MSGCODE_GET_PHYSICAL_ADDRESS, 2);
 723   if (response.size == 2)
 724   {
 725     iPhysicalAddress = ((uint16_t)response[0] << 8) | ((uint16_t)response[1]);
 726     return true;
 727   }
 728   return false;
 729 }
 730
 731 bool CUSBCECAdapterCommunication::SetSettingCECVersion(cec_version version)
 732 {
 733   CLockObject lock(m_mutex);
 734   CLibCEC::AddLog(CEC_LOG_DEBUG, "setting the CEC version to %s", CLibCEC::GetInstance()->ToString(version));
 735
 736   CCECAdapterMessage params;
 737   params.PushEscaped((uint8_t)version);
 738   return SendCommand(MSGCODE_SET_HDMI_VERSION, params);
 739 }
 740
 741 bool CUSBCECAdapterCommunication::GetSettingCECVersion(cec_version &version)
 742 {
 743   CLockObject lock(m_mutex);
 744   CLibCEC::AddLog(CEC_LOG_DEBUG, "requesting CEC version setting");
 745
 746   cec_datapacket response = GetSetting(MSGCODE_GET_HDMI_VERSION, 1);
 747   if (response.size == 1)
 748   {
 749     version = (cec_version)response[0];
 750     return true;
 751   }
 752   return false;
 753 }
 754
 755 bool CUSBCECAdapterCommunication::SetSettingOSDName(const char *strOSDName)
 756 {
 757   CLockObject lock(m_mutex);
 758   CLibCEC::AddLog(CEC_LOG_DEBUG, "setting the OSD name to %s", strOSDName);
 759
 760   CCECAdapterMessage params;
 761   for (size_t iPtr = 0; iPtr < strlen(strOSDName); iPtr++)
 762     params.PushEscaped(strOSDName[iPtr]);
 763   return SendCommand(MSGCODE_SET_OSD_NAME, params);
 764 }
 765
 766 bool CUSBCECAdapterCommunication::GetSettingOSDName(CStdString &strOSDName)
 767 {
 768   CLockObject lock(m_mutex);
 769   CLibCEC::AddLog(CEC_LOG_DEBUG, "requesting OSD name setting");
 770
 771   cec_datapacket response = GetSetting(MSGCODE_GET_OSD_NAME, 13);
 772   if (response.size == 0)
 773     return false;
 774
 775   char buf[14];
 776   for (uint8_t iPtr = 0; iPtr < response.size && iPtr < 13; iPtr++)
 777     buf[iPtr] = (char)response[iPtr];
 778   buf[response.size] = 0;
 779
 780   strOSDName.Format("%s", buf);
 781   return true;
 782 }
 783
 784 bool CUSBCECAdapterCommunication::WriteEEPROM(void)
 785 {
 786   CLockObject lock(m_mutex);
 787   CLibCEC::AddLog(CEC_LOG_DEBUG, "writing settings in the EEPROM");
 788
 789   CCECAdapterMessage params;
 790   return SendCommand(MSGCODE_WRITE_EEPROM, params);
 791 }
 792
 793 bool CUSBCECAdapterCommunication::IsOpen(void)
 794 {
 795   return !IsStopped() && m_port->IsOpen() && IsRunning();
 796 }
 797
 798 bool CUSBCECAdapterCommunication::WaitForAck(CCECAdapterMessage &message)
 799 {
 800   bool bError(false);
 801   bool bTransmitSucceeded(false);
 802   uint8_t iPacketsLeft(message.isTransmission ? message.Size() / 4 : 1);
 803
 804   int64_t iNow = GetTimeMs();
 805   int64_t iTargetTime = iNow + (message.transmit_timeout <= 5 ? CEC_DEFAULT_TRANSMIT_WAIT : message.transmit_timeout);
 806
 807   while (!bTransmitSucceeded && !bError && iNow < iTargetTime)
 808   {
 809     ReadFromDevice(50);
 810     CCECAdapterMessage msg;
 811     if (!Read(msg, 0))
 812     {
 813       iNow = GetTimeMs();
 814       continue;
 815     }
 816
 817     if (msg.Message() == MSGCODE_FRAME_START && msg.IsACK())
 818     {
 819       if (m_bWaitingForAck[msg.Initiator()])
 820         m_bWaitingForAck[msg.Initiator()] = false;
 821       else
 822       {
 823         m_processor->HandlePoll(msg.Initiator(), msg.Destination());
 824         m_lastDestination = msg.Initiator();
 825       }
 826       iNow = GetTimeMs();
 827       continue;
 828     }
 829
 830     if (msg.Message() == MSGCODE_RECEIVE_FAILED &&
 831         m_lastDestination != CECDEVICE_UNKNOWN &&
 832         m_processor->HandleReceiveFailed(m_lastDestination))
 833     {
 834       iNow = GetTimeMs();
 835       continue;
 836     }
 837
 838     bError = msg.IsError();
 839     if (bError)
 840     {
 841       message.reply = msg.Message();
 842       CLibCEC::AddLog(CEC_LOG_DEBUG, msg.ToString());
 843     }
 844     else
 845     {
 846       switch(msg.Message())
 847       {
 848       case MSGCODE_COMMAND_ACCEPTED:
 849         if (iPacketsLeft > 0)
 850           iPacketsLeft--;
 851         if (!message.isTransmission && iPacketsLeft == 0)
 852           bTransmitSucceeded = true;
 853         CLibCEC::AddLog(CEC_LOG_DEBUG, "%s - waiting for %d more", msg.ToString().c_str(), iPacketsLeft);
 854         break;
 855       case MSGCODE_TRANSMIT_SUCCEEDED:
 856         CLibCEC::AddLog(CEC_LOG_DEBUG, msg.ToString());
 857         bTransmitSucceeded = (iPacketsLeft == 0);
 858         bError = !bTransmitSucceeded;
 859         message.reply = MSGCODE_TRANSMIT_SUCCEEDED;
 860         break;
 861       default:
 862         // ignore other data while waiting
 863         break;
 864       }
 865
 866       iNow = GetTimeMs();
 867     }
 868   }
 869
 870   message.state = bTransmitSucceeded && !bError ?
 871       ADAPTER_MESSAGE_STATE_SENT_ACKED :
 872       ADAPTER_MESSAGE_STATE_SENT_NOT_ACKED;
 873
 874   return bTransmitSucceeded && !bError;
 875 }
 876
 877 void CUSBCECAdapterCommunication::AddData(uint8_t *data, size_t iLen)
 878 {
 879   CLockObject lock(m_mutex);
 880   for (size_t iPtr = 0; iPtr < iLen; iPtr++)
 881   {
 882     if (!m_bGotStart)
 883     {
 884       if (data[iPtr] == MSGSTART)
 885         m_bGotStart = true;
 886     }
 887     else if (data[iPtr] == MSGSTART) //we found a msgstart before msgend, this is not right, remove
 888     {
 889       if (m_currentAdapterMessage.Size() > 0)
 890         CLibCEC::AddLog(CEC_LOG_WARNING, "received MSGSTART before MSGEND, removing previous buffer contents");
 891       m_currentAdapterMessage.Clear();
 892       m_bGotStart = true;
 893     }
 894     else if (data[iPtr] == MSGEND)
 895     {
 896       CCECAdapterMessage *newMessage = new CCECAdapterMessage;
 897       newMessage->packet = m_currentAdapterMessage.packet;
 898       m_inBuffer.Push(newMessage);
 899       m_currentAdapterMessage.Clear();
 900       m_bGotStart = false;
 901       m_bNextIsEscaped = false;
 902       m_bHasData = true;
 903       m_rcvCondition.Broadcast();
 904     }
 905     else if (m_bNextIsEscaped)
 906     {
 907       m_currentAdapterMessage.PushBack(data[iPtr] + (uint8_t)ESCOFFSET);
 908       m_bNextIsEscaped = false;
 909     }
 910     else if (data[iPtr] == MSGESC)
 911     {
 912       m_bNextIsEscaped = true;
 913     }
 914     else
 915     {
 916       m_currentAdapterMessage.PushBack(data[iPtr]);
 917     }
 918   }
 919 }
 920
 921 bool CUSBCECAdapterCommunication::ReadFromDevice(uint32_t iTimeout, size_t iSize /* = 256 */)
 922 {
 923   ssize_t iBytesRead;
 924   uint8_t buff[256];
 925   if (!m_port)
 926     return false;
 927   if (iSize > 256)
 928     iSize = 256;
 929
 930   CLockObject lock(m_mutex);
 931   iBytesRead = m_port->Read(buff, sizeof(uint8_t) * iSize, iTimeout);
 932   if (iBytesRead < 0 || iBytesRead > 256)
 933   {
 934     CLibCEC::AddLog(CEC_LOG_ERROR, "error reading from serial port: %s", m_port->GetError().c_str());
 935     StopThread(false);
 936     return false;
 937   }
 938   else if (iBytesRead > 0)
 939   {
 940     AddData(buff, iBytesRead);
 941   }
 942
 943   return iBytesRead > 0;
 944 }
 945
 946 void CUSBCECAdapterCommunication::SendMessageToAdapter(CCECAdapterMessage *msg)
 947 {
 948   CLockObject adapterLock(m_mutex);
 949   if (!m_port->IsOpen())
 950   {
 951     CLibCEC::AddLog(CEC_LOG_ERROR, "error writing to serial port: the connection is closed");
 952     msg->state = ADAPTER_MESSAGE_STATE_ERROR;
 953     return;
 954   }
 955
 956   if (msg->isTransmission && (msg->Size() < 2 || msg->At(1) != MSGCODE_TRANSMIT_IDLETIME))
 957   {
 958     if (msg->tries == 1)
 959       SetLineTimeout(msg->lineTimeout);
 960     else
 961       SetLineTimeout(msg->retryTimeout);
 962   }
 963
 964   if (m_port->Write(msg->packet.data, msg->Size()) != (ssize_t) msg->Size())
 965   {
 966     CLibCEC::AddLog(CEC_LOG_ERROR, "error writing to serial port: %s", m_port->GetError().c_str());
 967     msg->state = ADAPTER_MESSAGE_STATE_ERROR;
 968   }
 969   else
 970   {
 971     CLibCEC::AddLog(CEC_LOG_DEBUG, "command sent");
 972     msg->state = ADAPTER_MESSAGE_STATE_SENT;
 973
 974     if (msg->expectControllerAck)
 975     {
 976       if (!WaitForAck(*msg))
 977         CLibCEC::AddLog(CEC_LOG_DEBUG, "did not receive ack");
 978     }
 979   }
 980   msg->event.Signal();
 981 }
 982
 983 void CUSBCECAdapterCommunication::WriteNextCommand(void)
 984 {
 985   CCECAdapterMessage *msg(NULL);
 986   if (m_outBuffer.Pop(msg))
 987     SendMessageToAdapter(msg);
 988 }
 989
 990 CStdString CUSBCECAdapterCommunication::GetPortName(void)
 991 {
 992   CStdString strName;
 993   strName = m_port->GetName();
 994   return strName;
 995 }
 996
 997 bool CUSBCECAdapterCommunication::SendCommand(cec_adapter_messagecode msgCode, CCECAdapterMessage &params, bool bExpectAck /* = true */, bool bIsTransmission /* = false */, bool bSendDirectly /* = true */, bool bIsRetry /* = false */)
 998 {
 999   CLockObject lock(m_mutex);
1000
1001   CCECAdapterMessage *output = new CCECAdapterMessage;
1002
1003   output->PushBack(MSGSTART);
1004   output->PushEscaped((uint8_t)msgCode);
1005   output->Append(params);
1006   output->PushBack(MSGEND);
1007   output->isTransmission = bIsTransmission;
1008   output->expectControllerAck = bExpectAck;
1009
1010   if (bSendDirectly)
1011     SendMessageToAdapter(output);
1012   else
1013     Write(output);
1014
1015   bool bWriteOk = output->state == (output->expectControllerAck ? ADAPTER_MESSAGE_STATE_SENT_ACKED : ADAPTER_MESSAGE_STATE_SENT);
1016   if (!bWriteOk)
1017   {
1018     CLibCEC::AddLog(CEC_LOG_ERROR, "'%s' failed", CCECAdapterMessage::ToString(msgCode));
1019     delete output;
1020
1021     if (!bIsRetry && output->reply == MSGCODE_COMMAND_REJECTED && msgCode != MSGCODE_SET_CONTROLLED)
1022     {
1023       CLibCEC::AddLog(CEC_LOG_DEBUG, "setting controlled mode and retrying");
1024       if (SetControlledMode(true))
1025         return SendCommand(msgCode, params, bExpectAck, bIsTransmission, bSendDirectly, true);
1026     }
1027     return false;
1028   }
1029
1030   delete output;
1031   return true;
1032 }
1033
1034 cec_datapacket CUSBCECAdapterCommunication::GetSetting(cec_adapter_messagecode msgCode, uint8_t iResponseLength)
1035 {
1036   cec_datapacket retVal;
1037   retVal.Clear();
1038
1039   CCECAdapterMessage params;
1040   if (!SendCommand(msgCode, params, false))
1041   {
1042     CLibCEC::AddLog(CEC_LOG_ERROR, "%s failed", CCECAdapterMessage::ToString(msgCode));
1043     return retVal;
1044   }
1045
1046   Sleep(250); // TODO ReadFromDevice() isn't waiting for the timeout to pass on win32
1047   ReadFromDevice(CEC_DEFAULT_TRANSMIT_WAIT, iResponseLength + 3 /* start + msgcode + iResponseLength + end */);
1048   CCECAdapterMessage input;
1049   if (Read(input, 0))
1050   {
1051     if (input.Message() != msgCode)
1052       CLibCEC::AddLog(CEC_LOG_ERROR, "invalid response to %s received (%s)", CCECAdapterMessage::ToString(msgCode), CCECAdapterMessage::ToString(input.Message()));
1053     else
1054     {
1055       for (uint8_t iPtr = 1; iPtr < input.Size(); iPtr++)
1056         retVal.PushBack(input[iPtr]);
1057     }
1058   }
1059   else
1060   {
1061     CLibCEC::AddLog(CEC_LOG_ERROR, "no response to %s received", CCECAdapterMessage::ToString(msgCode));
1062   }
1063
1064   return retVal;
1065 }