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