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