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