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