2 * This file is part of the libCEC(R) library.
4 * libCEC(R) is Copyright (C) 2011-2012 Pulse-Eight Limited. All rights reserved.
5 * libCEC(R) is an original work, containing original code.
7 * libCEC(R) is a trademark of Pulse-Eight Limited.
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.
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.
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.
24 * Alternatively, you can license this library under a commercial license,
25 * please contact Pulse-Eight Licensing for more information.
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/
34 #include "USBCECAdapterCommunication.h"
36 #include "USBCECAdapterCommands.h"
37 #include "USBCECAdapterMessageQueue.h"
38 #include "USBCECAdapterMessage.h"
39 #include "lib/platform/sockets/serialport.h"
40 #include "lib/platform/util/timeutils.h"
41 #include "lib/platform/util/util.h"
42 #include "lib/platform/util/edid.h"
43 #include "lib/platform/adl/adl-edid.h"
44 #include "lib/platform/nvidia/nv-edid.h"
45 #include "lib/LibCEC.h"
46 #include "lib/CECProcessor.h"
50 using namespace PLATFORM
;
52 #define CEC_ADAPTER_PING_TIMEOUT 15000
53 #define CEC_ADAPTER_EEPROM_WRITE_INTERVAL 30000
54 #define CEC_ADAPTER_EEPROM_WRITE_RETRY 5000
57 #define CEC_LATEST_ADAPTER_FW_VERSION 2
58 // firmware date Thu Aug 2 08:31:24 UTC 2012
59 #define CEC_LATEST_ADAPTER_FW_DATE 0x501a4b0c
61 #define CEC_FW_DATE_EXTENDED_RESPONSE 0x501a4b0c
63 #define LIB_CEC m_callback->GetLib()
65 CUSBCECAdapterCommunication::CUSBCECAdapterCommunication(IAdapterCommunicationCallback
*callback
, const char *strPort
, uint16_t iBaudRate
/* = CEC_SERIAL_DEFAULT_BAUDRATE */) :
66 IAdapterCommunication(callback
),
69 m_lastPollDestination(CECDEVICE_UNKNOWN
),
70 m_bInitialised(false),
72 m_eepromWriteThread(NULL
),
74 m_adapterMessageQueue(NULL
)
76 m_logicalAddresses
.Clear();
77 for (unsigned int iPtr
= CECDEVICE_TV
; iPtr
< CECDEVICE_BROADCAST
; iPtr
++)
78 m_bWaitingForAck
[iPtr
] = false;
79 m_port
= new CSerialPort(strPort
, iBaudRate
);
80 m_commands
= new CUSBCECAdapterCommands(this);
83 CUSBCECAdapterCommunication::~CUSBCECAdapterCommunication(void)
86 DELETE_AND_NULL(m_commands
);
87 DELETE_AND_NULL(m_adapterMessageQueue
);
88 DELETE_AND_NULL(m_port
);
91 void CUSBCECAdapterCommunication::ResetMessageQueue(void)
93 DELETE_AND_NULL(m_adapterMessageQueue
);
94 m_adapterMessageQueue
= new CCECAdapterMessageQueue(this);
95 m_adapterMessageQueue
->CreateThread();
98 bool CUSBCECAdapterCommunication::Open(uint32_t iTimeoutMs
/* = CEC_DEFAULT_CONNECT_TIMEOUT */, bool bSkipChecks
/* = false */, bool bStartListening
/* = true */)
100 bool bConnectionOpened(false);
102 CLockObject
lock(m_mutex
);
104 /* we need the port settings here */
107 LIB_CEC
->AddLog(CEC_LOG_ERROR
, "port is NULL");
108 return bConnectionOpened
;
111 /* return true when the port is already open */
114 LIB_CEC
->AddLog(CEC_LOG_WARNING
, "port is already open");
120 /* try to open the connection */
122 CTimeout
timeout(iTimeoutMs
);
123 while (!bConnectionOpened
&& timeout
.TimeLeft() > 0)
125 if ((bConnectionOpened
= m_port
->Open(timeout
.TimeLeft())) == false)
127 strError
.Format("error opening serial port '%s': %s", m_port
->GetName().c_str(), m_port
->GetError().c_str());
130 /* and retry every 250ms until the timeout passed */
133 /* return false when we couldn't connect */
134 if (!bConnectionOpened
)
136 LIB_CEC
->AddLog(CEC_LOG_ERROR
, strError
);
138 if (m_port
->GetErrorNumber() == EACCES
)
140 libcec_parameter param
;
141 param
.paramType
= CEC_PARAMETER_TYPE_STRING
;
142 param
.paramData
= (void*)"No permission to open the device";
143 LIB_CEC
->Alert(CEC_ALERT_PERMISSION_ERROR
, param
);
145 else if (m_port
->GetErrorNumber() == EBUSY
)
147 libcec_parameter param
;
148 param
.paramType
= CEC_PARAMETER_TYPE_STRING
;
149 param
.paramData
= (void*)"The serial port is busy. Only one program can access the device directly.";
150 LIB_CEC
->Alert(CEC_ALERT_PORT_BUSY
, param
);
155 LIB_CEC
->AddLog(CEC_LOG_DEBUG
, "connection opened, clearing any previous input and waiting for active transmissions to end before starting");
159 // always start by setting the ackmask to 0, to clear previous values
160 cec_logical_addresses addresses
; addresses
.Clear();
161 SetLogicalAddresses(addresses
);
165 bConnectionOpened
= false;
166 LIB_CEC
->AddLog(CEC_LOG_ERROR
, "could not create a communication thread");
168 else if (!bSkipChecks
&& !CheckAdapter())
170 bConnectionOpened
= false;
171 LIB_CEC
->AddLog(CEC_LOG_ERROR
, "the adapter failed to pass basic checks");
173 else if (bStartListening
)
175 /* start the eeprom write thread, that handles all eeprom writes async */
176 m_eepromWriteThread
= new CAdapterEepromWriteThread(this);
177 if (!m_eepromWriteThread
->CreateThread())
179 bConnectionOpened
= false;
180 LIB_CEC
->AddLog(CEC_LOG_ERROR
, "could not create the eeprom write thread");
184 /* start a ping thread, that will ping the adapter every 15 seconds
185 if it doesn't receive any ping for 30 seconds, it'll switch to auto mode */
186 m_pingThread
= new CAdapterPingThread(this, CEC_ADAPTER_PING_TIMEOUT
);
187 if (m_pingThread
->CreateThread())
189 bConnectionOpened
= true;
193 bConnectionOpened
= false;
194 LIB_CEC
->AddLog(CEC_LOG_ERROR
, "could not create a ping thread");
199 if (!bConnectionOpened
|| !bStartListening
)
202 return bConnectionOpened
;
205 void CUSBCECAdapterCommunication::Close(void)
207 /* stop the reader thread */
210 CLockObject
lock(m_mutex
);
212 /* set the ackmask to 0 before closing the connection */
213 if (IsOpen() && m_port
->GetErrorNumber() == 0)
215 LIB_CEC
->AddLog(CEC_LOG_DEBUG
, "%s - closing the connection", __FUNCTION__
);
216 cec_logical_addresses addresses
; addresses
.Clear();
217 SetLogicalAddresses(addresses
);
218 if (m_commands
->GetFirmwareVersion() >= 2)
219 SetControlledMode(false);
222 m_adapterMessageQueue
->Clear();
224 /* stop and delete the write thread */
225 if (m_eepromWriteThread
)
226 m_eepromWriteThread
->Stop();
227 DELETE_AND_NULL(m_eepromWriteThread
);
229 /* stop and delete the ping thread */
230 DELETE_AND_NULL(m_pingThread
);
232 /* close and delete the com port connection */
237 cec_adapter_message_state
CUSBCECAdapterCommunication::Write(const cec_command
&data
, bool &bRetry
, uint8_t iLineTimeout
, bool bIsReply
)
239 cec_adapter_message_state
retVal(ADAPTER_MESSAGE_STATE_UNKNOWN
);
243 CCECAdapterMessage
*output
= new CCECAdapterMessage(data
, iLineTimeout
);
244 output
->bFireAndForget
= bIsReply
;
246 /* mark as waiting for an ack from the destination */
247 MarkAsWaiting(data
.destination
);
249 /* send the message */
252 retVal
= m_adapterMessageQueue
->Write(output
) ?
253 ADAPTER_MESSAGE_STATE_WAITING_TO_BE_SENT
: ADAPTER_MESSAGE_STATE_ERROR
;
257 bRetry
= (!m_adapterMessageQueue
->Write(output
) || output
->NeedsRetry()) && output
->transmit_timeout
> 0;
259 Sleep(CEC_DEFAULT_TRANSMIT_RETRY_WAIT
);
260 retVal
= output
->state
;
267 void *CUSBCECAdapterCommunication::Process(void)
269 CCECAdapterMessage msg
;
270 LIB_CEC
->AddLog(CEC_LOG_DEBUG
, "communication thread started");
274 /* read from the serial port */
275 if (!ReadFromDevice(50, 5))
277 libcec_parameter param
;
278 param
.paramData
= NULL
; param
.paramType
= CEC_PARAMETER_TYPE_UNKOWN
;
279 LIB_CEC
->Alert(CEC_ALERT_CONNECTION_LOST
, param
);
284 /* TODO sleep 5 ms so other threads can get a lock */
288 m_adapterMessageQueue
->Clear();
289 LIB_CEC
->AddLog(CEC_LOG_DEBUG
, "communication thread ended");
293 bool CUSBCECAdapterCommunication::HandlePoll(const CCECAdapterMessage
&msg
)
295 bool bIsError(msg
.IsError());
296 cec_adapter_messagecode
messageCode(msg
.Message());
297 CLockObject
lock(m_mutex
);
299 if (messageCode
== MSGCODE_FRAME_START
&& msg
.IsACK())
301 m_lastPollDestination
= msg
.Destination();
302 if (msg
.Destination() < CECDEVICE_BROADCAST
)
304 if (!m_bWaitingForAck
[msg
.Destination()] && !msg
.IsEOM())
307 m_callback
->HandlePoll(msg
.Initiator(), msg
.Destination());
310 m_bWaitingForAck
[msg
.Destination()] = false;
313 else if (messageCode
== MSGCODE_RECEIVE_FAILED
)
315 /* hack to suppress warnings when an LG is polling */
316 if (m_lastPollDestination
!= CECDEVICE_UNKNOWN
)
317 bIsError
= m_callback
->HandleReceiveFailed(m_lastPollDestination
);
323 void CUSBCECAdapterCommunication::MarkAsWaiting(const cec_logical_address dest
)
325 /* mark as waiting for an ack from the destination */
326 if (dest
< CECDEVICE_BROADCAST
)
328 CLockObject
lock(m_mutex
);
329 m_bWaitingForAck
[dest
] = true;
333 void CUSBCECAdapterCommunication::ClearInputBytes(uint32_t iTimeout
/* = CEC_CLEAR_INPUT_DEFAULT_WAIT */)
335 CTimeout
timeout(iTimeout
);
337 ssize_t
iBytesRead(0);
338 bool bGotMsgEnd(true);
340 while (timeout
.TimeLeft() > 0 && ((iBytesRead
= m_port
->Read(buff
, 1024, 5)) > 0 || !bGotMsgEnd
))
343 /* if something was received, wait for MSGEND */
344 for (ssize_t iPtr
= 0; iPtr
< iBytesRead
; iPtr
++)
345 bGotMsgEnd
= buff
[iPtr
] == MSGEND
;
349 bool CUSBCECAdapterCommunication::SetLineTimeout(uint8_t iTimeout
)
352 bool bChanged(false);
354 /* only send the command if the timeout changed */
356 CLockObject
lock(m_mutex
);
357 bChanged
= (m_iLineTimeout
!= iTimeout
);
358 m_iLineTimeout
= iTimeout
;
362 bReturn
= m_commands
->SetLineTimeout(iTimeout
);
367 bool CUSBCECAdapterCommunication::WriteToDevice(CCECAdapterMessage
*message
)
369 CLockObject
adapterLock(m_mutex
);
372 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());
373 message
->state
= ADAPTER_MESSAGE_STATE_ERROR
;
377 /* write the message */
378 if (m_port
->Write(message
->packet
.data
, message
->Size()) != (ssize_t
) message
->Size())
380 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());
381 message
->state
= ADAPTER_MESSAGE_STATE_ERROR
;
382 // this will trigger an alert in the reader thread
388 LIB_CEC
->AddLog(CEC_LOG_DEBUG
, "command '%s' sent", message
->IsTranmission() ? "CEC transmission" : CCECAdapterMessage::ToString(message
->Message()));
390 message
->state
= ADAPTER_MESSAGE_STATE_SENT
;
394 bool CUSBCECAdapterCommunication::ReadFromDevice(uint32_t iTimeout
, size_t iSize
/* = 256 */)
396 ssize_t
iBytesRead(0);
401 /* read from the serial port */
403 CLockObject
lock(m_mutex
);
408 /* retry Read() if it was interrupted */
409 iBytesRead
= m_port
->Read(buff
, sizeof(uint8_t) * iSize
, iTimeout
);
410 } while(m_port
->GetErrorNumber() == EINTR
);
413 if (m_port
->GetErrorNumber())
415 LIB_CEC
->AddLog(CEC_LOG_ERROR
, "error reading from serial port: %s", m_port
->GetError().c_str());
421 if (iBytesRead
< 0 || iBytesRead
> 256)
423 else if (iBytesRead
> 0)
425 /* add the data to the current frame */
426 m_adapterMessageQueue
->AddData(buff
, iBytesRead
);
432 CCECAdapterMessage
*CUSBCECAdapterCommunication::SendCommand(cec_adapter_messagecode msgCode
, CCECAdapterMessage
¶ms
, bool bIsRetry
/* = false */)
434 if (!IsOpen() || !m_adapterMessageQueue
)
437 /* create the adapter message for this command */
438 CCECAdapterMessage
*output
= new CCECAdapterMessage
;
439 output
->PushBack(MSGSTART
);
440 output
->PushEscaped((uint8_t)msgCode
);
441 output
->Append(params
);
442 output
->PushBack(MSGEND
);
444 /* write the command */
445 if (!m_adapterMessageQueue
->Write(output
))
447 // this will trigger an alert in the reader thread
448 if (output
->state
== ADAPTER_MESSAGE_STATE_ERROR
)
454 if (!bIsRetry
&& output
->Reply() == MSGCODE_COMMAND_REJECTED
&& msgCode
!= MSGCODE_SET_CONTROLLED
&&
455 msgCode
!= MSGCODE_GET_BUILDDATE
/* same messagecode value had a different meaning in older fw builds */)
457 /* if the controller reported that the command was rejected, and we didn't send the command
458 to set controlled mode, then the controller probably switched to auto mode. set controlled
460 LIB_CEC
->AddLog(CEC_LOG_DEBUG
, "setting controlled mode and retrying");
462 if (SetControlledMode(true))
463 return SendCommand(msgCode
, params
, true);
470 bool CUSBCECAdapterCommunication::CheckAdapter(uint32_t iTimeoutMs
/* = CEC_DEFAULT_CONNECT_TIMEOUT */)
473 CTimeout
timeout(iTimeoutMs
> 0 ? iTimeoutMs
: CEC_DEFAULT_TRANSMIT_WAIT
);
475 /* try to ping the adapter */
477 unsigned iPingTry(0);
478 while (timeout
.TimeLeft() > 0 && (bPinged
= PingAdapter()) == false)
480 LIB_CEC
->AddLog(CEC_LOG_ERROR
, "the adapter did not respond correctly to a ping (try %d)", ++iPingTry
);
484 /* try to read the firmware version */
485 if (bPinged
&& timeout
.TimeLeft() > 0 && m_commands
->RequestFirmwareVersion() >= 2)
487 /* try to set controlled mode for v2+ firmwares */
488 unsigned iControlledTry(0);
489 bool bControlled(false);
490 while (timeout
.TimeLeft() > 0 && (bControlled
= SetControlledMode(true)) == false)
492 LIB_CEC
->AddLog(CEC_LOG_ERROR
, "the adapter did not respond correctly to setting controlled mode (try %d)", ++iControlledTry
);
495 bReturn
= bControlled
;
500 if (m_commands
->GetFirmwareVersion() >= 2)
502 /* try to read the build date */
503 m_commands
->RequestBuildDate();
505 /* try to read the adapter type */
506 m_commands
->RequestAdapterType();
509 SetInitialised(bReturn
);
513 bool CUSBCECAdapterCommunication::IsOpen(void)
515 /* thread is not being stopped, the port is open and the thread is running */
516 return !IsStopped() && m_port
->IsOpen() && IsRunning();
519 std::string
CUSBCECAdapterCommunication::GetError(void) const
521 return m_port
->GetError();
524 void CUSBCECAdapterCommunication::SetInitialised(bool bSetTo
/* = true */)
526 CLockObject
lock(m_mutex
);
527 m_bInitialised
= bSetTo
;
530 bool CUSBCECAdapterCommunication::IsInitialised(void)
532 CLockObject
lock(m_mutex
);
533 return m_bInitialised
;
536 bool CUSBCECAdapterCommunication::StartBootloader(void)
538 if (m_port
->IsOpen() && m_commands
->StartBootloader())
546 bool CUSBCECAdapterCommunication::SetLogicalAddresses(const cec_logical_addresses
&addresses
)
549 CLockObject
lock(m_mutex
);
550 if (m_logicalAddresses
== addresses
)
554 if (IsOpen() && m_commands
->SetAckMask(addresses
.AckMask()))
556 CLockObject
lock(m_mutex
);
557 m_logicalAddresses
= addresses
;
561 LIB_CEC
->AddLog(CEC_LOG_DEBUG
, "couldn't change the ackmask: the connection is closed");
565 cec_logical_addresses
CUSBCECAdapterCommunication::GetLogicalAddresses(void)
567 cec_logical_addresses addresses
;
568 CLockObject
lock(m_mutex
);
569 addresses
= m_logicalAddresses
;
573 bool CUSBCECAdapterCommunication::PingAdapter(void)
575 return IsOpen() ? m_commands
->PingAdapter() : false;
578 uint16_t CUSBCECAdapterCommunication::GetFirmwareVersion(void)
580 return m_commands
? m_commands
->GetFirmwareVersion() : CEC_FW_VERSION_UNKNOWN
;
583 uint32_t CUSBCECAdapterCommunication::GetFirmwareBuildDate(void)
585 uint32_t iBuildDate(0);
587 iBuildDate
= m_commands
->GetPersistedBuildDate();
588 if (iBuildDate
== 0 && IsOpen())
589 iBuildDate
= m_commands
->RequestBuildDate();
594 cec_adapter_type
CUSBCECAdapterCommunication::GetAdapterType(void)
596 cec_adapter_type
type(ADAPTERTYPE_UNKNOWN
);
598 type
= (cec_adapter_type
)m_commands
->GetPersistedAdapterType();
599 if (type
== ADAPTERTYPE_UNKNOWN
&& IsOpen())
600 type
= (cec_adapter_type
)m_commands
->RequestAdapterType();
605 bool CUSBCECAdapterCommunication::ProvidesExtendedResponse(void)
607 uint32_t iBuildDate(0);
609 iBuildDate
= m_commands
->GetPersistedBuildDate();
611 return iBuildDate
>= CEC_FW_DATE_EXTENDED_RESPONSE
;
614 bool CUSBCECAdapterCommunication::IsRunningLatestFirmware(void)
616 return GetFirmwareBuildDate() >= CEC_LATEST_ADAPTER_FW_DATE
&&
617 GetFirmwareVersion() >= CEC_LATEST_ADAPTER_FW_VERSION
;
620 bool CUSBCECAdapterCommunication::PersistConfiguration(const libcec_configuration
&configuration
)
623 m_commands
->PersistConfiguration(configuration
) && m_eepromWriteThread
->Write() :
627 bool CUSBCECAdapterCommunication::GetConfiguration(libcec_configuration
&configuration
)
629 return IsOpen() ? m_commands
->GetConfiguration(configuration
) : false;
632 std::string
CUSBCECAdapterCommunication::GetPortName(void)
634 return m_port
->GetName();
637 bool CUSBCECAdapterCommunication::SetControlledMode(bool controlled
)
639 return IsOpen() ? m_commands
->SetControlledMode(controlled
) : false;
642 uint16_t CUSBCECAdapterCommunication::GetPhysicalAddress(void)
646 // try to get the PA from ADL
647 #if defined(HAS_ADL_EDID_PARSER)
649 LIB_CEC
->AddLog(CEC_LOG_DEBUG
, "%s - trying to get the physical address via ADL", __FUNCTION__
);
651 iPA
= adl
.GetPhysicalAddress();
652 LIB_CEC
->AddLog(CEC_LOG_DEBUG
, "%s - ADL returned physical address %04x", __FUNCTION__
, iPA
);
656 // try to get the PA from the nvidia driver
657 #if defined(HAS_NVIDIA_EDID_PARSER)
660 LIB_CEC
->AddLog(CEC_LOG_DEBUG
, "%s - trying to get the physical address via nvidia driver", __FUNCTION__
);
662 iPA
= nv
.GetPhysicalAddress();
663 LIB_CEC
->AddLog(CEC_LOG_DEBUG
, "%s - nvidia driver returned physical address %04x", __FUNCTION__
, iPA
);
667 // try to get the PA from the OS
670 LIB_CEC
->AddLog(CEC_LOG_DEBUG
, "%s - trying to get the physical address from the OS", __FUNCTION__
);
671 iPA
= CEDIDParser::GetPhysicalAddress();
672 LIB_CEC
->AddLog(CEC_LOG_DEBUG
, "%s - OS returned physical address %04x", __FUNCTION__
, iPA
);
678 void *CAdapterPingThread::Process(void)
682 if (m_timeout
.TimeLeft() == 0)
684 /* reinit the timeout */
685 m_timeout
.Init(CEC_ADAPTER_PING_TIMEOUT
);
687 /* send a ping to the adapter */
689 int iFailedCounter(0);
690 while (!bPinged
&& iFailedCounter
< 3)
692 if (!m_com
->PingAdapter())
694 /* sleep and retry */
695 Sleep(CEC_DEFAULT_TRANSMIT_RETRY_WAIT
);
704 if (iFailedCounter
== 3)
706 /* failed to ping the adapter 3 times in a row. something must be wrong with the connection */
707 m_com
->LIB_CEC
->AddLog(CEC_LOG_ERROR
, "failed to ping the adapter 3 times in a row. closing the connection.");
708 m_com
->StopThread(false);
718 void CAdapterEepromWriteThread::Stop(void)
722 CLockObject
lock(m_mutex
);
723 if (m_iScheduleEepromWrite
> 0)
724 m_com
->LIB_CEC
->AddLog(CEC_LOG_WARNING
, "write thread stopped while a write was queued");
725 m_condition
.Signal();
730 void *CAdapterEepromWriteThread::Process(void)
734 CLockObject
lock(m_mutex
);
735 if ((m_iScheduleEepromWrite
> 0 && m_iScheduleEepromWrite
< GetTimeMs()) ||
736 m_condition
.Wait(m_mutex
, m_bWrite
, 100))
739 if (m_com
->m_commands
->WriteEEPROM())
741 m_iLastEepromWrite
= GetTimeMs();
742 m_iScheduleEepromWrite
= 0;
746 m_iScheduleEepromWrite
= GetTimeMs() + CEC_ADAPTER_EEPROM_WRITE_RETRY
;
753 bool CAdapterEepromWriteThread::Write(void)
755 CLockObject
lock(m_mutex
);
756 if (m_iScheduleEepromWrite
== 0)
758 int64_t iNow
= GetTimeMs();
759 if (m_iLastEepromWrite
+ CEC_ADAPTER_EEPROM_WRITE_INTERVAL
> iNow
)
761 m_com
->LIB_CEC
->AddLog(CEC_LOG_DEBUG
, "delaying eeprom write by %ld ms", m_iLastEepromWrite
+ CEC_ADAPTER_EEPROM_WRITE_INTERVAL
- iNow
);
762 m_iScheduleEepromWrite
= m_iLastEepromWrite
+ CEC_ADAPTER_EEPROM_WRITE_INTERVAL
;
767 m_condition
.Signal();