less debug logging by default
[deb_libcec.git] / src / lib / adapter / Pulse-Eight / 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 "env.h"
34 #include "USBCECAdapterCommunication.h"
35
36 #include "USBCECAdapterCommands.h"
37 #include "USBCECAdapterMessageQueue.h"
38 #include "USBCECAdapterMessage.h"
39 #include "USBCECAdapterDetection.h"
40 #include "lib/platform/sockets/serialport.h"
41 #include "lib/platform/util/timeutils.h"
42 #include "lib/platform/util/util.h"
43 #include "lib/platform/util/edid.h"
44 #include "lib/platform/adl/adl-edid.h"
45 #include "lib/platform/nvidia/nv-edid.h"
46 #include "lib/LibCEC.h"
47 #include "lib/CECProcessor.h"
48
49 using namespace std;
50 using namespace CEC;
51 using namespace PLATFORM;
52
53 #define CEC_ADAPTER_PING_TIMEOUT 15000
54 #define CEC_ADAPTER_EEPROM_WRITE_INTERVAL 30000
55 #define CEC_ADAPTER_EEPROM_WRITE_RETRY 5000
56
57 // firmware version 2
58 #define CEC_LATEST_ADAPTER_FW_VERSION 2
59 // firmware date Thu Aug 2 08:31:24 UTC 2012
60 #define CEC_LATEST_ADAPTER_FW_DATE 0x501a4b0c
61
62 #define CEC_FW_DATE_EXTENDED_RESPONSE 0x501a4b0c
63 #define CEC_FW_DATE_DESCRIPTOR2 0x5045dbf5
64
65 #define LIB_CEC m_callback->GetLib()
66
67 CUSBCECAdapterCommunication::CUSBCECAdapterCommunication(IAdapterCommunicationCallback *callback, const char *strPort, uint16_t iBaudRate /* = CEC_SERIAL_DEFAULT_BAUDRATE */) :
68 IAdapterCommunication(callback),
69 m_port(NULL),
70 m_iLineTimeout(0),
71 m_lastPollDestination(CECDEVICE_UNKNOWN),
72 m_bInitialised(false),
73 m_pingThread(NULL),
74 m_eepromWriteThread(NULL),
75 m_commands(NULL),
76 m_adapterMessageQueue(NULL)
77 {
78 m_logicalAddresses.Clear();
79 for (unsigned int iPtr = CECDEVICE_TV; iPtr < CECDEVICE_BROADCAST; iPtr++)
80 m_bWaitingForAck[iPtr] = false;
81 m_port = new CSerialPort(strPort, iBaudRate);
82 m_commands = new CUSBCECAdapterCommands(this);
83 }
84
85 CUSBCECAdapterCommunication::~CUSBCECAdapterCommunication(void)
86 {
87 Close();
88 DELETE_AND_NULL(m_commands);
89 DELETE_AND_NULL(m_adapterMessageQueue);
90 DELETE_AND_NULL(m_port);
91 }
92
93 void CUSBCECAdapterCommunication::ResetMessageQueue(void)
94 {
95 DELETE_AND_NULL(m_adapterMessageQueue);
96 m_adapterMessageQueue = new CCECAdapterMessageQueue(this);
97 m_adapterMessageQueue->CreateThread();
98 }
99
100 bool CUSBCECAdapterCommunication::Open(uint32_t iTimeoutMs /* = CEC_DEFAULT_CONNECT_TIMEOUT */, bool bSkipChecks /* = false */, bool bStartListening /* = true */)
101 {
102 bool bConnectionOpened(false);
103 {
104 CLockObject lock(m_mutex);
105
106 /* we need the port settings here */
107 if (!m_port)
108 {
109 LIB_CEC->AddLog(CEC_LOG_ERROR, "port is NULL");
110 return bConnectionOpened;
111 }
112
113 /* return true when the port is already open */
114 if (IsOpen())
115 {
116 LIB_CEC->AddLog(CEC_LOG_WARNING, "port is already open");
117 return true;
118 }
119
120 ResetMessageQueue();
121
122 /* try to open the connection */
123 CStdString strError;
124 CTimeout timeout(iTimeoutMs);
125 while (!bConnectionOpened && timeout.TimeLeft() > 0)
126 {
127 if ((bConnectionOpened = m_port->Open(timeout.TimeLeft())) == false)
128 {
129 strError.Format("error opening serial port '%s': %s", m_port->GetName().c_str(), m_port->GetError().c_str());
130 Sleep(250);
131 }
132 /* and retry every 250ms until the timeout passed */
133 }
134
135 /* return false when we couldn't connect */
136 if (!bConnectionOpened)
137 {
138 LIB_CEC->AddLog(CEC_LOG_ERROR, strError);
139
140 if (m_port->GetErrorNumber() == EACCES)
141 {
142 libcec_parameter param;
143 param.paramType = CEC_PARAMETER_TYPE_STRING;
144 param.paramData = (void*)"No permission to open the device";
145 LIB_CEC->Alert(CEC_ALERT_PERMISSION_ERROR, param);
146 }
147 else if (m_port->GetErrorNumber() == EBUSY)
148 {
149 libcec_parameter param;
150 param.paramType = CEC_PARAMETER_TYPE_STRING;
151 param.paramData = (void*)"The serial port is busy. Only one program can access the device directly.";
152 LIB_CEC->Alert(CEC_ALERT_PORT_BUSY, param);
153 }
154 return false;
155 }
156
157 LIB_CEC->AddLog(CEC_LOG_DEBUG, "connection opened, clearing any previous input and waiting for active transmissions to end before starting");
158 ClearInputBytes();
159 }
160
161 // always start by setting the ackmask to 0, to clear previous values
162 cec_logical_addresses addresses; addresses.Clear();
163 SetLogicalAddresses(addresses);
164
165 if (!CreateThread())
166 {
167 bConnectionOpened = false;
168 LIB_CEC->AddLog(CEC_LOG_ERROR, "could not create a communication thread");
169 }
170 else if (!bSkipChecks && !CheckAdapter())
171 {
172 bConnectionOpened = false;
173 LIB_CEC->AddLog(CEC_LOG_ERROR, "the adapter failed to pass basic checks");
174 }
175 else if (bStartListening)
176 {
177 /* start the eeprom write thread, that handles all eeprom writes async */
178 m_eepromWriteThread = new CAdapterEepromWriteThread(this);
179 if (!m_eepromWriteThread->CreateThread())
180 {
181 bConnectionOpened = false;
182 LIB_CEC->AddLog(CEC_LOG_ERROR, "could not create the eeprom write thread");
183 }
184 else
185 {
186 /* start a ping thread, that will ping the adapter every 15 seconds
187 if it doesn't receive any ping for 30 seconds, it'll switch to auto mode */
188 m_pingThread = new CAdapterPingThread(this, CEC_ADAPTER_PING_TIMEOUT);
189 if (m_pingThread->CreateThread())
190 {
191 bConnectionOpened = true;
192 }
193 else
194 {
195 bConnectionOpened = false;
196 LIB_CEC->AddLog(CEC_LOG_ERROR, "could not create a ping thread");
197 }
198 }
199 }
200
201 if (!bConnectionOpened || !bStartListening)
202 StopThread(0);
203
204 return bConnectionOpened;
205 }
206
207 void CUSBCECAdapterCommunication::Close(void)
208 {
209 /* stop the reader thread */
210 StopThread(0);
211
212 CLockObject lock(m_mutex);
213
214 /* set the ackmask to 0 before closing the connection */
215 if (IsOpen() && m_port->GetErrorNumber() == 0)
216 {
217 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - closing the connection", __FUNCTION__);
218 cec_logical_addresses addresses; addresses.Clear();
219 SetLogicalAddresses(addresses);
220 if (m_commands->GetFirmwareVersion() >= 2)
221 SetControlledMode(false);
222 }
223
224 m_adapterMessageQueue->Clear();
225
226 /* stop and delete the write thread */
227 if (m_eepromWriteThread)
228 m_eepromWriteThread->Stop();
229 DELETE_AND_NULL(m_eepromWriteThread);
230
231 /* stop and delete the ping thread */
232 DELETE_AND_NULL(m_pingThread);
233
234 /* close and delete the com port connection */
235 if (m_port)
236 m_port->Close();
237 }
238
239 cec_adapter_message_state CUSBCECAdapterCommunication::Write(const cec_command &data, bool &bRetry, uint8_t iLineTimeout, bool bIsReply)
240 {
241 cec_adapter_message_state retVal(ADAPTER_MESSAGE_STATE_UNKNOWN);
242 if (!IsRunning())
243 return retVal;
244
245 CCECAdapterMessage *output = new CCECAdapterMessage(data, iLineTimeout);
246 output->bFireAndForget = bIsReply;
247
248 /* mark as waiting for an ack from the destination */
249 MarkAsWaiting(data.destination);
250
251 /* send the message */
252 if (bIsReply)
253 {
254 retVal = m_adapterMessageQueue->Write(output) ?
255 ADAPTER_MESSAGE_STATE_WAITING_TO_BE_SENT : ADAPTER_MESSAGE_STATE_ERROR;
256 }
257 else
258 {
259 bRetry = (!m_adapterMessageQueue->Write(output) || output->NeedsRetry()) && output->transmit_timeout > 0;
260 if (bRetry)
261 Sleep(CEC_DEFAULT_TRANSMIT_RETRY_WAIT);
262 retVal = output->state;
263
264 delete output;
265 }
266 return retVal;
267 }
268
269 void *CUSBCECAdapterCommunication::Process(void)
270 {
271 CCECAdapterMessage msg;
272 LIB_CEC->AddLog(CEC_LOG_DEBUG, "communication thread started");
273
274 while (!IsStopped())
275 {
276 /* read from the serial port */
277 if (!ReadFromDevice(50, 5))
278 {
279 libcec_parameter param;
280 param.paramData = NULL; param.paramType = CEC_PARAMETER_TYPE_UNKOWN;
281 LIB_CEC->Alert(CEC_ALERT_CONNECTION_LOST, param);
282
283 break;
284 }
285
286 /* TODO sleep 5 ms so other threads can get a lock */
287 if (!IsStopped())
288 Sleep(5);
289 }
290
291 m_adapterMessageQueue->Clear();
292 LIB_CEC->AddLog(CEC_LOG_DEBUG, "communication thread ended");
293 return NULL;
294 }
295
296 bool CUSBCECAdapterCommunication::HandlePoll(const CCECAdapterMessage &msg)
297 {
298 bool bIsError(msg.IsError());
299 cec_adapter_messagecode messageCode(msg.Message());
300 CLockObject lock(m_mutex);
301
302 if (messageCode == MSGCODE_FRAME_START && msg.IsACK())
303 {
304 m_lastPollDestination = msg.Destination();
305 if (msg.Destination() < CECDEVICE_BROADCAST)
306 {
307 if (!m_bWaitingForAck[msg.Destination()] && !msg.IsEOM())
308 {
309 if (m_callback)
310 m_callback->HandlePoll(msg.Initiator(), msg.Destination());
311 }
312 else
313 m_bWaitingForAck[msg.Destination()] = false;
314 }
315 }
316 else if (messageCode == MSGCODE_RECEIVE_FAILED)
317 {
318 /* hack to suppress warnings when an LG is polling */
319 if (m_lastPollDestination != CECDEVICE_UNKNOWN)
320 bIsError = m_callback->HandleReceiveFailed(m_lastPollDestination);
321 }
322
323 return bIsError;
324 }
325
326 void CUSBCECAdapterCommunication::MarkAsWaiting(const cec_logical_address dest)
327 {
328 /* mark as waiting for an ack from the destination */
329 if (dest < CECDEVICE_BROADCAST)
330 {
331 CLockObject lock(m_mutex);
332 m_bWaitingForAck[dest] = true;
333 }
334 }
335
336 void CUSBCECAdapterCommunication::ClearInputBytes(uint32_t iTimeout /* = CEC_CLEAR_INPUT_DEFAULT_WAIT */)
337 {
338 CTimeout timeout(iTimeout);
339 uint8_t buff[1024];
340 ssize_t iBytesRead(0);
341 bool bGotMsgEnd(true);
342
343 while (timeout.TimeLeft() > 0 && ((iBytesRead = m_port->Read(buff, 1024, 5)) > 0 || !bGotMsgEnd))
344 {
345 bGotMsgEnd = false;
346 /* if something was received, wait for MSGEND */
347 for (ssize_t iPtr = 0; iPtr < iBytesRead; iPtr++)
348 bGotMsgEnd = buff[iPtr] == MSGEND;
349 }
350 }
351
352 bool CUSBCECAdapterCommunication::SetLineTimeout(uint8_t iTimeout)
353 {
354 bool bReturn(true);
355 bool bChanged(false);
356
357 /* only send the command if the timeout changed */
358 {
359 CLockObject lock(m_mutex);
360 bChanged = (m_iLineTimeout != iTimeout);
361 m_iLineTimeout = iTimeout;
362 }
363
364 if (bChanged)
365 bReturn = m_commands->SetLineTimeout(iTimeout);
366
367 return bReturn;
368 }
369
370 bool CUSBCECAdapterCommunication::WriteToDevice(CCECAdapterMessage *message)
371 {
372 CLockObject adapterLock(m_mutex);
373 if (!IsOpen())
374 {
375 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());
376 message->state = ADAPTER_MESSAGE_STATE_ERROR;
377 return false;
378 }
379
380 /* write the message */
381 if (m_port->Write(message->packet.data, message->Size()) != (ssize_t) message->Size())
382 {
383 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());
384 message->state = ADAPTER_MESSAGE_STATE_ERROR;
385 // this will trigger an alert in the reader thread
386 m_port->Close();
387 return false;
388 }
389
390 #ifdef CEC_DEBUGGING
391 LIB_CEC->AddLog(CEC_LOG_DEBUG, "command '%s' sent", message->IsTranmission() ? "CEC transmission" : CCECAdapterMessage::ToString(message->Message()));
392 #endif
393 message->state = ADAPTER_MESSAGE_STATE_SENT;
394 return true;
395 }
396
397 bool CUSBCECAdapterCommunication::ReadFromDevice(uint32_t iTimeout, size_t iSize /* = 256 */)
398 {
399 ssize_t iBytesRead(0);
400 uint8_t buff[256];
401 if (iSize > 256)
402 iSize = 256;
403
404 /* read from the serial port */
405 {
406 CLockObject lock(m_mutex);
407 if (!IsOpen())
408 return false;
409
410 do {
411 /* retry Read() if it was interrupted */
412 iBytesRead = m_port->Read(buff, sizeof(uint8_t) * iSize, iTimeout);
413 } while(m_port->GetErrorNumber() == EINTR);
414
415
416 if (m_port->GetErrorNumber())
417 {
418 LIB_CEC->AddLog(CEC_LOG_ERROR, "error reading from serial port: %s", m_port->GetError().c_str());
419 m_port->Close();
420 return false;
421 }
422 }
423
424 if (iBytesRead < 0 || iBytesRead > 256)
425 return false;
426 else if (iBytesRead > 0)
427 {
428 /* add the data to the current frame */
429 m_adapterMessageQueue->AddData(buff, iBytesRead);
430 }
431
432 return true;
433 }
434
435 CCECAdapterMessage *CUSBCECAdapterCommunication::SendCommand(cec_adapter_messagecode msgCode, CCECAdapterMessage &params, bool bIsRetry /* = false */)
436 {
437 if (!IsOpen() || !m_adapterMessageQueue)
438 return NULL;
439
440 /* create the adapter message for this command */
441 CCECAdapterMessage *output = new CCECAdapterMessage;
442 output->PushBack(MSGSTART);
443 output->PushEscaped((uint8_t)msgCode);
444 output->Append(params);
445 output->PushBack(MSGEND);
446
447 /* write the command */
448 if (!m_adapterMessageQueue->Write(output))
449 {
450 // this will trigger an alert in the reader thread
451 if (output->state == ADAPTER_MESSAGE_STATE_ERROR)
452 m_port->Close();
453 return output;
454 }
455 else
456 {
457 if (!bIsRetry && output->Reply() == MSGCODE_COMMAND_REJECTED && msgCode != MSGCODE_SET_CONTROLLED &&
458 msgCode != MSGCODE_GET_BUILDDATE /* same messagecode value had a different meaning in older fw builds */)
459 {
460 /* if the controller reported that the command was rejected, and we didn't send the command
461 to set controlled mode, then the controller probably switched to auto mode. set controlled
462 mode and retry */
463 LIB_CEC->AddLog(CEC_LOG_DEBUG, "setting controlled mode and retrying");
464 delete output;
465 if (SetControlledMode(true))
466 return SendCommand(msgCode, params, true);
467 }
468 }
469
470 return output;
471 }
472
473 bool CUSBCECAdapterCommunication::CheckAdapter(uint32_t iTimeoutMs /* = CEC_DEFAULT_CONNECT_TIMEOUT */)
474 {
475 bool bReturn(false);
476 CTimeout timeout(iTimeoutMs > 0 ? iTimeoutMs : CEC_DEFAULT_TRANSMIT_WAIT);
477
478 /* try to ping the adapter */
479 bool bPinged(false);
480 unsigned iPingTry(0);
481 while (timeout.TimeLeft() > 0 && (bPinged = PingAdapter()) == false)
482 {
483 LIB_CEC->AddLog(CEC_LOG_ERROR, "the adapter did not respond correctly to a ping (try %d)", ++iPingTry);
484 CEvent::Sleep(500);
485 }
486
487 /* try to read the firmware version */
488 if (bPinged && timeout.TimeLeft() > 0 && m_commands->RequestFirmwareVersion() >= 2)
489 {
490 /* try to set controlled mode for v2+ firmwares */
491 unsigned iControlledTry(0);
492 bool bControlled(false);
493 while (timeout.TimeLeft() > 0 && (bControlled = SetControlledMode(true)) == false)
494 {
495 LIB_CEC->AddLog(CEC_LOG_ERROR, "the adapter did not respond correctly to setting controlled mode (try %d)", ++iControlledTry);
496 CEvent::Sleep(500);
497 }
498 bReturn = bControlled;
499 }
500 else
501 bReturn = true;
502
503 if (m_commands->GetFirmwareVersion() >= 2)
504 {
505 /* try to read the build date */
506 m_commands->RequestBuildDate();
507
508 /* try to read the adapter type */
509 m_commands->RequestAdapterType();
510 }
511
512 SetInitialised(bReturn);
513 return bReturn;
514 }
515
516 bool CUSBCECAdapterCommunication::IsOpen(void)
517 {
518 /* thread is not being stopped, the port is open and the thread is running */
519 return !IsStopped() && m_port->IsOpen() && IsRunning();
520 }
521
522 std::string CUSBCECAdapterCommunication::GetError(void) const
523 {
524 return m_port->GetError();
525 }
526
527 void CUSBCECAdapterCommunication::SetInitialised(bool bSetTo /* = true */)
528 {
529 CLockObject lock(m_mutex);
530 m_bInitialised = bSetTo;
531 }
532
533 bool CUSBCECAdapterCommunication::IsInitialised(void)
534 {
535 CLockObject lock(m_mutex);
536 return m_bInitialised;
537 }
538
539 bool CUSBCECAdapterCommunication::StartBootloader(void)
540 {
541 if (m_port->IsOpen() && m_commands->StartBootloader())
542 {
543 m_port->Close();
544 return true;
545 }
546 return false;
547 }
548
549 bool CUSBCECAdapterCommunication::SetLogicalAddresses(const cec_logical_addresses &addresses)
550 {
551 {
552 CLockObject lock(m_mutex);
553 if (m_logicalAddresses == addresses)
554 return true;
555 }
556
557 if (IsOpen() && m_commands->SetAckMask(addresses.AckMask()))
558 {
559 CLockObject lock(m_mutex);
560 m_logicalAddresses = addresses;
561 return true;
562 }
563
564 LIB_CEC->AddLog(CEC_LOG_DEBUG, "couldn't change the ackmask: the connection is closed");
565 return false;
566 }
567
568 cec_logical_addresses CUSBCECAdapterCommunication::GetLogicalAddresses(void)
569 {
570 cec_logical_addresses addresses;
571 CLockObject lock(m_mutex);
572 addresses = m_logicalAddresses;
573 return addresses;
574 }
575
576 bool CUSBCECAdapterCommunication::PingAdapter(void)
577 {
578 return IsOpen() ? m_commands->PingAdapter() : false;
579 }
580
581 uint16_t CUSBCECAdapterCommunication::GetFirmwareVersion(void)
582 {
583 return m_commands ? m_commands->GetFirmwareVersion() : CEC_FW_VERSION_UNKNOWN;
584 }
585
586 uint32_t CUSBCECAdapterCommunication::GetFirmwareBuildDate(void)
587 {
588 uint32_t iBuildDate(0);
589 if (m_commands)
590 iBuildDate = m_commands->GetPersistedBuildDate();
591 if (iBuildDate == 0 && IsOpen())
592 iBuildDate = m_commands->RequestBuildDate();
593
594 return iBuildDate;
595 }
596
597 cec_adapter_type CUSBCECAdapterCommunication::GetAdapterType(void)
598 {
599 cec_adapter_type type(ADAPTERTYPE_UNKNOWN);
600 if (m_commands)
601 type = (cec_adapter_type)m_commands->GetPersistedAdapterType();
602 if (type == ADAPTERTYPE_UNKNOWN && IsOpen())
603 type = (cec_adapter_type)m_commands->RequestAdapterType();
604
605 return type;
606 }
607
608 bool CUSBCECAdapterCommunication::ProvidesExtendedResponse(void)
609 {
610 uint32_t iBuildDate(0);
611 if (m_commands)
612 iBuildDate = m_commands->GetPersistedBuildDate();
613
614 return iBuildDate >= CEC_FW_DATE_EXTENDED_RESPONSE;
615 }
616
617 uint16_t CUSBCECAdapterCommunication::GetAdapterVendorId(void) const
618 {
619 return CEC_VID;
620 }
621
622 uint16_t CUSBCECAdapterCommunication::GetAdapterProductId(void) const
623 {
624 uint32_t iBuildDate(0);
625 if (m_commands)
626 iBuildDate = m_commands->GetPersistedBuildDate();
627
628 return iBuildDate >= CEC_FW_DATE_DESCRIPTOR2 ? CEC_PID2 : CEC_PID;
629 }
630
631 bool CUSBCECAdapterCommunication::IsRunningLatestFirmware(void)
632 {
633 return GetFirmwareBuildDate() >= CEC_LATEST_ADAPTER_FW_DATE &&
634 GetFirmwareVersion() >= CEC_LATEST_ADAPTER_FW_VERSION;
635 }
636
637 bool CUSBCECAdapterCommunication::PersistConfiguration(const libcec_configuration &configuration)
638 {
639 return IsOpen() ?
640 m_commands->PersistConfiguration(configuration) && m_eepromWriteThread->Write() :
641 false;
642 }
643
644 bool CUSBCECAdapterCommunication::GetConfiguration(libcec_configuration &configuration)
645 {
646 return IsOpen() ? m_commands->GetConfiguration(configuration) : false;
647 }
648
649 std::string CUSBCECAdapterCommunication::GetPortName(void)
650 {
651 return m_port->GetName();
652 }
653
654 bool CUSBCECAdapterCommunication::SetControlledMode(bool controlled)
655 {
656 return IsOpen() ? m_commands->SetControlledMode(controlled) : false;
657 }
658
659 uint16_t CUSBCECAdapterCommunication::GetPhysicalAddress(void)
660 {
661 uint16_t iPA(0);
662
663 // try to get the PA from ADL
664 #if defined(HAS_ADL_EDID_PARSER)
665 {
666 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - trying to get the physical address via ADL", __FUNCTION__);
667 CADLEdidParser adl;
668 iPA = adl.GetPhysicalAddress();
669 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - ADL returned physical address %04x", __FUNCTION__, iPA);
670 }
671 #endif
672
673 // try to get the PA from the nvidia driver
674 #if defined(HAS_NVIDIA_EDID_PARSER)
675 if (iPA == 0)
676 {
677 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - trying to get the physical address via nvidia driver", __FUNCTION__);
678 CNVEdidParser nv;
679 iPA = nv.GetPhysicalAddress();
680 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - nvidia driver returned physical address %04x", __FUNCTION__, iPA);
681 }
682 #endif
683
684 // try to get the PA from the OS
685 if (iPA == 0)
686 {
687 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - trying to get the physical address from the OS", __FUNCTION__);
688 iPA = CEDIDParser::GetPhysicalAddress();
689 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - OS returned physical address %04x", __FUNCTION__, iPA);
690 }
691
692 return iPA;
693 }
694
695 void *CAdapterPingThread::Process(void)
696 {
697 while (!IsStopped())
698 {
699 if (m_timeout.TimeLeft() == 0)
700 {
701 /* reinit the timeout */
702 m_timeout.Init(CEC_ADAPTER_PING_TIMEOUT);
703
704 /* send a ping to the adapter */
705 bool bPinged(false);
706 int iFailedCounter(0);
707 while (!bPinged && iFailedCounter < 3)
708 {
709 if (!m_com->PingAdapter())
710 {
711 /* sleep and retry */
712 Sleep(CEC_DEFAULT_TRANSMIT_RETRY_WAIT);
713 ++iFailedCounter;
714 }
715 else
716 {
717 bPinged = true;
718 }
719 }
720
721 if (iFailedCounter == 3)
722 {
723 /* failed to ping the adapter 3 times in a row. something must be wrong with the connection */
724 m_com->LIB_CEC->AddLog(CEC_LOG_ERROR, "failed to ping the adapter 3 times in a row. closing the connection.");
725 m_com->StopThread(false);
726 break;
727 }
728 }
729
730 Sleep(5);
731 }
732 return NULL;
733 }
734
735 void CAdapterEepromWriteThread::Stop(void)
736 {
737 StopThread(-1);
738 {
739 CLockObject lock(m_mutex);
740 if (m_iScheduleEepromWrite > 0)
741 m_com->LIB_CEC->AddLog(CEC_LOG_WARNING, "write thread stopped while a write was queued");
742 m_bWrite = true;
743 m_condition.Signal();
744 }
745 StopThread();
746 }
747
748 void *CAdapterEepromWriteThread::Process(void)
749 {
750 while (!IsStopped())
751 {
752 CLockObject lock(m_mutex);
753 if ((m_iScheduleEepromWrite > 0 && m_iScheduleEepromWrite < GetTimeMs()) ||
754 m_condition.Wait(m_mutex, m_bWrite, 100))
755 {
756 if (IsStopped())
757 break;
758 m_bWrite = false;
759 if (m_com->m_commands->WriteEEPROM())
760 {
761 m_iLastEepromWrite = GetTimeMs();
762 m_iScheduleEepromWrite = 0;
763 }
764 else
765 {
766 m_iScheduleEepromWrite = GetTimeMs() + CEC_ADAPTER_EEPROM_WRITE_RETRY;
767 }
768 }
769 }
770 return NULL;
771 }
772
773 bool CAdapterEepromWriteThread::Write(void)
774 {
775 CLockObject lock(m_mutex);
776 if (m_iScheduleEepromWrite == 0)
777 {
778 int64_t iNow = GetTimeMs();
779 if (m_iLastEepromWrite + CEC_ADAPTER_EEPROM_WRITE_INTERVAL > iNow)
780 {
781 m_com->LIB_CEC->AddLog(CEC_LOG_DEBUG, "delaying eeprom write by %ld ms", m_iLastEepromWrite + CEC_ADAPTER_EEPROM_WRITE_INTERVAL - iNow);
782 m_iScheduleEepromWrite = m_iLastEepromWrite + CEC_ADAPTER_EEPROM_WRITE_INTERVAL;
783 }
784 else
785 {
786 m_bWrite = true;
787 m_condition.Signal();
788 }
789 }
790 return true;
791 }