src/lib/adapter/Pulse-Eight/USBCECAdapterCommands.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 "env.h"
  34 #include "USBCECAdapterCommands.h"
  35
  36 #include "USBCECAdapterMessage.h"
  37 #include "USBCECAdapterCommunication.h"
  38 #include "lib/LibCEC.h"
  39 #include "lib/CECProcessor.h"
  40 #include "lib/CECTypeUtils.h"
  41 #include <stdio.h>
  42
  43 using namespace CEC;
  44 using namespace PLATFORM;
  45
  46 #define LIB_CEC     m_comm->m_callback->GetLib()
  47 #define ToString(p) CCECTypeUtils::ToString(p)
  48
  49 CUSBCECAdapterCommands::CUSBCECAdapterCommands(CUSBCECAdapterCommunication *comm) :
  50     m_comm(comm),
  51     m_bSettingsRetrieved(false),
  52     m_bSettingAutoEnabled(false),
  53     m_settingCecVersion(CEC_VERSION_UNKNOWN),
  54     m_iSettingLAMask(0),
  55     m_bNeedsWrite(false),
  56     m_iBuildDate(CEC_FW_BUILD_UNKNOWN),
  57     m_bControlledMode(false),
  58     m_adapterType(P8_ADAPTERTYPE_UNKNOWN)
  59 {
  60   m_persistedConfiguration.Clear();
  61 }
  62
  63 cec_datapacket CUSBCECAdapterCommands::RequestSetting(cec_adapter_messagecode msgCode)
  64 {
  65   cec_datapacket retVal;
  66   retVal.Clear();
  67
  68   CCECAdapterMessage params;
  69   CCECAdapterMessage *message = m_comm->SendCommand(msgCode, params);
  70   if (message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED)
  71   {
  72     retVal = message->response;
  73     retVal.Shift(2); // shift out start and msgcode
  74     retVal.size -= 1; // remove end
  75   }
  76
  77   delete message;
  78   return retVal;
  79 }
  80
  81 uint16_t CUSBCECAdapterCommands::RequestFirmwareVersion(void)
  82 {
  83   m_persistedConfiguration.iFirmwareVersion = CEC_FW_VERSION_UNKNOWN;
  84   unsigned int iFwVersionTry(0);
  85
  86   while (m_persistedConfiguration.iFirmwareVersion == CEC_FW_VERSION_UNKNOWN && iFwVersionTry++ < 3)
  87   {
  88     LIB_CEC->AddLog(CEC_LOG_DEBUG, "requesting the firmware version");
  89     cec_datapacket response = RequestSetting(MSGCODE_FIRMWARE_VERSION);
  90     if (response.size == 2)
  91       m_persistedConfiguration.iFirmwareVersion = (response[0] << 8 | response[1]);
  92     else
  93     {
  94       LIB_CEC->AddLog(CEC_LOG_WARNING, "the adapter did not respond with a correct firmware version (try %d, size = %d)", iFwVersionTry, response.size);
  95       CEvent::Sleep(500);
  96     }
  97   }
  98
  99   if (m_persistedConfiguration.iFirmwareVersion == CEC_FW_VERSION_UNKNOWN)
 100   {
 101     LIB_CEC->AddLog(CEC_LOG_DEBUG, "defaulting to firmware version 1");
 102     m_persistedConfiguration.iFirmwareVersion = 1;
 103   }
 104
 105   return m_persistedConfiguration.iFirmwareVersion;
 106 }
 107
 108 bool CUSBCECAdapterCommands::RequestSettingAutoEnabled(void)
 109 {
 110   LIB_CEC->AddLog(CEC_LOG_DEBUG, "requesting autonomous mode setting");
 111
 112   cec_datapacket response = RequestSetting(MSGCODE_GET_AUTO_ENABLED);
 113   if (response.size == 1)
 114   {
 115     m_bSettingAutoEnabled = response[0] == 1;
 116     LIB_CEC->AddLog(CEC_LOG_DEBUG, "using persisted autonomous mode setting: '%s'", m_bSettingAutoEnabled ? "enabled" : "disabled");
 117     return true;
 118   }
 119   return false;
 120 }
 121
 122 bool CUSBCECAdapterCommands::RequestSettingCECVersion(void)
 123 {
 124   LIB_CEC->AddLog(CEC_LOG_DEBUG, "requesting CEC version setting");
 125
 126   cec_datapacket response = RequestSetting(MSGCODE_GET_HDMI_VERSION);
 127   if (response.size == 1)
 128   {
 129     m_settingCecVersion = (cec_version)response[0];
 130     LIB_CEC->AddLog(CEC_LOG_DEBUG, "using persisted CEC version setting: '%s'", ToString(m_settingCecVersion));
 131     return true;
 132   }
 133   return false;
 134 }
 135
 136 p8_cec_adapter_type CUSBCECAdapterCommands::RequestAdapterType(void)
 137 {
 138   if (m_adapterType == P8_ADAPTERTYPE_UNKNOWN)
 139   {
 140     LIB_CEC->AddLog(CEC_LOG_DEBUG, "requesting adapter type");
 141
 142     cec_datapacket response = RequestSetting(MSGCODE_GET_ADAPTER_TYPE);
 143     if (response.size == 1)
 144       m_adapterType = (p8_cec_adapter_type)response[0];
 145   }
 146   return m_adapterType;
 147 }
 148
 149 uint32_t CUSBCECAdapterCommands::RequestBuildDate(void)
 150 {
 151   if (m_iBuildDate == CEC_FW_BUILD_UNKNOWN)
 152   {
 153     LIB_CEC->AddLog(CEC_LOG_DEBUG, "requesting firmware build date");
 154
 155     cec_datapacket response = RequestSetting(MSGCODE_GET_BUILDDATE);
 156     if (response.size == 4)
 157       m_iBuildDate = (uint32_t)response[0] << 24 | (uint32_t)response[1] << 16 | (uint32_t)response[2] << 8 | (uint32_t)response[3];
 158   }
 159   return m_iBuildDate;
 160 }
 161
 162 bool CUSBCECAdapterCommands::RequestSettingDefaultLogicalAddress(void)
 163 {
 164   LIB_CEC->AddLog(CEC_LOG_DEBUG, "requesting default logical address setting");
 165
 166   cec_datapacket response = RequestSetting(MSGCODE_GET_DEFAULT_LOGICAL_ADDRESS);
 167   if (response.size == 1)
 168   {
 169     m_persistedConfiguration.logicalAddresses.primary = (cec_logical_address)response[0];
 170     LIB_CEC->AddLog(CEC_LOG_DEBUG, "using persisted logical address setting: '%s'", ToString(m_persistedConfiguration.logicalAddresses.primary));
 171     return true;
 172   }
 173   return false;
 174 }
 175
 176 bool CUSBCECAdapterCommands::RequestSettingDeviceType(void)
 177 {
 178   LIB_CEC->AddLog(CEC_LOG_DEBUG, "requesting device type setting");
 179   m_persistedConfiguration.deviceTypes.Clear();
 180
 181   cec_datapacket response = RequestSetting(MSGCODE_GET_DEVICE_TYPE);
 182   if (response.size == 1)
 183   {
 184     m_persistedConfiguration.deviceTypes.Add((cec_device_type)response[0]);
 185     LIB_CEC->AddLog(CEC_LOG_DEBUG, "using persisted device type setting: '%s'", ToString((cec_device_type)response[0]));
 186     return true;
 187   }
 188   LIB_CEC->AddLog(CEC_LOG_DEBUG, "no persisted device type setting");
 189   return false;
 190 }
 191
 192 bool CUSBCECAdapterCommands::RequestSettingLogicalAddressMask(void)
 193 {
 194   LIB_CEC->AddLog(CEC_LOG_DEBUG, "requesting logical address mask setting");
 195
 196   cec_datapacket response = RequestSetting(MSGCODE_GET_LOGICAL_ADDRESS_MASK);
 197   if (response.size == 2)
 198   {
 199     m_iSettingLAMask = ((uint16_t)response[0] << 8) | ((uint16_t)response[1]);
 200     LIB_CEC->AddLog(CEC_LOG_DEBUG, "using persisted logical address mask setting: '%x'", m_iSettingLAMask);
 201     return true;
 202   }
 203   return false;
 204 }
 205
 206 bool CUSBCECAdapterCommands::RequestSettingOSDName(void)
 207 {
 208   LIB_CEC->AddLog(CEC_LOG_DEBUG, "requesting OSD name setting");
 209
 210   memset(m_persistedConfiguration.strDeviceName, 0, 13);
 211   cec_datapacket response = RequestSetting(MSGCODE_GET_OSD_NAME);
 212   if (response.size == 0)
 213   {
 214     LIB_CEC->AddLog(CEC_LOG_DEBUG, "no persisted device name setting");
 215     return false;
 216   }
 217
 218   char buf[14];
 219   for (uint8_t iPtr = 0; iPtr < response.size && iPtr < 13; iPtr++)
 220     buf[iPtr] = (char)response[iPtr];
 221   buf[response.size] = 0;
 222
 223   snprintf(m_persistedConfiguration.strDeviceName, 13, "%s", buf);
 224   LIB_CEC->AddLog(CEC_LOG_DEBUG, "using persisted device name setting: '%s'", buf);
 225   return true;
 226 }
 227
 228 bool CUSBCECAdapterCommands::RequestSettingPhysicalAddress(void)
 229 {
 230   LIB_CEC->AddLog(CEC_LOG_DEBUG, "requesting physical address setting");
 231
 232   cec_datapacket response = RequestSetting(MSGCODE_GET_PHYSICAL_ADDRESS);
 233   if (response.size == 2)
 234   {
 235     m_persistedConfiguration.iPhysicalAddress = ((uint16_t)response[0] << 8) | ((uint16_t)response[1]);
 236     LIB_CEC->AddLog(CEC_LOG_DEBUG, "using persisted physical address setting: '%4x'", m_persistedConfiguration.iPhysicalAddress);
 237     return true;
 238   }
 239   LIB_CEC->AddLog(CEC_LOG_DEBUG, "no persisted physical address setting");
 240   return false;
 241 }
 242
 243 bool CUSBCECAdapterCommands::SetSettingAutoEnabled(bool enabled)
 244 {
 245   bool bReturn(false);
 246
 247   /* check whether this value was changed */
 248   {
 249     CLockObject lock(m_mutex);
 250     if (m_bSettingAutoEnabled == enabled)
 251       return bReturn;
 252     m_bNeedsWrite = true;
 253   }
 254
 255   LIB_CEC->AddLog(CEC_LOG_DEBUG, "turning autonomous mode %s", enabled ? "on" : "off");
 256
 257   CCECAdapterMessage params;
 258   params.PushEscaped(enabled ? 1 : 0);
 259   CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_SET_AUTO_ENABLED, params);
 260   bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
 261   delete message;
 262
 263   if (bReturn)
 264   {
 265     CLockObject lock(m_mutex);
 266     m_bSettingAutoEnabled = enabled;
 267   }
 268
 269   return bReturn;
 270 }
 271
 272 bool CUSBCECAdapterCommands::SetSettingDeviceType(cec_device_type type)
 273 {
 274   bool bReturn(false);
 275
 276   /* check whether this value was changed */
 277   {
 278     CLockObject lock(m_mutex);
 279     if (m_persistedConfiguration.deviceTypes.types[0] == type)
 280       return bReturn;
 281     m_bNeedsWrite = true;
 282   }
 283
 284   LIB_CEC->AddLog(CEC_LOG_DEBUG, "setting the device type to %X (previous: %X)", (uint8_t)type, (uint8_t)m_persistedConfiguration.deviceTypes.types[0]);
 285
 286   CCECAdapterMessage params;
 287   params.PushEscaped((uint8_t)type);
 288   CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_SET_DEVICE_TYPE, params);
 289   bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
 290   delete message;
 291
 292   if (bReturn)
 293   {
 294     CLockObject lock(m_mutex);
 295     m_persistedConfiguration.deviceTypes.types[0] = type;
 296   }
 297
 298   return bReturn;
 299 }
 300
 301 bool CUSBCECAdapterCommands::SetSettingDefaultLogicalAddress(cec_logical_address address)
 302 {
 303   bool bReturn(false);
 304
 305   /* check whether this value was changed */
 306   {
 307     CLockObject lock(m_mutex);
 308     if (m_persistedConfiguration.logicalAddresses.primary == address)
 309       return bReturn;
 310     m_bNeedsWrite = true;
 311   }
 312
 313   LIB_CEC->AddLog(CEC_LOG_DEBUG, "setting the default logical address to %X (previous: %X)", (uint8_t)address, (uint8_t)m_persistedConfiguration.logicalAddresses.primary);
 314
 315   CCECAdapterMessage params;
 316   params.PushEscaped((uint8_t)address);
 317   CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_SET_DEFAULT_LOGICAL_ADDRESS, params);
 318   bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
 319   delete message;
 320
 321   if (bReturn)
 322   {
 323     CLockObject lock(m_mutex);
 324     m_persistedConfiguration.logicalAddresses.primary = address;
 325   }
 326
 327   return bReturn;
 328 }
 329
 330 bool CUSBCECAdapterCommands::SetSettingLogicalAddressMask(uint16_t iMask)
 331 {
 332   bool bReturn(false);
 333
 334   /* check whether this value was changed */
 335   {
 336     CLockObject lock(m_mutex);
 337     if (m_iSettingLAMask == iMask)
 338       return bReturn;
 339     m_bNeedsWrite = true;
 340   }
 341
 342   LIB_CEC->AddLog(CEC_LOG_DEBUG, "setting the logical address mask to %2X (previous: %2X)", iMask, m_iSettingLAMask);
 343
 344   CCECAdapterMessage params;
 345   params.PushEscaped(iMask >> 8);
 346   params.PushEscaped((uint8_t)iMask);
 347   CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_SET_LOGICAL_ADDRESS_MASK, params);
 348   bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
 349   delete message;
 350
 351   if (bReturn)
 352   {
 353     CLockObject lock(m_mutex);
 354     m_iSettingLAMask = iMask;
 355   }
 356
 357   return bReturn;
 358 }
 359
 360 bool CUSBCECAdapterCommands::SetSettingPhysicalAddress(uint16_t iPhysicalAddress)
 361 {
 362   bool bReturn(false);
 363
 364   /* check whether this value was changed */
 365   {
 366     CLockObject lock(m_mutex);
 367     if (m_persistedConfiguration.iPhysicalAddress == iPhysicalAddress)
 368       return bReturn;
 369     m_bNeedsWrite = true;
 370   }
 371
 372   LIB_CEC->AddLog(CEC_LOG_DEBUG, "setting the physical address to %04X (previous: %04X)", iPhysicalAddress, m_persistedConfiguration.iPhysicalAddress);
 373
 374   CCECAdapterMessage params;
 375   params.PushEscaped(iPhysicalAddress >> 8);
 376   params.PushEscaped((uint8_t)iPhysicalAddress);
 377   CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_SET_PHYSICAL_ADDRESS, params);
 378   bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
 379   delete message;
 380
 381   if (bReturn)
 382   {
 383     CLockObject lock(m_mutex);
 384     m_persistedConfiguration.iPhysicalAddress = iPhysicalAddress;
 385   }
 386
 387   return bReturn;
 388 }
 389
 390 bool CUSBCECAdapterCommands::SetSettingCECVersion(cec_version version)
 391 {
 392   bool bReturn(false);
 393
 394   /* check whether this value was changed */
 395   {
 396     CLockObject lock(m_mutex);
 397     if (m_settingCecVersion == version)
 398       return bReturn;
 399     m_bNeedsWrite = true;
 400   }
 401
 402   LIB_CEC->AddLog(CEC_LOG_DEBUG, "setting the CEC version to %s (previous: %s)", ToString(version), ToString(m_settingCecVersion));
 403
 404   CCECAdapterMessage params;
 405   params.PushEscaped((uint8_t)version);
 406   CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_SET_HDMI_VERSION, params);
 407   bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
 408   delete message;
 409
 410   if (bReturn)
 411   {
 412     CLockObject lock(m_mutex);
 413     m_settingCecVersion = version;
 414   }
 415
 416   return bReturn;
 417 }
 418
 419 bool CUSBCECAdapterCommands::SetSettingOSDName(const char *strOSDName)
 420 {
 421   bool bReturn(false);
 422
 423   /* check whether this value was changed */
 424   if (!strcmp(m_persistedConfiguration.strDeviceName, strOSDName))
 425     return bReturn;
 426
 427   LIB_CEC->AddLog(CEC_LOG_DEBUG, "setting the OSD name to %s (previous: %s)", strOSDName, m_persistedConfiguration.strDeviceName);
 428
 429   CCECAdapterMessage params;
 430   for (size_t iPtr = 0; iPtr < strlen(strOSDName); iPtr++)
 431     params.PushEscaped(strOSDName[iPtr]);
 432   CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_SET_OSD_NAME, params);
 433   bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
 434   delete message;
 435
 436   if (bReturn)
 437     snprintf(m_persistedConfiguration.strDeviceName, 13, "%s", strOSDName);
 438
 439   return bReturn;
 440 }
 441
 442 bool CUSBCECAdapterCommands::WriteEEPROM(void)
 443 {
 444   {
 445     CLockObject lock(m_mutex);
 446     if (!m_bNeedsWrite)
 447       return true;
 448   }
 449
 450   LIB_CEC->AddLog(CEC_LOG_DEBUG, "writing settings in the EEPROM");
 451
 452   CCECAdapterMessage params;
 453   CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_WRITE_EEPROM, params);
 454   bool bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
 455   delete message;
 456
 457   if (bReturn)
 458   {
 459     CLockObject lock(m_mutex);
 460     m_bNeedsWrite = false;
 461   }
 462
 463   return bReturn;
 464 }
 465
 466 bool CUSBCECAdapterCommands::PersistConfiguration(const libcec_configuration &configuration)
 467 {
 468   bool bReturn(false);
 469   if (m_persistedConfiguration.iFirmwareVersion < 2)
 470     return bReturn;
 471
 472   if (!RequestSettings())
 473     return bReturn;
 474
 475   bReturn |= SetSettingAutoEnabled(true);
 476   bReturn |= SetSettingDeviceType(CLibCEC::GetType(configuration.logicalAddresses.primary));
 477   bReturn |= SetSettingDefaultLogicalAddress(configuration.logicalAddresses.primary);
 478   bReturn |= SetSettingLogicalAddressMask(CLibCEC::GetMaskForType(configuration.logicalAddresses.primary));
 479   bReturn |= SetSettingPhysicalAddress(configuration.iPhysicalAddress);
 480   bReturn |= SetSettingCECVersion(configuration.clientVersion >= CEC_CLIENT_VERSION_1_8_0 ? configuration.cecVersion : CEC_VERSION_1_4);
 481   bReturn |= SetSettingOSDName(configuration.strDeviceName);
 482
 483   return bReturn;
 484 }
 485
 486 bool CUSBCECAdapterCommands::RequestSettings(void)
 487 {
 488   if (m_persistedConfiguration.iFirmwareVersion < 2)
 489   {
 490     LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - firmware version %d does not have any eeprom settings", __FUNCTION__, m_persistedConfiguration.iFirmwareVersion);
 491     // settings can only be persisted with firmware v2+
 492     return false;
 493   }
 494
 495   if (m_bSettingsRetrieved)
 496     return true;
 497
 498   bool bReturn(true);
 499   bReturn &= RequestSettingAutoEnabled();
 500   bReturn &= RequestSettingCECVersion();
 501   bReturn &= RequestSettingDefaultLogicalAddress();
 502   bReturn &= RequestSettingDeviceType();
 503   bReturn &= RequestSettingLogicalAddressMask();
 504   bReturn &= RequestSettingOSDName();
 505   bReturn &= RequestSettingPhysicalAddress();
 506
 507   // don't read the following settings:
 508   // - auto enabled (always enabled)
 509   // - default logical address (autodetected)
 510   // - logical address mask (autodetected)
 511   // - CEC version (1.3a)
 512
 513   // TODO to be added to the firmware:
 514   // - base device (4 bits)
 515   // - HDMI port number (4 bits)
 516   // - TV vendor id (12 bits)
 517   // - wake devices (8 bits)
 518   // - standby devices (8 bits)
 519   // - use TV menu language (1 bit)
 520   // - activate source (1 bit)
 521   // - power off screensaver (1 bit)
 522   // - power off on standby (1 bit)
 523   // - send inactive source (1 bit)
 524
 525   m_bSettingsRetrieved = true;
 526
 527   return bReturn;
 528 }
 529
 530 bool CUSBCECAdapterCommands::GetConfiguration(libcec_configuration &configuration)
 531 {
 532   // get the settings from the eeprom if needed
 533   if (!RequestSettings())
 534     return false;
 535
 536   // copy the settings
 537   configuration.iFirmwareVersion = m_persistedConfiguration.iFirmwareVersion;
 538   configuration.deviceTypes      = m_persistedConfiguration.deviceTypes;
 539   configuration.iPhysicalAddress = m_persistedConfiguration.iPhysicalAddress;
 540   snprintf(configuration.strDeviceName, 13, "%s", m_persistedConfiguration.strDeviceName);
 541
 542   return true;
 543 }
 544
 545 bool CUSBCECAdapterCommands::PingAdapter(void)
 546 {
 547   LIB_CEC->AddLog(CEC_LOG_DEBUG, "sending ping");
 548
 549   CCECAdapterMessage params;
 550   CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_PING, params);
 551   bool bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
 552   delete message;
 553   return bReturn;
 554 }
 555
 556 bool CUSBCECAdapterCommands::SetAckMask(uint16_t iMask)
 557 {
 558   LIB_CEC->AddLog(CEC_LOG_DEBUG, "setting ackmask to %2x", iMask);
 559
 560   CCECAdapterMessage params;
 561   params.PushEscaped(iMask >> 8);
 562   params.PushEscaped((uint8_t)iMask);
 563   CCECAdapterMessage *message  = m_comm->SendCommand(MSGCODE_SET_ACK_MASK, params);
 564   bool bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
 565   delete message;
 566   return bReturn;
 567 }
 568
 569 bool CUSBCECAdapterCommands::StartBootloader(void)
 570 {
 571   LIB_CEC->AddLog(CEC_LOG_DEBUG, "starting the bootloader");
 572
 573   CCECAdapterMessage params;
 574   CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_START_BOOTLOADER, params);
 575   bool bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
 576   delete message;
 577   return bReturn;
 578 }
 579
 580 bool CUSBCECAdapterCommands::SetLineTimeout(uint8_t iTimeout)
 581 {
 582   LIB_CEC->AddLog(CEC_LOG_DEBUG, "setting the line timeout to %d", iTimeout);
 583   CCECAdapterMessage params;
 584   params.PushEscaped(iTimeout);
 585   CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_TRANSMIT_IDLETIME, params);
 586   bool bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
 587   delete message;
 588   return bReturn;
 589 }
 590
 591 bool CUSBCECAdapterCommands::SetControlledMode(bool controlled)
 592 {
 593   {
 594     CLockObject lock(m_mutex);
 595     if (m_bControlledMode == controlled)
 596       return true;
 597   }
 598
 599   LIB_CEC->AddLog(CEC_LOG_DEBUG, "turning controlled mode %s", controlled ? "on" : "off");
 600
 601   CCECAdapterMessage params;
 602   params.PushEscaped(controlled ? 1 : 0);
 603   CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_SET_CONTROLLED, params);
 604   bool bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
 605   delete message;
 606
 607   if (bReturn)
 608   {
 609     CLockObject lock(m_mutex);
 610     m_bControlledMode = controlled;
 611   }
 612
 613   return bReturn;
 614 }