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 void *CUSBCECAdapterProcessor::Process(void)
  44 {
  45   cec_command command;
  46   while (!IsStopped())
  47   {
  48     if (m_inBuffer.Pop(command))
  49       m_callback->OnCommandReceived(command);
  50     Sleep(5);
  51   }
  52
  53   return NULL;
  54 }
  55
  56 void CUSBCECAdapterProcessor::AddCommand(cec_command command)
  57 {
  58   m_inBuffer.Push(command);
  59 }
  60
  61 CUSBCECAdapterCommunication::CUSBCECAdapterCommunication(CCECProcessor *processor, const char *strPort, uint16_t iBaudRate /* = 38400 */) :
  62     m_port(NULL),
  63     m_processor(processor),
  64     m_bHasData(false),
  65     m_iLineTimeout(0),
  66     m_iFirmwareVersion(CEC_FW_VERSION_UNKNOWN),
  67     m_lastInitiator(CECDEVICE_UNKNOWN),
  68     m_bNextIsEscaped(false),
  69     m_bGotStart(false),
  70     m_messageProcessor(NULL),
  71     m_bInitialised(false)
  72 {
  73   m_port = new PLATFORM::CSerialPort(strPort, iBaudRate);
  74 }
  75
  76 CUSBCECAdapterCommunication::~CUSBCECAdapterCommunication(void)
  77 {
  78   Close();
  79 }
  80
  81 bool CUSBCECAdapterCommunication::CheckAdapter(uint32_t iTimeoutMs /* = 10000 */)
  82 {
  83   bool bReturn(false);
  84   uint64_t iNow = GetTimeMs();
  85   uint64_t iTarget = iTimeoutMs > 0 ? iNow + iTimeoutMs : iNow + CEC_DEFAULT_TRANSMIT_WAIT;
  86
  87   /* try to ping the adapter */
  88   bool bPinged(false);
  89   unsigned iPingTry(0);
  90   while (iNow < iTarget && (bPinged = PingAdapter()) == false)
  91   {
  92     CLibCEC::AddLog(CEC_LOG_ERROR, "the adapter did not respond correctly to a ping (try %d)", ++iPingTry);
  93     CEvent::Sleep(500);
  94     iNow = GetTimeMs();
  95   }
  96
  97   /* try to read the firmware version */
  98   m_iFirmwareVersion = CEC_FW_VERSION_UNKNOWN;
  99   unsigned iFwVersionTry(0);
 100   while (bPinged && iNow < iTarget && (m_iFirmwareVersion = GetFirmwareVersion()) == CEC_FW_VERSION_UNKNOWN && iFwVersionTry < 3)
 101   {
 102     CLibCEC::AddLog(CEC_LOG_WARNING, "the adapter did not respond with a correct firmware version (try %d)", ++iFwVersionTry);
 103     CEvent::Sleep(500);
 104     iNow = GetTimeMs();
 105   }
 106
 107   if (m_iFirmwareVersion == CEC_FW_VERSION_UNKNOWN)
 108   {
 109     CLibCEC::AddLog(CEC_LOG_DEBUG, "defaulting to firmware version 1");
 110     m_iFirmwareVersion = 1;
 111   }
 112
 113   if (m_iFirmwareVersion >= 2)
 114   {
 115     /* try to set controlled mode */
 116     unsigned iControlledTry(0);
 117     bool bControlled(false);
 118     while (iNow < iTarget && (bControlled = SetControlledMode(true)) == false)
 119     {
 120       CLibCEC::AddLog(CEC_LOG_ERROR, "the adapter did not respond correctly to setting controlled mode (try %d)", ++iControlledTry);
 121       CEvent::Sleep(500);
 122       iNow = GetTimeMs();
 123     }
 124     bReturn = bControlled;
 125   }
 126   else
 127     bReturn = true;
 128
 129   {
 130     CLockObject lock(m_mutex);
 131     m_bInitialised = bReturn;
 132   }
 133
 134   return bReturn;
 135 }
 136
 137 bool CUSBCECAdapterCommunication::Open(IAdapterCommunicationCallback *cb, uint32_t iTimeoutMs /* = 10000 */, bool bSkipChecks /* = false */)
 138 {
 139   uint64_t iNow = GetTimeMs();
 140   uint64_t iTimeout = iNow + iTimeoutMs;
 141
 142   {
 143     CLockObject lock(m_mutex);
 144
 145     if (!m_port)
 146     {
 147       CLibCEC::AddLog(CEC_LOG_ERROR, "port is NULL");
 148       return false;
 149     }
 150
 151     if (IsOpen())
 152     {
 153       CLibCEC::AddLog(CEC_LOG_ERROR, "port is already open");
 154       return true;
 155     }
 156
 157     m_callback = cb;
 158     CStdString strError;
 159     bool bConnected(false);
 160     while (!bConnected && iNow < iTimeout)
 161     {
 162       if ((bConnected = m_port->Open(iTimeout)) == false)
 163       {
 164         strError.Format("error opening serial port '%s': %s", m_port->GetName().c_str(), m_port->GetError().c_str());
 165         Sleep(250);
 166         iNow = GetTimeMs();
 167       }
 168     }
 169
 170     if (!bConnected)
 171     {
 172       CLibCEC::AddLog(CEC_LOG_ERROR, strError);
 173       return false;
 174     }
 175
 176     CLibCEC::AddLog(CEC_LOG_DEBUG, "connection opened, clearing any previous input and waiting for active transmissions to end before starting");
 177
 178     if (!bSkipChecks)
 179     {
 180       //clear any input bytes
 181       uint8_t buff[1024];
 182       while (m_port->Read(buff, 1024, 100) > 0)
 183       {
 184         CLibCEC::AddLog(CEC_LOG_DEBUG, "data received, clearing it");
 185         Sleep(250);
 186       }
 187     }
 188   }
 189
 190   if (!bSkipChecks && !CheckAdapter())
 191   {
 192     CLibCEC::AddLog(CEC_LOG_ERROR, "the adapter failed to pass basic checks");
 193     return false;
 194   }
 195   else
 196   {
 197     if (CreateThread())
 198     {
 199       CLibCEC::AddLog(CEC_LOG_DEBUG, "communication thread started");
 200       return true;
 201     }
 202     else
 203     {
 204       CLibCEC::AddLog(CEC_LOG_ERROR, "could not create a communication thread");
 205     }
 206   }
 207
 208   return false;
 209 }
 210
 211 void CUSBCECAdapterCommunication::Close(void)
 212 {
 213   StopThread();
 214 }
 215
 216 void *CUSBCECAdapterCommunication::Process(void)
 217 {
 218   m_messageProcessor = new CUSBCECAdapterProcessor(m_callback);
 219   m_messageProcessor->CreateThread();
 220
 221   cec_command command;
 222   command.Clear();
 223   bool bCommandReceived(false);
 224   while (!IsStopped())
 225   {
 226     {
 227       CLockObject lock(m_mutex);
 228       ReadFromDevice(50);
 229       bCommandReceived = m_callback && Read(command, 0) && m_bInitialised;
 230     }
 231
 232     /* push the next command to the callback method if there is one */
 233     if (!IsStopped() && bCommandReceived)
 234       m_messageProcessor->AddCommand(command);
 235
 236     if (!IsStopped())
 237     {
 238       Sleep(5);
 239       WriteNextCommand();
 240     }
 241   }
 242
 243   /* stop the message processor */
 244   m_messageProcessor->StopThread();
 245   delete m_messageProcessor;
 246
 247   /* notify all threads that are waiting on messages to be sent */
 248   CCECAdapterMessage *msg(NULL);
 249   while (m_outBuffer.Pop(msg))
 250     msg->event.Broadcast();
 251
 252   /* set the ackmask to 0 before closing the connection */
 253   SetAckMaskInternal(0, true);
 254
 255   if (m_iFirmwareVersion >= 2)
 256     SetControlledMode(false);
 257
 258   if (m_port)
 259   {
 260     delete m_port;
 261     m_port = NULL;
 262   }
 263
 264   return NULL;
 265 }
 266
 267 cec_adapter_message_state CUSBCECAdapterCommunication::Write(const cec_command &data, uint8_t iMaxTries, uint8_t iLineTimeout /* = 3 */, uint8_t iRetryLineTimeout /* = 3 */)
 268 {
 269   cec_adapter_message_state retVal(ADAPTER_MESSAGE_STATE_UNKNOWN);
 270   if (!IsRunning())
 271     return retVal;
 272
 273   CCECAdapterMessage *output = new CCECAdapterMessage(data);
 274
 275   /* set the number of retries */
 276   if (data.opcode == CEC_OPCODE_NONE) //TODO
 277     output->maxTries = 1;
 278   else if (data.initiator != CECDEVICE_BROADCAST)
 279     output->maxTries = iMaxTries;
 280
 281   output->lineTimeout = iLineTimeout;
 282   output->retryTimeout = iRetryLineTimeout;
 283   output->tries = 0;
 284
 285   bool bRetry(true);
 286   while (bRetry && ++output->tries < output->maxTries)
 287   {
 288     bRetry = (!Write(output) || output->NeedsRetry()) && output->transmit_timeout > 0;
 289     if (bRetry)
 290       Sleep(CEC_DEFAULT_TRANSMIT_RETRY_WAIT);
 291   }
 292   retVal = output->state;
 293
 294   delete output;
 295   return retVal;
 296 }
 297
 298 bool CUSBCECAdapterCommunication::Write(CCECAdapterMessage *data)
 299 {
 300   data->state = ADAPTER_MESSAGE_STATE_WAITING_TO_BE_SENT;
 301   m_outBuffer.Push(data);
 302   data->event.Wait(5000);
 303
 304   if ((data->expectControllerAck && data->state != ADAPTER_MESSAGE_STATE_SENT_ACKED) ||
 305       (!data->expectControllerAck && data->state != ADAPTER_MESSAGE_STATE_SENT))
 306   {
 307     CLibCEC::AddLog(CEC_LOG_DEBUG, "command was not %s", data->state == ADAPTER_MESSAGE_STATE_SENT_NOT_ACKED ? "acked" : "sent");
 308     return false;
 309   }
 310
 311   return true;
 312 }
 313
 314 bool CUSBCECAdapterCommunication::Read(cec_command &command, uint32_t iTimeout)
 315 {
 316   if (!IsRunning())
 317     return false;
 318
 319   CCECAdapterMessage msg;
 320   if (Read(msg, iTimeout))
 321   {
 322     if (ParseMessage(msg))
 323     {
 324       command = m_currentframe;
 325       m_currentframe.Clear();
 326       return true;
 327     }
 328   }
 329   return false;
 330 }
 331
 332 bool CUSBCECAdapterCommunication::Read(CCECAdapterMessage &msg, uint32_t iTimeout)
 333 {
 334   CLockObject lock(m_mutex);
 335
 336   msg.Clear();
 337   CCECAdapterMessage *buf(NULL);
 338
 339   if (!m_inBuffer.Pop(buf))
 340   {
 341     if (iTimeout == 0 || !m_rcvCondition.Wait(m_mutex, m_bHasData, iTimeout))
 342       return false;
 343     m_inBuffer.Pop(buf);
 344     m_bHasData = !m_inBuffer.IsEmpty();
 345   }
 346
 347   if (buf)
 348   {
 349     msg.packet = buf->packet;
 350     msg.state = ADAPTER_MESSAGE_STATE_INCOMING;
 351     delete buf;
 352     return true;
 353   }
 354   return false;
 355 }
 356
 357 CStdString CUSBCECAdapterCommunication::GetError(void) const
 358 {
 359   CStdString strError;
 360   strError = m_port->GetError();
 361   return strError;
 362 }
 363
 364 bool CUSBCECAdapterCommunication::StartBootloader(void)
 365 {
 366   bool bReturn(false);
 367   if (!IsRunning())
 368     return bReturn;
 369
 370   CLibCEC::AddLog(CEC_LOG_DEBUG, "starting the bootloader");
 371   CCECAdapterMessage *output = new CCECAdapterMessage;
 372
 373   output->PushBack(MSGSTART);
 374   output->PushEscaped(MSGCODE_START_BOOTLOADER);
 375   output->PushBack(MSGEND);
 376   output->isTransmission = false;
 377   output->expectControllerAck = false;
 378
 379   if ((bReturn = Write(output)) == false)
 380     CLibCEC::AddLog(CEC_LOG_ERROR, "could not start the bootloader");
 381   delete output;
 382
 383   return bReturn;
 384 }
 385
 386 bool CUSBCECAdapterCommunication::PingAdapter(void)
 387 {
 388   CLockObject lock(m_mutex);
 389   CLibCEC::AddLog(CEC_LOG_DEBUG, "sending ping");
 390
 391   CCECAdapterMessage *output = new CCECAdapterMessage;
 392
 393   output->PushBack(MSGSTART);
 394   output->PushEscaped(MSGCODE_PING);
 395   output->PushBack(MSGEND);
 396   output->isTransmission = false;
 397
 398   SendMessageToAdapter(output);
 399   bool bWriteOk = output->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
 400   delete output;
 401   if (!bWriteOk)
 402   {
 403     CLibCEC::AddLog(CEC_LOG_ERROR, "could not ping the adapter");
 404     return false;
 405   }
 406
 407   return true;
 408 }
 409
 410 bool CUSBCECAdapterCommunication::ParseMessage(const CCECAdapterMessage &msg)
 411 {
 412   bool bEom(false);
 413   bool bIsError(msg.IsError());
 414
 415   if (msg.IsEmpty())
 416     return bEom;
 417
 418   CLockObject adapterLock(m_mutex);
 419   switch(msg.Message())
 420   {
 421   case MSGCODE_FRAME_START:
 422     {
 423       m_currentframe.Clear();
 424       if (msg.Size() >= 2)
 425       {
 426         m_currentframe.initiator   = msg.Initiator();
 427         m_currentframe.destination = msg.Destination();
 428         m_currentframe.ack         = msg.IsACK();
 429         m_currentframe.eom         = msg.IsEOM();
 430       }
 431       if (m_currentframe.ack == 0x1)
 432       {
 433         m_lastInitiator = m_currentframe.initiator;
 434         m_processor->HandlePoll(m_currentframe.initiator, m_currentframe.destination);
 435       }
 436     }
 437     break;
 438   case MSGCODE_RECEIVE_FAILED:
 439     {
 440       m_currentframe.Clear();
 441       if (m_lastInitiator != CECDEVICE_UNKNOWN)
 442         bIsError = m_processor->HandleReceiveFailed(m_lastInitiator);
 443     }
 444     break;
 445   case MSGCODE_FRAME_DATA:
 446     {
 447       if (msg.Size() >= 2)
 448       {
 449         m_currentframe.PushBack(msg[1]);
 450         m_currentframe.eom = msg.IsEOM();
 451       }
 452     }
 453     break;
 454   default:
 455     break;
 456   }
 457
 458   CLibCEC::AddLog(bIsError ? CEC_LOG_WARNING : CEC_LOG_DEBUG, msg.ToString());
 459   return msg.IsEOM();
 460 }
 461
 462 uint16_t CUSBCECAdapterCommunication::GetFirmwareVersion(void)
 463 {
 464   uint16_t iReturn(m_iFirmwareVersion);
 465
 466   if (iReturn == CEC_FW_VERSION_UNKNOWN)
 467   {
 468     CLockObject lock(m_mutex);
 469     CLibCEC::AddLog(CEC_LOG_DEBUG, "requesting the firmware version");
 470     CCECAdapterMessage *output = new CCECAdapterMessage;
 471
 472     output->PushBack(MSGSTART);
 473     output->PushEscaped(MSGCODE_FIRMWARE_VERSION);
 474     output->PushBack(MSGEND);
 475     output->isTransmission = false;
 476     output->expectControllerAck = false;
 477
 478     SendMessageToAdapter(output);
 479     bool bWriteOk = output->state == ADAPTER_MESSAGE_STATE_SENT;
 480     delete output;
 481     if (!bWriteOk)
 482     {
 483       CLibCEC::AddLog(CEC_LOG_ERROR, "could not request the firmware version");
 484       return iReturn;
 485     }
 486
 487     Sleep(250); // TODO ReadFromDevice() isn't waiting for the timeout to pass on win32
 488     ReadFromDevice(CEC_DEFAULT_TRANSMIT_WAIT, 5 /* start + msgcode + 2 bytes for fw version + end */);
 489     CCECAdapterMessage input;
 490     if (Read(input, 0))
 491     {
 492       if (input.Message() != MSGCODE_FIRMWARE_VERSION || input.Size() != 3)
 493         CLibCEC::AddLog(CEC_LOG_ERROR, "invalid firmware version (size = %d, message = %d)", input.Size(), input.Message());
 494       else
 495       {
 496         m_iFirmwareVersion = (input[1] << 8 | input[2]);
 497         iReturn = m_iFirmwareVersion;
 498       }
 499     }
 500     else
 501     {
 502       CLibCEC::AddLog(CEC_LOG_ERROR, "no firmware version received");
 503     }
 504   }
 505
 506   return iReturn;
 507 }
 508
 509 bool CUSBCECAdapterCommunication::SetLineTimeout(uint8_t iTimeout)
 510 {
 511   m_iLineTimeout = iTimeout;
 512   return true;
 513   //TODO
 514 //  bool bReturn(m_iLineTimeout != iTimeout);
 515 //
 516 //  if (!bReturn)
 517 //  {
 518 //    CCECAdapterMessage *output = new CCECAdapterMessage;
 519 //
 520 //    output->PushBack(MSGSTART);
 521 //    output->PushEscaped(MSGCODE_TRANSMIT_IDLETIME);
 522 //    output->PushEscaped(iTimeout);
 523 //    output->PushBack(MSGEND);
 524 //    output->isTransmission = false;
 525 //
 526 //    if ((bReturn = Write(output)) == false)
 527 //      CLibCEC::AddLog(CEC_LOG_ERROR, "could not set the idletime");
 528 //    delete output;
 529 //  }
 530 //
 531 //  return bReturn;
 532 }
 533
 534 bool CUSBCECAdapterCommunication::SetAckMask(uint16_t iMask)
 535 {
 536   return SetAckMaskInternal(iMask, false);
 537 }
 538
 539 bool CUSBCECAdapterCommunication::SetAckMaskInternal(uint16_t iMask, bool bWriteDirectly /* = false */)
 540 {
 541   bool bReturn(false);
 542   CLibCEC::AddLog(CEC_LOG_DEBUG, "setting ackmask to %2x", iMask);
 543
 544   CCECAdapterMessage *output = new CCECAdapterMessage;
 545
 546   output->PushBack(MSGSTART);
 547   output->PushEscaped(MSGCODE_SET_ACK_MASK);
 548   output->PushEscaped(iMask >> 8);
 549   output->PushEscaped((uint8_t)iMask);
 550   output->PushBack(MSGEND);
 551   output->isTransmission = false;
 552
 553   if (bWriteDirectly)
 554     SendMessageToAdapter(output);
 555   else if ((bReturn = Write(output)) == false)
 556     CLibCEC::AddLog(CEC_LOG_ERROR, "could not set the ackmask");
 557   delete output;
 558
 559   return bReturn;
 560 }
 561
 562
 563 bool CUSBCECAdapterCommunication::SetControlledMode(bool controlled)
 564 {
 565   CLockObject lock(m_mutex);
 566   CLibCEC::AddLog(CEC_LOG_DEBUG, "turning controlled mode %s", controlled ? "on" : "off");
 567
 568   CCECAdapterMessage *output = new CCECAdapterMessage;
 569
 570   output->PushBack(MSGSTART);
 571   output->PushEscaped(MSGCODE_SET_CONTROLLED);
 572   output->PushEscaped(controlled);
 573   output->PushBack(MSGEND);
 574   output->isTransmission = false;
 575
 576   SendMessageToAdapter(output);
 577   bool bWriteOk = output->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
 578   delete output;
 579   if (!bWriteOk)
 580   {
 581     CLibCEC::AddLog(CEC_LOG_ERROR, "could not set controlled mode");
 582     return false;
 583   }
 584
 585   return true;
 586 }
 587
 588 bool CUSBCECAdapterCommunication::IsOpen(void)
 589 {
 590   return !IsStopped() && m_port->IsOpen() && IsRunning();
 591 }
 592
 593 bool CUSBCECAdapterCommunication::WaitForAck(CCECAdapterMessage &message)
 594 {
 595   bool bError(false);
 596   bool bTransmitSucceeded(false);
 597   uint8_t iPacketsLeft(message.Size() / 4);
 598
 599   int64_t iNow = GetTimeMs();
 600   int64_t iTargetTime = iNow + (message.transmit_timeout <= 5 ? CEC_DEFAULT_TRANSMIT_WAIT : message.transmit_timeout);
 601
 602   while (!bTransmitSucceeded && !bError && iNow < iTargetTime)
 603   {
 604     ReadFromDevice(50);
 605     CCECAdapterMessage msg;
 606     if (!Read(msg, 0))
 607     {
 608       iNow = GetTimeMs();
 609       continue;
 610     }
 611
 612     if (msg.Message() == MSGCODE_FRAME_START && msg.IsACK())
 613     {
 614       m_processor->HandlePoll(msg.Initiator(), msg.Destination());
 615       m_lastInitiator = msg.Initiator();
 616       iNow = GetTimeMs();
 617       continue;
 618     }
 619
 620     if (msg.Message() == MSGCODE_RECEIVE_FAILED &&
 621         m_lastInitiator != CECDEVICE_UNKNOWN &&
 622         m_processor->HandleReceiveFailed(m_lastInitiator))
 623     {
 624       iNow = GetTimeMs();
 625       continue;
 626     }
 627
 628     bError = msg.IsError();
 629     if (bError)
 630     {
 631       message.reply = msg.Message();
 632       CLibCEC::AddLog(CEC_LOG_DEBUG, msg.ToString());
 633     }
 634     else
 635     {
 636       switch(msg.Message())
 637       {
 638       case MSGCODE_COMMAND_ACCEPTED:
 639         if (iPacketsLeft > 0)
 640           iPacketsLeft--;
 641         if (!message.isTransmission && iPacketsLeft == 0)
 642           bTransmitSucceeded = true;
 643         CLibCEC::AddLog(CEC_LOG_DEBUG, "%s - waiting for %d more", msg.ToString().c_str(), iPacketsLeft);
 644         break;
 645       case MSGCODE_TRANSMIT_SUCCEEDED:
 646         CLibCEC::AddLog(CEC_LOG_DEBUG, msg.ToString());
 647         bTransmitSucceeded = (iPacketsLeft == 0);
 648         bError = !bTransmitSucceeded;
 649         message.reply = MSGCODE_TRANSMIT_SUCCEEDED;
 650         break;
 651       default:
 652         // ignore other data while waiting
 653         break;
 654       }
 655
 656       iNow = GetTimeMs();
 657     }
 658   }
 659
 660   message.state = bTransmitSucceeded && !bError ?
 661       ADAPTER_MESSAGE_STATE_SENT_ACKED :
 662       ADAPTER_MESSAGE_STATE_SENT_NOT_ACKED;
 663
 664   return bTransmitSucceeded && !bError;
 665 }
 666
 667 void CUSBCECAdapterCommunication::AddData(uint8_t *data, size_t iLen)
 668 {
 669   CLockObject lock(m_mutex);
 670   for (size_t iPtr = 0; iPtr < iLen; iPtr++)
 671   {
 672     if (!m_bGotStart)
 673     {
 674       if (data[iPtr] == MSGSTART)
 675         m_bGotStart = true;
 676     }
 677     else if (data[iPtr] == MSGSTART) //we found a msgstart before msgend, this is not right, remove
 678     {
 679       if (m_currentAdapterMessage.Size() > 0)
 680         CLibCEC::AddLog(CEC_LOG_WARNING, "received MSGSTART before MSGEND, removing previous buffer contents");
 681       m_currentAdapterMessage.Clear();
 682       m_bGotStart = true;
 683     }
 684     else if (data[iPtr] == MSGEND)
 685     {
 686       CCECAdapterMessage *newMessage = new CCECAdapterMessage;
 687       newMessage->packet = m_currentAdapterMessage.packet;
 688       m_inBuffer.Push(newMessage);
 689       m_currentAdapterMessage.Clear();
 690       m_bGotStart = false;
 691       m_bNextIsEscaped = false;
 692       m_bHasData = true;
 693       m_rcvCondition.Broadcast();
 694     }
 695     else if (m_bNextIsEscaped)
 696     {
 697       m_currentAdapterMessage.PushBack(data[iPtr] + (uint8_t)ESCOFFSET);
 698       m_bNextIsEscaped = false;
 699     }
 700     else if (data[iPtr] == MSGESC)
 701     {
 702       m_bNextIsEscaped = true;
 703     }
 704     else
 705     {
 706       m_currentAdapterMessage.PushBack(data[iPtr]);
 707     }
 708   }
 709 }
 710
 711 bool CUSBCECAdapterCommunication::ReadFromDevice(uint32_t iTimeout, size_t iSize /* = 256 */)
 712 {
 713   ssize_t iBytesRead;
 714   uint8_t buff[256];
 715   if (!m_port)
 716     return false;
 717   if (iSize > 256)
 718     iSize = 256;
 719
 720   CLockObject lock(m_mutex);
 721   iBytesRead = m_port->Read(buff, sizeof(uint8_t) * iSize, iTimeout);
 722   if (iBytesRead < 0 || iBytesRead > 256)
 723   {
 724     CLibCEC::AddLog(CEC_LOG_ERROR, "error reading from serial port: %s", m_port->GetError().c_str());
 725     StopThread(false);
 726     return false;
 727   }
 728   else if (iBytesRead > 0)
 729   {
 730     AddData(buff, iBytesRead);
 731   }
 732
 733   return iBytesRead > 0;
 734 }
 735
 736 void CUSBCECAdapterCommunication::SendMessageToAdapter(CCECAdapterMessage *msg)
 737 {
 738   CLockObject adapterLock(m_mutex);
 739   if (!m_port->IsOpen())
 740   {
 741     CLibCEC::AddLog(CEC_LOG_ERROR, "error writing to serial port: the connection is closed");
 742     msg->state = ADAPTER_MESSAGE_STATE_ERROR;
 743     return;
 744   }
 745
 746   if (msg->tries == 1)
 747     SetLineTimeout(msg->lineTimeout);
 748   else
 749     SetLineTimeout(msg->retryTimeout);
 750
 751   if (m_port->Write(msg->packet.data, msg->Size()) != (ssize_t) msg->Size())
 752   {
 753     CLibCEC::AddLog(CEC_LOG_ERROR, "error writing to serial port: %s", m_port->GetError().c_str());
 754     msg->state = ADAPTER_MESSAGE_STATE_ERROR;
 755   }
 756   else
 757   {
 758     CLibCEC::AddLog(CEC_LOG_DEBUG, "command sent");
 759     msg->state = ADAPTER_MESSAGE_STATE_SENT;
 760
 761     if (msg->expectControllerAck)
 762     {
 763       if (!WaitForAck(*msg))
 764         CLibCEC::AddLog(CEC_LOG_DEBUG, "did not receive ack");
 765     }
 766   }
 767   msg->event.Signal();
 768 }
 769
 770 void CUSBCECAdapterCommunication::WriteNextCommand(void)
 771 {
 772   CCECAdapterMessage *msg(NULL);
 773   if (m_outBuffer.Pop(msg))
 774     SendMessageToAdapter(msg);
 775 }
 776
 777 CStdString CUSBCECAdapterCommunication::GetPortName(void)
 778 {
 779   CStdString strName;
 780   strName = m_port->GetName();
 781   return strName;
 782 }