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