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 "USBCECAdapterCommands.h"
  35 #include "USBCECAdapterMessageQueue.h"
  36 #include "../platform/sockets/serialport.h"
  37 #include "../platform/util/timeutils.h"
  38 #include "../LibCEC.h"
  39 #include "../CECProcessor.h"
  40
  41 using namespace std;
  42 using namespace CEC;
  43 using namespace PLATFORM;
  44
  45 #define CEC_ADAPTER_PING_TIMEOUT 15000
  46
  47 // firmware version 2
  48 #define CEC_LATEST_ADAPTER_FW_VERSION 2
  49 // firmware date Thu Apr 26 20:14:49 2012 +0000
  50 #define CEC_LATEST_ADAPTER_FW_DATE    0x4F99ACB9
  51
  52 #define LIB_CEC m_callback->GetLib()
  53
  54 CUSBCECAdapterCommunication::CUSBCECAdapterCommunication(IAdapterCommunicationCallback *callback, const char *strPort, uint16_t iBaudRate /* = CEC_SERIAL_DEFAULT_BAUDRATE */) :
  55     IAdapterCommunication(callback),
  56     m_port(NULL),
  57     m_iLineTimeout(0),
  58     m_lastPollDestination(CECDEVICE_UNKNOWN),
  59     m_bInitialised(false),
  60     m_pingThread(NULL),
  61     m_commands(NULL),
  62     m_adapterMessageQueue(NULL),
  63     m_iAckMask(0xFFFF)
  64 {
  65   for (unsigned int iPtr = CECDEVICE_TV; iPtr < CECDEVICE_BROADCAST; iPtr++)
  66     m_bWaitingForAck[iPtr] = false;
  67   m_port = new CSerialPort(strPort, iBaudRate);
  68 }
  69
  70 CUSBCECAdapterCommunication::~CUSBCECAdapterCommunication(void)
  71 {
  72   Close();
  73   delete m_commands;
  74   delete m_adapterMessageQueue;
  75   delete m_port;
  76 }
  77
  78 bool CUSBCECAdapterCommunication::Open(uint32_t iTimeoutMs /* = CEC_DEFAULT_CONNECT_TIMEOUT */, bool bSkipChecks /* = false */, bool bStartListening /* = true */)
  79 {
  80   bool bConnectionOpened(false);
  81   {
  82     CLockObject lock(m_mutex);
  83
  84     /* we need the port settings here */
  85     if (!m_port)
  86     {
  87       LIB_CEC->AddLog(CEC_LOG_ERROR, "port is NULL");
  88       return bConnectionOpened;
  89     }
  90
  91     /* return true when the port is already open */
  92     if (IsOpen())
  93     {
  94       LIB_CEC->AddLog(CEC_LOG_WARNING, "port is already open");
  95       return true;
  96     }
  97
  98     /* adapter commands */
  99     if (!m_commands)
 100       m_commands = new CUSBCECAdapterCommands(this);
 101
 102     if (!m_adapterMessageQueue)
 103     {
 104       m_adapterMessageQueue = new CCECAdapterMessageQueue(this);
 105       m_adapterMessageQueue->CreateThread();
 106     }
 107
 108     /* try to open the connection */
 109     CStdString strError;
 110     CTimeout timeout(iTimeoutMs);
 111     while (!bConnectionOpened && timeout.TimeLeft() > 0)
 112     {
 113       if ((bConnectionOpened = m_port->Open(timeout.TimeLeft())) == false)
 114       {
 115         strError.Format("error opening serial port '%s': %s", m_port->GetName().c_str(), m_port->GetError().c_str());
 116         Sleep(250);
 117       }
 118       /* and retry every 250ms until the timeout passed */
 119     }
 120
 121     /* return false when we couldn't connect */
 122     if (!bConnectionOpened)
 123     {
 124       LIB_CEC->AddLog(CEC_LOG_ERROR, strError);
 125       return false;
 126     }
 127
 128     LIB_CEC->AddLog(CEC_LOG_DEBUG, "connection opened, clearing any previous input and waiting for active transmissions to end before starting");
 129     ClearInputBytes();
 130   }
 131
 132   if (!CreateThread())
 133   {
 134     bConnectionOpened = false;
 135     LIB_CEC->AddLog(CEC_LOG_ERROR, "could not create a communication thread");
 136   }
 137   else if (!bSkipChecks && !CheckAdapter())
 138   {
 139     bConnectionOpened = false;
 140     LIB_CEC->AddLog(CEC_LOG_ERROR, "the adapter failed to pass basic checks");
 141   }
 142   else if (bStartListening)
 143   {
 144     /* start a ping thread, that will ping the adapter every 15 seconds
 145        if it doesn't receive any ping for 30 seconds, it'll switch to auto mode */
 146     m_pingThread = new CAdapterPingThread(this, CEC_ADAPTER_PING_TIMEOUT);
 147     if (m_pingThread->CreateThread())
 148     {
 149       bConnectionOpened = true;
 150     }
 151     else
 152     {
 153       bConnectionOpened = false;
 154       LIB_CEC->AddLog(CEC_LOG_ERROR, "could not create a ping thread");
 155     }
 156   }
 157
 158   if (!bConnectionOpened || !bStartListening)
 159     StopThread(0);
 160
 161   return bConnectionOpened;
 162 }
 163
 164 void CUSBCECAdapterCommunication::Close(void)
 165 {
 166   /* stop the reader thread */
 167   StopThread(0);
 168
 169   CLockObject lock(m_mutex);
 170
 171   /* set the ackmask to 0 before closing the connection */
 172   if (IsRunning() && m_port->IsOpen() && m_port->GetErrorNumber() == 0)
 173   {
 174     LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - closing the connection", __FUNCTION__);
 175     SetAckMask(0);
 176     if (m_commands->GetFirmwareVersion() >= 2)
 177       SetControlledMode(false);
 178   }
 179
 180   m_adapterMessageQueue->Clear();
 181
 182   /* stop and delete the ping thread */
 183   if (m_pingThread)
 184     m_pingThread->StopThread(0);
 185   delete m_pingThread;
 186   m_pingThread = NULL;
 187
 188   /* close and delete the com port connection */
 189   if (m_port)
 190     m_port->Close();
 191 }
 192
 193 cec_adapter_message_state CUSBCECAdapterCommunication::Write(const cec_command &data, bool &bRetry, uint8_t iLineTimeout)
 194 {
 195   cec_adapter_message_state retVal(ADAPTER_MESSAGE_STATE_UNKNOWN);
 196   if (!IsRunning())
 197     return retVal;
 198
 199   CCECAdapterMessage *output = new CCECAdapterMessage(data, iLineTimeout);
 200
 201   /* mark as waiting for an ack from the destination */
 202   MarkAsWaiting(data.destination);
 203
 204   /* send the message */
 205   bRetry = (!m_adapterMessageQueue->Write(output) || output->NeedsRetry()) && output->transmit_timeout > 0;
 206   if (bRetry)
 207     Sleep(CEC_DEFAULT_TRANSMIT_RETRY_WAIT);
 208   retVal = output->state;
 209
 210   delete output;
 211   return retVal;
 212 }
 213
 214 void *CUSBCECAdapterCommunication::Process(void)
 215 {
 216   CCECAdapterMessage msg;
 217   LIB_CEC->AddLog(CEC_LOG_DEBUG, "communication thread started");
 218
 219   while (!IsStopped())
 220   {
 221     /* read from the serial port */
 222     if (!ReadFromDevice(50, 5))
 223     {
 224       libcec_parameter param;
 225       param.paramData = NULL; param.paramType = CEC_PARAMETER_TYPE_UNKOWN;
 226       LIB_CEC->Alert(CEC_ALERT_CONNECTION_LOST, param);
 227
 228       break;
 229     }
 230
 231     /* TODO sleep 5 ms so other threads can get a lock */
 232     Sleep(5);
 233   }
 234
 235   m_adapterMessageQueue->Clear();
 236   LIB_CEC->AddLog(CEC_LOG_DEBUG, "communication thread ended");
 237   return NULL;
 238 }
 239
 240 bool CUSBCECAdapterCommunication::HandlePoll(const CCECAdapterMessage &msg)
 241 {
 242   bool bIsError(msg.IsError());
 243   cec_adapter_messagecode messageCode(msg.Message());
 244   CLockObject lock(m_mutex);
 245
 246   if (messageCode == MSGCODE_FRAME_START && msg.IsACK())
 247   {
 248     m_lastPollDestination = msg.Destination();
 249     if (msg.Destination() < CECDEVICE_BROADCAST)
 250     {
 251       if (!m_bWaitingForAck[msg.Destination()] && !msg.IsEOM())
 252       {
 253         if (m_callback)
 254           m_callback->HandlePoll(msg.Initiator(), msg.Destination());
 255       }
 256       else
 257         m_bWaitingForAck[msg.Destination()] = false;
 258     }
 259   }
 260   else if (messageCode == MSGCODE_RECEIVE_FAILED)
 261   {
 262     /* hack to suppress warnings when an LG is polling */
 263     if (m_lastPollDestination != CECDEVICE_UNKNOWN)
 264       bIsError = m_callback->HandleReceiveFailed(m_lastPollDestination);
 265   }
 266
 267   return bIsError;
 268 }
 269
 270 void CUSBCECAdapterCommunication::MarkAsWaiting(const cec_logical_address dest)
 271 {
 272   /* mark as waiting for an ack from the destination */
 273   if (dest < CECDEVICE_BROADCAST)
 274   {
 275     CLockObject lock(m_mutex);
 276     m_bWaitingForAck[dest] = true;
 277   }
 278 }
 279
 280 void CUSBCECAdapterCommunication::ClearInputBytes(uint32_t iTimeout /* = CEC_CLEAR_INPUT_DEFAULT_WAIT */)
 281 {
 282   CTimeout timeout(iTimeout);
 283   uint8_t buff[1024];
 284   ssize_t iBytesRead(0);
 285   bool bGotMsgEnd(true);
 286
 287   while (timeout.TimeLeft() > 0 && ((iBytesRead = m_port->Read(buff, 1024, 5)) > 0 || !bGotMsgEnd))
 288   {
 289     bGotMsgEnd = false;
 290     /* if something was received, wait for MSGEND */
 291     for (ssize_t iPtr = 0; iPtr < iBytesRead; iPtr++)
 292       bGotMsgEnd = buff[iPtr] == MSGEND;
 293   }
 294 }
 295
 296 bool CUSBCECAdapterCommunication::SetLineTimeout(uint8_t iTimeout)
 297 {
 298   bool bReturn(true);
 299   bool bChanged(false);
 300
 301   /* only send the command if the timeout changed */
 302   {
 303     CLockObject lock(m_mutex);
 304     bChanged = (m_iLineTimeout != iTimeout);
 305     m_iLineTimeout = iTimeout;
 306   }
 307
 308   if (bChanged)
 309     bReturn = m_commands->SetLineTimeout(iTimeout);
 310
 311   return bReturn;
 312 }
 313
 314 bool CUSBCECAdapterCommunication::WriteToDevice(CCECAdapterMessage *message)
 315 {
 316   CLockObject adapterLock(m_mutex);
 317   if (!m_port->IsOpen())
 318   {
 319     LIB_CEC->AddLog(CEC_LOG_DEBUG, "error writing command '%s' to serial port '%s': the connection is closed", CCECAdapterMessage::ToString(message->Message()), m_port->GetName().c_str());
 320     message->state = ADAPTER_MESSAGE_STATE_ERROR;
 321     return false;
 322   }
 323
 324   /* write the message */
 325   if (m_port->Write(message->packet.data, message->Size()) != (ssize_t) message->Size())
 326   {
 327     LIB_CEC->AddLog(CEC_LOG_DEBUG, "error writing command '%s' to serial port '%s': %s", CCECAdapterMessage::ToString(message->Message()), m_port->GetName().c_str(), m_port->GetError().c_str());
 328     message->state = ADAPTER_MESSAGE_STATE_ERROR;
 329     Close();
 330     return false;
 331   }
 332
 333   LIB_CEC->AddLog(CEC_LOG_DEBUG, "command '%s' sent", message->IsTranmission() ? "CEC transmission" : CCECAdapterMessage::ToString(message->Message()));
 334   message->state = ADAPTER_MESSAGE_STATE_SENT;
 335   return true;
 336 }
 337
 338 bool CUSBCECAdapterCommunication::ReadFromDevice(uint32_t iTimeout, size_t iSize /* = 256 */)
 339 {
 340   ssize_t iBytesRead(0);
 341   uint8_t buff[256];
 342   if (iSize > 256)
 343     iSize = 256;
 344
 345   /* read from the serial port */
 346   {
 347     CLockObject lock(m_mutex);
 348     if (!m_port || !m_port->IsOpen())
 349       return false;
 350
 351     iBytesRead = m_port->Read(buff, sizeof(uint8_t) * iSize, iTimeout);
 352
 353     if (m_port->GetErrorNumber())
 354     {
 355       LIB_CEC->AddLog(CEC_LOG_ERROR, "error reading from serial port: %s", m_port->GetError().c_str());
 356       m_port->Close();
 357       return false;
 358     }
 359   }
 360
 361   if (iBytesRead < 0 || iBytesRead > 256)
 362     return false;
 363   else if (iBytesRead > 0)
 364   {
 365     /* add the data to the current frame */
 366     m_adapterMessageQueue->AddData(buff, iBytesRead);
 367   }
 368
 369   return true;
 370 }
 371
 372 CCECAdapterMessage *CUSBCECAdapterCommunication::SendCommand(cec_adapter_messagecode msgCode, CCECAdapterMessage &params, bool bIsRetry /* = false */)
 373 {
 374   if (!m_port || !m_port->IsOpen() ||
 375       !m_adapterMessageQueue)
 376     return NULL;
 377
 378   /* create the adapter message for this command */
 379   CCECAdapterMessage *output = new CCECAdapterMessage;
 380   output->PushBack(MSGSTART);
 381   output->PushEscaped((uint8_t)msgCode);
 382   output->Append(params);
 383   output->PushBack(MSGEND);
 384
 385   /* write the command */
 386   if (!m_adapterMessageQueue->Write(output))
 387   {
 388     if (output->state == ADAPTER_MESSAGE_STATE_ERROR)
 389     {
 390       libcec_parameter param;
 391       param.paramData = NULL; param.paramType = CEC_PARAMETER_TYPE_UNKOWN;
 392       LIB_CEC->Alert(CEC_ALERT_CONNECTION_LOST, param);
 393
 394       Close();
 395     }
 396     return output;
 397   }
 398   else
 399   {
 400     if (!bIsRetry && output->Reply() == MSGCODE_COMMAND_REJECTED && msgCode != MSGCODE_SET_CONTROLLED &&
 401         msgCode != MSGCODE_GET_BUILDDATE /* same messagecode value had a different meaning in older fw builds */)
 402     {
 403       /* if the controller reported that the command was rejected, and we didn't send the command
 404          to set controlled mode, then the controller probably switched to auto mode. set controlled
 405          mode and retry */
 406       LIB_CEC->AddLog(CEC_LOG_DEBUG, "setting controlled mode and retrying");
 407       delete output;
 408       if (SetControlledMode(true))
 409         return SendCommand(msgCode, params, true);
 410     }
 411   }
 412
 413   return output;
 414 }
 415
 416 bool CUSBCECAdapterCommunication::CheckAdapter(uint32_t iTimeoutMs /* = CEC_DEFAULT_CONNECT_TIMEOUT */)
 417 {
 418   bool bReturn(false);
 419   CTimeout timeout(iTimeoutMs > 0 ? iTimeoutMs : CEC_DEFAULT_TRANSMIT_WAIT);
 420
 421   /* try to ping the adapter */
 422   bool bPinged(false);
 423   unsigned iPingTry(0);
 424   while (timeout.TimeLeft() > 0 && (bPinged = PingAdapter()) == false)
 425   {
 426     LIB_CEC->AddLog(CEC_LOG_ERROR, "the adapter did not respond correctly to a ping (try %d)", ++iPingTry);
 427     CEvent::Sleep(500);
 428   }
 429
 430   /* try to read the firmware version */
 431   if (bPinged && timeout.TimeLeft() > 0 && m_commands->RequestFirmwareVersion() >= 2)
 432   {
 433     /* try to set controlled mode for v2+ firmwares */
 434     unsigned iControlledTry(0);
 435     bool bControlled(false);
 436     while (timeout.TimeLeft() > 0 && (bControlled = SetControlledMode(true)) == false)
 437     {
 438       LIB_CEC->AddLog(CEC_LOG_ERROR, "the adapter did not respond correctly to setting controlled mode (try %d)", ++iControlledTry);
 439       CEvent::Sleep(500);
 440     }
 441     bReturn = bControlled;
 442   }
 443   else
 444     bReturn = true;
 445
 446   /* try to read the build date */
 447   m_commands->RequestBuildDate();
 448
 449   SetInitialised(bReturn);
 450   return bReturn;
 451 }
 452
 453 bool CUSBCECAdapterCommunication::IsOpen(void)
 454 {
 455   /* thread is not being stopped, the port is open and the thread is running */
 456   return !IsStopped() && m_port->IsOpen() && IsRunning();
 457 }
 458
 459 CStdString CUSBCECAdapterCommunication::GetError(void) const
 460 {
 461   return m_port->GetError();
 462 }
 463
 464 void CUSBCECAdapterCommunication::SetInitialised(bool bSetTo /* = true */)
 465 {
 466   CLockObject lock(m_mutex);
 467   m_bInitialised = bSetTo;
 468 }
 469
 470 bool CUSBCECAdapterCommunication::IsInitialised(void)
 471 {
 472   CLockObject lock(m_mutex);
 473   return m_bInitialised;
 474 }
 475
 476 bool CUSBCECAdapterCommunication::StartBootloader(void)
 477 {
 478   if (m_port->IsOpen() && m_commands->StartBootloader())
 479   {
 480     Close();
 481     return true;
 482   }
 483   return false;
 484 }
 485
 486 bool CUSBCECAdapterCommunication::SetAckMask(uint16_t iMask)
 487 {
 488   if (m_iAckMask == iMask)
 489     return true;
 490
 491   if (m_port && m_port->IsOpen() && m_commands->SetAckMask(iMask))
 492   {
 493     m_iAckMask = iMask;
 494     return true;
 495   }
 496
 497   return false;
 498 }
 499
 500 uint16_t CUSBCECAdapterCommunication::GetAckMask(void)
 501 {
 502   return m_iAckMask;
 503 }
 504
 505 bool CUSBCECAdapterCommunication::PingAdapter(void)
 506 {
 507   return m_port->IsOpen() ? m_commands->PingAdapter() : false;
 508 }
 509
 510 uint16_t CUSBCECAdapterCommunication::GetFirmwareVersion(void)
 511 {
 512   return m_commands->GetFirmwareVersion();
 513 }
 514
 515 uint32_t CUSBCECAdapterCommunication::GetFirmwareBuildDate(void)
 516 {
 517   return m_commands->RequestBuildDate();
 518 }
 519
 520 bool CUSBCECAdapterCommunication::IsRunningLatestFirmware(void)
 521 {
 522   return GetFirmwareVersion() >= CEC_LATEST_ADAPTER_FW_VERSION &&
 523       GetFirmwareBuildDate() >= CEC_LATEST_ADAPTER_FW_DATE;
 524 }
 525
 526 bool CUSBCECAdapterCommunication::PersistConfiguration(libcec_configuration *configuration)
 527 {
 528   return m_port->IsOpen() ? m_commands->PersistConfiguration(configuration) : false;
 529 }
 530
 531 bool CUSBCECAdapterCommunication::GetConfiguration(libcec_configuration *configuration)
 532 {
 533   return m_port->IsOpen() ? m_commands->GetConfiguration(configuration) : false;
 534 }
 535
 536 CStdString CUSBCECAdapterCommunication::GetPortName(void)
 537 {
 538   return m_port->GetName();
 539 }
 540
 541 bool CUSBCECAdapterCommunication::SetControlledMode(bool controlled)
 542 {
 543   return m_port->IsOpen() ? m_commands->SetControlledMode(controlled) : false;
 544 }
 545
 546 void *CAdapterPingThread::Process(void)
 547 {
 548   while (!IsStopped())
 549   {
 550     if (m_timeout.TimeLeft() == 0)
 551     {
 552       /* reinit the timeout */
 553       m_timeout.Init(CEC_ADAPTER_PING_TIMEOUT);
 554
 555       /* send a ping to the adapter */
 556       bool bPinged(false);
 557       int iFailedCounter(0);
 558       while (!bPinged && iFailedCounter < 3)
 559       {
 560         if (!m_com->PingAdapter())
 561         {
 562           /* sleep and retry */
 563           Sleep(CEC_DEFAULT_TRANSMIT_RETRY_WAIT);
 564           ++iFailedCounter;
 565         }
 566         else
 567         {
 568           bPinged = true;
 569         }
 570       }
 571
 572       if (iFailedCounter == 3)
 573       {
 574         /* failed to ping the adapter 3 times in a row. something must be wrong with the connection */
 575         m_com->LIB_CEC->AddLog(CEC_LOG_ERROR, "failed to ping the adapter 3 times in a row. closing the connection.");
 576         m_com->StopThread(false);
 577         break;
 578       }
 579     }
 580
 581     Sleep(500);
 582   }
 583   return NULL;
 584 }