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