cec: set controlled mode and retry to send the previous command if it failed with...
[deb_libcec.git] / src / lib / adapter / 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
7bb4ed43 33#include "USBCECAdapterCommunication.h"
ba65909d
LOK
34#include "../platform/sockets/serialport.h"
35#include "../platform/util/timeutils.h"
5477a250 36#include "../LibCEC.h"
7bb4ed43 37#include "../CECProcessor.h"
a8f0bd18
LOK
38
39using namespace std;
40using namespace CEC;
f00ff009 41using namespace PLATFORM;
a8f0bd18 42
ae54110f
LOK
43#define CEC_ADAPTER_PING_TIMEOUT 15000
44
83554890
LOK
45void *CUSBCECAdapterProcessor::Process(void)
46{
47 cec_command command;
48 while (!IsStopped())
49 {
50 if (m_inBuffer.Pop(command))
51 m_callback->OnCommandReceived(command);
52 Sleep(5);
53 }
54
55 return NULL;
56}
57
58void CUSBCECAdapterProcessor::AddCommand(cec_command command)
59{
60 m_inBuffer.Push(command);
61}
62
7bb4ed43 63CUSBCECAdapterCommunication::CUSBCECAdapterCommunication(CCECProcessor *processor, const char *strPort, uint16_t iBaudRate /* = 38400 */) :
12027dbe 64 m_port(NULL),
a171d2fd 65 m_processor(processor),
960f33c6 66 m_bHasData(false),
1fc16cfd 67 m_iLineTimeout(0),
7bb4ed43
LOK
68 m_iFirmwareVersion(CEC_FW_VERSION_UNKNOWN),
69 m_lastInitiator(CECDEVICE_UNKNOWN),
70 m_bNextIsEscaped(false),
83554890 71 m_bGotStart(false),
cccd2724
LOK
72 m_messageProcessor(NULL),
73 m_bInitialised(false)
a8f0bd18 74{
089f0e9d 75 m_port = new CSerialPort(strPort, iBaudRate);
a8f0bd18
LOK
76}
77
7bb4ed43 78CUSBCECAdapterCommunication::~CUSBCECAdapterCommunication(void)
a8f0bd18 79{
12027dbe 80 Close();
a8f0bd18
LOK
81}
82
efed01e1 83bool CUSBCECAdapterCommunication::CheckAdapter(uint32_t iTimeoutMs /* = 10000 */)
a8f0bd18 84{
efed01e1 85 bool bReturn(false);
7b494bea 86 uint64_t iNow = GetTimeMs();
efed01e1 87 uint64_t iTarget = iTimeoutMs > 0 ? iNow + iTimeoutMs : iNow + CEC_DEFAULT_TRANSMIT_WAIT;
7b494bea 88
efed01e1
LOK
89 /* try to ping the adapter */
90 bool bPinged(false);
91 unsigned iPingTry(0);
92 while (iNow < iTarget && (bPinged = PingAdapter()) == false)
13fd6a66 93 {
efed01e1 94 CLibCEC::AddLog(CEC_LOG_ERROR, "the adapter did not respond correctly to a ping (try %d)", ++iPingTry);
befa3a23 95 CEvent::Sleep(500);
efed01e1 96 iNow = GetTimeMs();
13fd6a66
LOK
97 }
98
efed01e1
LOK
99 /* try to read the firmware version */
100 m_iFirmwareVersion = CEC_FW_VERSION_UNKNOWN;
101 unsigned iFwVersionTry(0);
9aae458a 102 while (bPinged && iNow < iTarget && (m_iFirmwareVersion = GetFirmwareVersion()) == CEC_FW_VERSION_UNKNOWN && iFwVersionTry < 3)
13fd6a66 103 {
9aae458a 104 CLibCEC::AddLog(CEC_LOG_WARNING, "the adapter did not respond with a correct firmware version (try %d)", ++iFwVersionTry);
befa3a23 105 CEvent::Sleep(500);
efed01e1 106 iNow = GetTimeMs();
13fd6a66 107 }
a8f0bd18 108
9aae458a
LOK
109 if (m_iFirmwareVersion == CEC_FW_VERSION_UNKNOWN)
110 {
111 CLibCEC::AddLog(CEC_LOG_DEBUG, "defaulting to firmware version 1");
112 m_iFirmwareVersion = 1;
113 }
114
efed01e1 115 if (m_iFirmwareVersion >= 2)
7b494bea 116 {
efed01e1
LOK
117 /* try to set controlled mode */
118 unsigned iControlledTry(0);
119 bool bControlled(false);
120 while (iNow < iTarget && (bControlled = SetControlledMode(true)) == false)
7b494bea 121 {
efed01e1 122 CLibCEC::AddLog(CEC_LOG_ERROR, "the adapter did not respond correctly to setting controlled mode (try %d)", ++iControlledTry);
befa3a23 123 CEvent::Sleep(500);
7b494bea
LOK
124 iNow = GetTimeMs();
125 }
efed01e1 126 bReturn = bControlled;
7b494bea 127 }
efed01e1
LOK
128 else
129 bReturn = true;
7b494bea 130
cccd2724
LOK
131 {
132 CLockObject lock(m_mutex);
133 m_bInitialised = bReturn;
134 }
135
efed01e1
LOK
136 return bReturn;
137}
a8f0bd18 138
a2198e5e 139bool CUSBCECAdapterCommunication::Open(IAdapterCommunicationCallback *cb, uint32_t iTimeoutMs /* = 10000 */, bool bSkipChecks /* = false */)
efed01e1
LOK
140{
141 uint64_t iNow = GetTimeMs();
142 uint64_t iTimeout = iNow + iTimeoutMs;
a8f0bd18 143
2c780401 144 {
efed01e1
LOK
145 CLockObject lock(m_mutex);
146
147 if (!m_port)
148 {
149 CLibCEC::AddLog(CEC_LOG_ERROR, "port is NULL");
150 return false;
151 }
152
153 if (IsOpen())
154 {
155 CLibCEC::AddLog(CEC_LOG_ERROR, "port is already open");
156 return true;
157 }
158
159 m_callback = cb;
160 CStdString strError;
161 bool bConnected(false);
162 while (!bConnected && iNow < iTimeout)
163 {
164 if ((bConnected = m_port->Open(iTimeout)) == false)
165 {
166 strError.Format("error opening serial port '%s': %s", m_port->GetName().c_str(), m_port->GetError().c_str());
167 Sleep(250);
168 iNow = GetTimeMs();
169 }
170 }
171
172 if (!bConnected)
173 {
174 CLibCEC::AddLog(CEC_LOG_ERROR, strError);
175 return false;
176 }
177
178 CLibCEC::AddLog(CEC_LOG_DEBUG, "connection opened, clearing any previous input and waiting for active transmissions to end before starting");
179
a2198e5e 180 if (!bSkipChecks)
efed01e1 181 {
a2198e5e
LOK
182 //clear any input bytes
183 uint8_t buff[1024];
184 while (m_port->Read(buff, 1024, 100) > 0)
185 {
186 CLibCEC::AddLog(CEC_LOG_DEBUG, "data received, clearing it");
187 Sleep(250);
188 }
efed01e1 189 }
2c780401 190 }
a8f0bd18 191
befa3a23 192 if (!bSkipChecks && !CheckAdapter())
a8f0bd18 193 {
befa3a23
LOK
194 CLibCEC::AddLog(CEC_LOG_ERROR, "the adapter failed to pass basic checks");
195 return false;
196 }
197 else
198 {
199 if (CreateThread())
efed01e1 200 {
befa3a23
LOK
201 CLibCEC::AddLog(CEC_LOG_DEBUG, "communication thread started");
202 return true;
efed01e1
LOK
203 }
204 else
205 {
befa3a23 206 CLibCEC::AddLog(CEC_LOG_ERROR, "could not create a communication thread");
efed01e1 207 }
a8f0bd18
LOK
208 }
209
210 return false;
211}
212
7bb4ed43 213void CUSBCECAdapterCommunication::Close(void)
a8f0bd18 214{
b9eea66d 215 StopThread();
a8f0bd18
LOK
216}
217
7bb4ed43 218void *CUSBCECAdapterCommunication::Process(void)
a8f0bd18 219{
83554890
LOK
220 m_messageProcessor = new CUSBCECAdapterProcessor(m_callback);
221 m_messageProcessor->CreateThread();
222
b1f94db1 223 cec_command command;
32553784 224 command.Clear();
efed01e1 225 bool bCommandReceived(false);
ae54110f 226 CTimeout pingTimeout(CEC_ADAPTER_PING_TIMEOUT);
13fd6a66 227 while (!IsStopped())
a8f0bd18 228 {
efed01e1
LOK
229 {
230 CLockObject lock(m_mutex);
231 ReadFromDevice(50);
cccd2724 232 bCommandReceived = m_callback && Read(command, 0) && m_bInitialised;
efed01e1 233 }
b1f94db1
LOK
234
235 /* push the next command to the callback method if there is one */
efed01e1 236 if (!IsStopped() && bCommandReceived)
83554890 237 m_messageProcessor->AddCommand(command);
b1f94db1 238
ae54110f
LOK
239 /* ping the adapter every 15 seconds */
240 if (pingTimeout.TimeLeft() == 0)
241 {
242 pingTimeout.Init(CEC_ADAPTER_PING_TIMEOUT);
243 PingAdapter();
244 }
245
efed01e1
LOK
246 if (!IsStopped())
247 {
248 Sleep(5);
249 WriteNextCommand();
250 }
a8f0bd18
LOK
251 }
252
83554890
LOK
253 /* stop the message processor */
254 m_messageProcessor->StopThread();
255 delete m_messageProcessor;
256
f9e01dac 257 /* notify all threads that are waiting on messages to be sent */
ef7696f5 258 CCECAdapterMessage *msg(NULL);
f9e01dac 259 while (m_outBuffer.Pop(msg))
960f33c6 260 msg->event.Broadcast();
a0878ee3 261
f9e01dac
LOK
262 /* set the ackmask to 0 before closing the connection */
263 SetAckMaskInternal(0, true);
264
3c30c490
LOK
265 if (m_iFirmwareVersion >= 2)
266 SetControlledMode(false);
267
9f9c8c82
LOK
268 if (m_port)
269 {
270 delete m_port;
271 m_port = NULL;
272 }
273
a8f0bd18
LOK
274 return NULL;
275}
276
7bb4ed43
LOK
277cec_adapter_message_state CUSBCECAdapterCommunication::Write(const cec_command &data, uint8_t iMaxTries, uint8_t iLineTimeout /* = 3 */, uint8_t iRetryLineTimeout /* = 3 */)
278{
279 cec_adapter_message_state retVal(ADAPTER_MESSAGE_STATE_UNKNOWN);
9f68cc28
LOK
280 if (!IsRunning())
281 return retVal;
7bb4ed43
LOK
282
283 CCECAdapterMessage *output = new CCECAdapterMessage(data);
284
285 /* set the number of retries */
286 if (data.opcode == CEC_OPCODE_NONE) //TODO
287 output->maxTries = 1;
288 else if (data.initiator != CECDEVICE_BROADCAST)
289 output->maxTries = iMaxTries;
290
291 output->lineTimeout = iLineTimeout;
292 output->retryTimeout = iRetryLineTimeout;
293 output->tries = 0;
294
295 bool bRetry(true);
296 while (bRetry && ++output->tries < output->maxTries)
297 {
298 bRetry = (!Write(output) || output->NeedsRetry()) && output->transmit_timeout > 0;
299 if (bRetry)
300 Sleep(CEC_DEFAULT_TRANSMIT_RETRY_WAIT);
301 }
302 retVal = output->state;
303
304 delete output;
305 return retVal;
306}
307
308bool CUSBCECAdapterCommunication::Write(CCECAdapterMessage *data)
3c53ac93 309{
5dcf9f25 310 data->state = ADAPTER_MESSAGE_STATE_WAITING_TO_BE_SENT;
3c53ac93 311 m_outBuffer.Push(data);
f9e01dac 312 data->event.Wait(5000);
5dcf9f25 313
b1f94db1
LOK
314 if ((data->expectControllerAck && data->state != ADAPTER_MESSAGE_STATE_SENT_ACKED) ||
315 (!data->expectControllerAck && data->state != ADAPTER_MESSAGE_STATE_SENT))
5dcf9f25 316 {
b1f94db1
LOK
317 CLibCEC::AddLog(CEC_LOG_DEBUG, "command was not %s", data->state == ADAPTER_MESSAGE_STATE_SENT_NOT_ACKED ? "acked" : "sent");
318 return false;
5dcf9f25
LOK
319 }
320
b1f94db1 321 return true;
a8f0bd18
LOK
322}
323
7bb4ed43 324bool CUSBCECAdapterCommunication::Read(cec_command &command, uint32_t iTimeout)
a8f0bd18 325{
9f68cc28
LOK
326 if (!IsRunning())
327 return false;
328
7bb4ed43
LOK
329 CCECAdapterMessage msg;
330 if (Read(msg, iTimeout))
a8f0bd18 331 {
7bb4ed43 332 if (ParseMessage(msg))
a8f0bd18 333 {
7bb4ed43
LOK
334 command = m_currentframe;
335 m_currentframe.Clear();
336 return true;
a8f0bd18 337 }
7bb4ed43
LOK
338 }
339 return false;
340}
a8f0bd18 341
7bb4ed43
LOK
342bool CUSBCECAdapterCommunication::Read(CCECAdapterMessage &msg, uint32_t iTimeout)
343{
344 CLockObject lock(m_mutex);
a8f0bd18 345
7bb4ed43
LOK
346 msg.Clear();
347 CCECAdapterMessage *buf(NULL);
a8f0bd18 348
7bb4ed43
LOK
349 if (!m_inBuffer.Pop(buf))
350 {
960f33c6 351 if (iTimeout == 0 || !m_rcvCondition.Wait(m_mutex, m_bHasData, iTimeout))
7bb4ed43
LOK
352 return false;
353 m_inBuffer.Pop(buf);
120d4ca8 354 m_bHasData = !m_inBuffer.IsEmpty();
7bb4ed43 355 }
0e31a62c 356
7bb4ed43
LOK
357 if (buf)
358 {
359 msg.packet = buf->packet;
66e5bd72 360 msg.state = ADAPTER_MESSAGE_STATE_INCOMING;
7bb4ed43
LOK
361 delete buf;
362 return true;
363 }
364 return false;
a8f0bd18
LOK
365}
366
7bb4ed43 367CStdString CUSBCECAdapterCommunication::GetError(void) const
a8f0bd18 368{
ba65909d
LOK
369 CStdString strError;
370 strError = m_port->GetError();
371 return strError;
a8f0bd18 372}
2abe74eb 373
7bb4ed43 374bool CUSBCECAdapterCommunication::StartBootloader(void)
2abe74eb 375{
28352a04 376 bool bReturn(false);
2abe74eb 377 if (!IsRunning())
28352a04 378 return bReturn;
2abe74eb 379
5477a250 380 CLibCEC::AddLog(CEC_LOG_DEBUG, "starting the bootloader");
2abe74eb 381
089f0e9d
LOK
382 CCECAdapterMessage params;
383 return SendCommand(MSGCODE_START_BOOTLOADER, params, false);
2abe74eb
LOK
384}
385
7bb4ed43 386bool CUSBCECAdapterCommunication::PingAdapter(void)
2abe74eb 387{
befa3a23 388 CLockObject lock(m_mutex);
5477a250 389 CLibCEC::AddLog(CEC_LOG_DEBUG, "sending ping");
befa3a23 390
089f0e9d
LOK
391 CCECAdapterMessage params;
392 return SendCommand(MSGCODE_PING, params);
2abe74eb 393}
13fd6a66 394
7bb4ed43
LOK
395bool CUSBCECAdapterCommunication::ParseMessage(const CCECAdapterMessage &msg)
396{
397 bool bEom(false);
398 bool bIsError(msg.IsError());
399
400 if (msg.IsEmpty())
401 return bEom;
402
24dd566c 403 CLockObject adapterLock(m_mutex);
7bb4ed43
LOK
404 switch(msg.Message())
405 {
406 case MSGCODE_FRAME_START:
407 {
408 m_currentframe.Clear();
409 if (msg.Size() >= 2)
410 {
411 m_currentframe.initiator = msg.Initiator();
412 m_currentframe.destination = msg.Destination();
413 m_currentframe.ack = msg.IsACK();
414 m_currentframe.eom = msg.IsEOM();
415 }
416 if (m_currentframe.ack == 0x1)
417 {
418 m_lastInitiator = m_currentframe.initiator;
419 m_processor->HandlePoll(m_currentframe.initiator, m_currentframe.destination);
420 }
421 }
422 break;
423 case MSGCODE_RECEIVE_FAILED:
424 {
425 m_currentframe.Clear();
426 if (m_lastInitiator != CECDEVICE_UNKNOWN)
427 bIsError = m_processor->HandleReceiveFailed(m_lastInitiator);
428 }
429 break;
430 case MSGCODE_FRAME_DATA:
431 {
432 if (msg.Size() >= 2)
433 {
434 m_currentframe.PushBack(msg[1]);
435 m_currentframe.eom = msg.IsEOM();
436 }
7bb4ed43
LOK
437 }
438 break;
439 default:
440 break;
441 }
442
443 CLibCEC::AddLog(bIsError ? CEC_LOG_WARNING : CEC_LOG_DEBUG, msg.ToString());
d507711c 444 return msg.IsEOM();
7bb4ed43
LOK
445}
446
447uint16_t CUSBCECAdapterCommunication::GetFirmwareVersion(void)
1fc16cfd
LOK
448{
449 uint16_t iReturn(m_iFirmwareVersion);
1fc16cfd
LOK
450
451 if (iReturn == CEC_FW_VERSION_UNKNOWN)
452 {
006b76b9 453 CLockObject lock(m_mutex);
5477a250 454 CLibCEC::AddLog(CEC_LOG_DEBUG, "requesting the firmware version");
90008d10 455 cec_datapacket response = GetSetting(MSGCODE_FIRMWARE_VERSION, 2);
d4db0c6f 456 if (response.size == 2)
1fc16cfd 457 {
d4db0c6f
LOK
458 m_iFirmwareVersion = (response[0] << 8 | response[1]);
459 iReturn = m_iFirmwareVersion;
460 CLibCEC::AddLog(CEC_LOG_DEBUG, "firmware version %d", m_iFirmwareVersion);
efed01e1 461 }
1fc16cfd
LOK
462 }
463
464 return iReturn;
465}
466
7bb4ed43 467bool CUSBCECAdapterCommunication::SetLineTimeout(uint8_t iTimeout)
a171d2fd 468{
7bb4ed43 469 m_iLineTimeout = iTimeout;
089f0e9d
LOK
470 bool bReturn(m_iLineTimeout != iTimeout);
471
472 if (!bReturn)
473 {
474 CLibCEC::AddLog(CEC_LOG_DEBUG, "setting the line timeout to %d", iTimeout);
475 CCECAdapterMessage params;
476 params.PushEscaped(iTimeout);
477 bReturn = SendCommand(MSGCODE_TRANSMIT_IDLETIME, params);
478 }
479
480 return bReturn;
a171d2fd
LOK
481}
482
7bb4ed43 483bool CUSBCECAdapterCommunication::SetAckMask(uint16_t iMask)
f9e01dac 484{
089f0e9d 485 return SetAckMaskInternal(iMask, IsRunning());
f9e01dac
LOK
486}
487
488bool CUSBCECAdapterCommunication::SetAckMaskInternal(uint16_t iMask, bool bWriteDirectly /* = false */)
5dcf9f25 489{
bca69ca1 490 CLibCEC::AddLog(CEC_LOG_DEBUG, "setting ackmask to %2x", iMask);
5dcf9f25 491
089f0e9d
LOK
492 CCECAdapterMessage params;
493 params.PushEscaped(iMask >> 8);
494 params.PushEscaped((uint8_t)iMask);
495 return SendCommand(MSGCODE_SET_ACK_MASK, params, true, false, bWriteDirectly);
5dcf9f25
LOK
496}
497
c214d197
LOK
498bool CUSBCECAdapterCommunication::PersistConfiguration(libcec_configuration *configuration)
499{
cb4ee028
LOK
500 if (m_iFirmwareVersion < 2)
501 return false;
502
ffdfabf0 503 bool bReturn(true);
12a36be9
LOK
504 bReturn &= SetSettingAutoEnabled(true);
505 bReturn &= SetSettingDeviceType(CLibCEC::GetType(configuration->logicalAddresses.primary));
506 bReturn &= SetSettingDefaultLogicalAddress(configuration->logicalAddresses.primary);
507 bReturn &= SetSettingLogicalAddressMask(CLibCEC::GetMaskForType(configuration->logicalAddresses.primary));
508 bReturn &= SetSettingPhysicalAddress(configuration->iPhysicalAddress);
509 bReturn &= SetSettingCECVersion(CEC_VERSION_1_3A);
510 bReturn &= SetSettingOSDName(configuration->strDeviceName);
ffdfabf0
LOK
511 if (bReturn)
512 bReturn = WriteEEPROM();
513 return bReturn;
c214d197 514}
b057edad 515
12a36be9
LOK
516bool CUSBCECAdapterCommunication::GetConfiguration(libcec_configuration *configuration)
517{
518 if (m_iFirmwareVersion < 2)
519 return false;
520
521 bool bReturn(true);
522 cec_device_type type;
523 if (GetSettingDeviceType(type))
524 {
525 CLibCEC::AddLog(CEC_LOG_DEBUG, "using persisted device type setting %s", m_processor->ToString(type));
526 configuration->deviceTypes.Clear();
527 configuration->deviceTypes.Add(type);
528 }
529 else
530 {
531 CLibCEC::AddLog(CEC_LOG_DEBUG, "no persisted device type setting");
532 bReturn = false;
533 }
534
535 if (GetSettingPhysicalAddress(configuration->iPhysicalAddress))
536 {
537 CLibCEC::AddLog(CEC_LOG_DEBUG, "using persisted physical address setting %4x", configuration->iPhysicalAddress);
538 }
539 else
540 {
541 CLibCEC::AddLog(CEC_LOG_DEBUG, "no persisted physical address setting");
542 bReturn = false;
543 }
544
545 CStdString strDeviceName;
546 if (GetSettingOSDName(strDeviceName))
547 {
548 snprintf(configuration->strDeviceName, 13, "%s", strDeviceName.c_str());
549 CLibCEC::AddLog(CEC_LOG_DEBUG, "using persisted device name setting %s", configuration->strDeviceName);
550 }
551 else
552 {
553 CLibCEC::AddLog(CEC_LOG_DEBUG, "no persisted device name setting");
554 bReturn = false;
555 }
556
557 // don't read the following settings:
558 // - auto enabled (always enabled)
559 // - default logical address (autodetected)
560 // - logical address mask (autodetected)
561 // - CEC version (1.3a)
562
563 // TODO to be added to the firmware:
d28b4393
LOK
564 // - base device (4 bits)
565 // - HDMI port number (4 bits)
566 // - TV vendor id (12 bits)
567 // - wake devices (8 bits)
568 // - standby devices (8 bits)
12a36be9
LOK
569 // - use TV menu language (1 bit)
570 // - activate source (1 bit)
571 // - power off screensaver (1 bit)
572 // - power off on standby (1 bit)
573 // - send inactive source (1 bit)
574 return bReturn;
575}
576
b057edad
BL
577bool CUSBCECAdapterCommunication::SetControlledMode(bool controlled)
578{
befa3a23 579 CLockObject lock(m_mutex);
bca69ca1 580 CLibCEC::AddLog(CEC_LOG_DEBUG, "turning controlled mode %s", controlled ? "on" : "off");
b057edad 581
089f0e9d
LOK
582 CCECAdapterMessage params;
583 params.PushEscaped(controlled ? 1 : 0);
584 return SendCommand(MSGCODE_SET_CONTROLLED, params);
b057edad
BL
585}
586
12a36be9 587bool CUSBCECAdapterCommunication::SetSettingAutoEnabled(bool enabled)
c214d197
LOK
588{
589 CLockObject lock(m_mutex);
590 CLibCEC::AddLog(CEC_LOG_DEBUG, "turning autonomous mode %s", enabled ? "on" : "off");
591
c9c282a4
LOK
592 CCECAdapterMessage params;
593 params.PushEscaped(enabled ? 1 : 0);
594 return SendCommand(MSGCODE_SET_AUTO_ENABLED, params);
c214d197
LOK
595}
596
12a36be9
LOK
597bool CUSBCECAdapterCommunication::GetSettingAutoEnabled(bool &enabled)
598{
599 CLockObject lock(m_mutex);
600 CLibCEC::AddLog(CEC_LOG_DEBUG, "requesting autonomous mode setting");
601
90008d10 602 cec_datapacket response = GetSetting(MSGCODE_GET_AUTO_ENABLED, 1);
12a36be9
LOK
603 if (response.size == 1)
604 {
605 enabled = response[0] == 1;
606 return true;
607 }
608 return false;
609}
610
611bool CUSBCECAdapterCommunication::SetSettingDeviceType(cec_device_type type)
9878069e
LOK
612{
613 CLockObject lock(m_mutex);
614 CLibCEC::AddLog(CEC_LOG_DEBUG, "setting the device type to %1X", (uint8_t)type);
615
c9c282a4
LOK
616 CCECAdapterMessage params;
617 params.PushEscaped((uint8_t)type);
618 return SendCommand(MSGCODE_SET_DEVICE_TYPE, params);
9878069e
LOK
619}
620
12a36be9
LOK
621bool CUSBCECAdapterCommunication::GetSettingDeviceType(cec_device_type &value)
622{
623 CLockObject lock(m_mutex);
624 CLibCEC::AddLog(CEC_LOG_DEBUG, "requesting device type setting");
625
90008d10 626 cec_datapacket response = GetSetting(MSGCODE_GET_DEVICE_TYPE, 1);
12a36be9
LOK
627 if (response.size == 1)
628 {
629 value = (cec_device_type)response[0];
630 return true;
631 }
632 return false;
633}
634
635bool CUSBCECAdapterCommunication::SetSettingDefaultLogicalAddress(cec_logical_address address)
c214d197
LOK
636{
637 CLockObject lock(m_mutex);
638 CLibCEC::AddLog(CEC_LOG_DEBUG, "setting the default logical address to %1X", address);
639
c9c282a4
LOK
640 CCECAdapterMessage params;
641 params.PushEscaped((uint8_t)address);
642 return SendCommand(MSGCODE_SET_DEFAULT_LOGICAL_ADDRESS, params);
c214d197
LOK
643}
644
12a36be9
LOK
645bool CUSBCECAdapterCommunication::GetSettingDefaultLogicalAddress(cec_logical_address &address)
646{
647 CLockObject lock(m_mutex);
648 CLibCEC::AddLog(CEC_LOG_DEBUG, "requesting default logical address setting");
649
90008d10 650 cec_datapacket response = GetSetting(MSGCODE_GET_DEFAULT_LOGICAL_ADDRESS, 1);
12a36be9
LOK
651 if (response.size == 1)
652 {
653 address = (cec_logical_address)response[0];
654 return true;
655 }
656 return false;
657}
658
659bool CUSBCECAdapterCommunication::SetSettingLogicalAddressMask(uint16_t iMask)
c214d197
LOK
660{
661 CLockObject lock(m_mutex);
662 CLibCEC::AddLog(CEC_LOG_DEBUG, "setting the logical address mask to %2X", iMask);
663
c9c282a4
LOK
664 CCECAdapterMessage params;
665 params.PushEscaped(iMask >> 8);
666 params.PushEscaped((uint8_t)iMask);
667 return SendCommand(MSGCODE_SET_LOGICAL_ADDRESS_MASK, params);
c214d197
LOK
668}
669
12a36be9
LOK
670bool CUSBCECAdapterCommunication::GetSettingLogicalAddressMask(uint16_t &iMask)
671{
672 CLockObject lock(m_mutex);
673 CLibCEC::AddLog(CEC_LOG_DEBUG, "requesting logical address mask setting");
674
90008d10 675 cec_datapacket response = GetSetting(MSGCODE_GET_LOGICAL_ADDRESS_MASK, 2);
12a36be9
LOK
676 if (response.size == 2)
677 {
678 iMask = ((uint16_t)response[0] << 8) | ((uint16_t)response[1]);
679 return true;
680 }
681 return false;
682}
683
684bool CUSBCECAdapterCommunication::SetSettingPhysicalAddress(uint16_t iPhysicalAddress)
c214d197
LOK
685{
686 CLockObject lock(m_mutex);
687 CLibCEC::AddLog(CEC_LOG_DEBUG, "setting the physical address to %2X", iPhysicalAddress);
688
c9c282a4
LOK
689 CCECAdapterMessage params;
690 params.PushEscaped(iPhysicalAddress >> 8);
691 params.PushEscaped((uint8_t)iPhysicalAddress);
692 return SendCommand(MSGCODE_SET_PHYSICAL_ADDRESS, params);
c214d197
LOK
693}
694
12a36be9
LOK
695bool CUSBCECAdapterCommunication::GetSettingPhysicalAddress(uint16_t &iPhysicalAddress)
696{
697 CLockObject lock(m_mutex);
698 CLibCEC::AddLog(CEC_LOG_DEBUG, "requesting physical address setting");
699
90008d10 700 cec_datapacket response = GetSetting(MSGCODE_GET_PHYSICAL_ADDRESS, 2);
12a36be9
LOK
701 if (response.size == 2)
702 {
703 iPhysicalAddress = ((uint16_t)response[0] << 8) | ((uint16_t)response[1]);
704 return true;
705 }
706 return false;
707}
708
709bool CUSBCECAdapterCommunication::SetSettingCECVersion(cec_version version)
c214d197
LOK
710{
711 CLockObject lock(m_mutex);
712 CLibCEC::AddLog(CEC_LOG_DEBUG, "setting the CEC version to %s", CLibCEC::GetInstance()->ToString(version));
713
c9c282a4
LOK
714 CCECAdapterMessage params;
715 params.PushEscaped((uint8_t)version);
716 return SendCommand(MSGCODE_SET_HDMI_VERSION, params);
c214d197
LOK
717}
718
12a36be9
LOK
719bool CUSBCECAdapterCommunication::GetSettingCECVersion(cec_version &version)
720{
721 CLockObject lock(m_mutex);
722 CLibCEC::AddLog(CEC_LOG_DEBUG, "requesting CEC version setting");
723
90008d10 724 cec_datapacket response = GetSetting(MSGCODE_GET_HDMI_VERSION, 1);
12a36be9
LOK
725 if (response.size == 1)
726 {
727 version = (cec_version)response[0];
728 return true;
729 }
730 return false;
731}
732
733bool CUSBCECAdapterCommunication::SetSettingOSDName(const char *strOSDName)
c214d197
LOK
734{
735 CLockObject lock(m_mutex);
736 CLibCEC::AddLog(CEC_LOG_DEBUG, "setting the OSD name to %s", strOSDName);
737
c9c282a4 738 CCECAdapterMessage params;
c214d197 739 for (size_t iPtr = 0; iPtr < strlen(strOSDName); iPtr++)
c9c282a4
LOK
740 params.PushEscaped(strOSDName[iPtr]);
741 return SendCommand(MSGCODE_SET_OSD_NAME, params);
c214d197
LOK
742}
743
12a36be9
LOK
744bool CUSBCECAdapterCommunication::GetSettingOSDName(CStdString &strOSDName)
745{
746 CLockObject lock(m_mutex);
747 CLibCEC::AddLog(CEC_LOG_DEBUG, "requesting OSD name setting");
748
90008d10 749 cec_datapacket response = GetSetting(MSGCODE_GET_OSD_NAME, 13);
12a36be9
LOK
750 if (response.size == 0)
751 return false;
752
90008d10
LOK
753 char buf[14];
754 for (uint8_t iPtr = 0; iPtr < response.size && iPtr < 13; iPtr++)
12a36be9
LOK
755 buf[iPtr] = (char)response[iPtr];
756 buf[response.size] = 0;
757
758 strOSDName.Format("%s", buf);
759 return true;
760}
761
c214d197
LOK
762bool CUSBCECAdapterCommunication::WriteEEPROM(void)
763{
764 CLockObject lock(m_mutex);
765 CLibCEC::AddLog(CEC_LOG_DEBUG, "writing settings in the EEPROM");
766
c9c282a4
LOK
767 CCECAdapterMessage params;
768 return SendCommand(MSGCODE_WRITE_EEPROM, params);
c214d197
LOK
769}
770
7bb4ed43 771bool CUSBCECAdapterCommunication::IsOpen(void)
13fd6a66 772{
b9eea66d 773 return !IsStopped() && m_port->IsOpen() && IsRunning();
13fd6a66 774}
ef7696f5 775
7bb4ed43 776bool CUSBCECAdapterCommunication::WaitForAck(CCECAdapterMessage &message)
6729ac71
LOK
777{
778 bool bError(false);
779 bool bTransmitSucceeded(false);
99f1d66e 780 uint8_t iPacketsLeft(message.isTransmission ? message.Size() / 4 : 1);
6729ac71
LOK
781
782 int64_t iNow = GetTimeMs();
b1f94db1 783 int64_t iTargetTime = iNow + (message.transmit_timeout <= 5 ? CEC_DEFAULT_TRANSMIT_WAIT : message.transmit_timeout);
6729ac71 784
b1f94db1 785 while (!bTransmitSucceeded && !bError && iNow < iTargetTime)
6729ac71 786 {
b1f94db1 787 ReadFromDevice(50);
6729ac71 788 CCECAdapterMessage msg;
b1f94db1 789 if (!Read(msg, 0))
6729ac71
LOK
790 {
791 iNow = GetTimeMs();
792 continue;
793 }
794
795 if (msg.Message() == MSGCODE_FRAME_START && msg.IsACK())
796 {
797 m_processor->HandlePoll(msg.Initiator(), msg.Destination());
7bb4ed43 798 m_lastInitiator = msg.Initiator();
6729ac71
LOK
799 iNow = GetTimeMs();
800 continue;
801 }
802
803 if (msg.Message() == MSGCODE_RECEIVE_FAILED &&
7bb4ed43
LOK
804 m_lastInitiator != CECDEVICE_UNKNOWN &&
805 m_processor->HandleReceiveFailed(m_lastInitiator))
6729ac71
LOK
806 {
807 iNow = GetTimeMs();
808 continue;
809 }
810
811 bError = msg.IsError();
812 if (bError)
813 {
b2f0b1ab 814 message.reply = msg.Message();
5477a250 815 CLibCEC::AddLog(CEC_LOG_DEBUG, msg.ToString());
6729ac71
LOK
816 }
817 else
818 {
819 switch(msg.Message())
820 {
821 case MSGCODE_COMMAND_ACCEPTED:
6729ac71
LOK
822 if (iPacketsLeft > 0)
823 iPacketsLeft--;
b2f0b1ab 824 if (!message.isTransmission && iPacketsLeft == 0)
5dcf9f25 825 bTransmitSucceeded = true;
befa3a23 826 CLibCEC::AddLog(CEC_LOG_DEBUG, "%s - waiting for %d more", msg.ToString().c_str(), iPacketsLeft);
6729ac71
LOK
827 break;
828 case MSGCODE_TRANSMIT_SUCCEEDED:
5477a250 829 CLibCEC::AddLog(CEC_LOG_DEBUG, msg.ToString());
6729ac71
LOK
830 bTransmitSucceeded = (iPacketsLeft == 0);
831 bError = !bTransmitSucceeded;
b2f0b1ab 832 message.reply = MSGCODE_TRANSMIT_SUCCEEDED;
6729ac71
LOK
833 break;
834 default:
835 // ignore other data while waiting
836 break;
837 }
838
839 iNow = GetTimeMs();
840 }
841 }
842
b1f94db1
LOK
843 message.state = bTransmitSucceeded && !bError ?
844 ADAPTER_MESSAGE_STATE_SENT_ACKED :
845 ADAPTER_MESSAGE_STATE_SENT_NOT_ACKED;
846
6729ac71
LOK
847 return bTransmitSucceeded && !bError;
848}
849
7bb4ed43 850void CUSBCECAdapterCommunication::AddData(uint8_t *data, size_t iLen)
ef7696f5
LOK
851{
852 CLockObject lock(m_mutex);
99666519 853 for (size_t iPtr = 0; iPtr < iLen; iPtr++)
7bb4ed43
LOK
854 {
855 if (!m_bGotStart)
856 {
857 if (data[iPtr] == MSGSTART)
858 m_bGotStart = true;
859 }
860 else if (data[iPtr] == MSGSTART) //we found a msgstart before msgend, this is not right, remove
861 {
862 if (m_currentAdapterMessage.Size() > 0)
863 CLibCEC::AddLog(CEC_LOG_WARNING, "received MSGSTART before MSGEND, removing previous buffer contents");
864 m_currentAdapterMessage.Clear();
865 m_bGotStart = true;
866 }
867 else if (data[iPtr] == MSGEND)
868 {
869 CCECAdapterMessage *newMessage = new CCECAdapterMessage;
870 newMessage->packet = m_currentAdapterMessage.packet;
871 m_inBuffer.Push(newMessage);
872 m_currentAdapterMessage.Clear();
873 m_bGotStart = false;
874 m_bNextIsEscaped = false;
960f33c6 875 m_bHasData = true;
24dd566c 876 m_rcvCondition.Broadcast();
7bb4ed43
LOK
877 }
878 else if (m_bNextIsEscaped)
879 {
880 m_currentAdapterMessage.PushBack(data[iPtr] + (uint8_t)ESCOFFSET);
881 m_bNextIsEscaped = false;
882 }
883 else if (data[iPtr] == MSGESC)
884 {
885 m_bNextIsEscaped = true;
886 }
887 else
888 {
889 m_currentAdapterMessage.PushBack(data[iPtr]);
890 }
891 }
ef7696f5
LOK
892}
893
b1f94db1 894bool CUSBCECAdapterCommunication::ReadFromDevice(uint32_t iTimeout, size_t iSize /* = 256 */)
ef7696f5 895{
99666519
LOK
896 ssize_t iBytesRead;
897 uint8_t buff[256];
ef7696f5
LOK
898 if (!m_port)
899 return false;
b1f94db1
LOK
900 if (iSize > 256)
901 iSize = 256;
ef7696f5 902
1fc16cfd 903 CLockObject lock(m_mutex);
b1f94db1 904 iBytesRead = m_port->Read(buff, sizeof(uint8_t) * iSize, iTimeout);
ef7696f5
LOK
905 if (iBytesRead < 0 || iBytesRead > 256)
906 {
99666519 907 CLibCEC::AddLog(CEC_LOG_ERROR, "error reading from serial port: %s", m_port->GetError().c_str());
60383b11 908 StopThread(false);
ef7696f5
LOK
909 return false;
910 }
911 else if (iBytesRead > 0)
99666519
LOK
912 {
913 AddData(buff, iBytesRead);
914 }
ef7696f5
LOK
915
916 return iBytesRead > 0;
917}
918
7bb4ed43 919void CUSBCECAdapterCommunication::SendMessageToAdapter(CCECAdapterMessage *msg)
ef7696f5 920{
1fc16cfd 921 CLockObject adapterLock(m_mutex);
f9e01dac
LOK
922 if (!m_port->IsOpen())
923 {
924 CLibCEC::AddLog(CEC_LOG_ERROR, "error writing to serial port: the connection is closed");
925 msg->state = ADAPTER_MESSAGE_STATE_ERROR;
926 return;
927 }
928
089f0e9d
LOK
929 if (msg->isTransmission && (msg->Size() < 2 || msg->At(1) != MSGCODE_TRANSMIT_IDLETIME))
930 {
931 if (msg->tries == 1)
932 SetLineTimeout(msg->lineTimeout);
933 else
934 SetLineTimeout(msg->retryTimeout);
935 }
7bb4ed43 936
99666519 937 if (m_port->Write(msg->packet.data, msg->Size()) != (ssize_t) msg->Size())
ef7696f5 938 {
b74fd339 939 CLibCEC::AddLog(CEC_LOG_ERROR, "error writing to serial port: %s", m_port->GetError().c_str());
ef7696f5
LOK
940 msg->state = ADAPTER_MESSAGE_STATE_ERROR;
941 }
942 else
943 {
5477a250 944 CLibCEC::AddLog(CEC_LOG_DEBUG, "command sent");
ef7696f5 945 msg->state = ADAPTER_MESSAGE_STATE_SENT;
b1f94db1
LOK
946
947 if (msg->expectControllerAck)
948 {
949 if (!WaitForAck(*msg))
950 CLibCEC::AddLog(CEC_LOG_DEBUG, "did not receive ack");
951 }
ef7696f5 952 }
960f33c6 953 msg->event.Signal();
ef7696f5
LOK
954}
955
7bb4ed43 956void CUSBCECAdapterCommunication::WriteNextCommand(void)
ef7696f5
LOK
957{
958 CCECAdapterMessage *msg(NULL);
959 if (m_outBuffer.Pop(msg))
960 SendMessageToAdapter(msg);
961}
cba904a6
LOK
962
963CStdString CUSBCECAdapterCommunication::GetPortName(void)
964{
965 CStdString strName;
966 strName = m_port->GetName();
967 return strName;
968}
c9c282a4 969
9b175d9c 970bool CUSBCECAdapterCommunication::SendCommand(cec_adapter_messagecode msgCode, CCECAdapterMessage &params, bool bExpectAck /* = true */, bool bIsTransmission /* = false */, bool bSendDirectly /* = true */, bool bIsRetry /* = false */)
c9c282a4
LOK
971{
972 CLockObject lock(m_mutex);
973
974 CCECAdapterMessage *output = new CCECAdapterMessage;
975
976 output->PushBack(MSGSTART);
edd18f05 977 output->PushEscaped((uint8_t)msgCode);
c9c282a4
LOK
978 output->Append(params);
979 output->PushBack(MSGEND);
089f0e9d
LOK
980 output->isTransmission = bIsTransmission;
981 output->expectControllerAck = bExpectAck;
982
983 if (bSendDirectly)
984 SendMessageToAdapter(output);
985 else
986 Write(output);
c9c282a4 987
089f0e9d 988 bool bWriteOk = output->state == (output->expectControllerAck ? ADAPTER_MESSAGE_STATE_SENT_ACKED : ADAPTER_MESSAGE_STATE_SENT);
c9c282a4
LOK
989 if (!bWriteOk)
990 {
7a87e02e 991 CLibCEC::AddLog(CEC_LOG_ERROR, "'%s' failed", CCECAdapterMessage::ToString(msgCode));
c9c282a4 992 delete output;
9b175d9c
LOK
993
994 if (!bIsRetry && output->reply == MSGCODE_COMMAND_REJECTED && msgCode != MSGCODE_SET_CONTROLLED)
995 {
996 CLibCEC::AddLog(CEC_LOG_DEBUG, "setting controlled mode and retrying");
997 if (SetControlledMode(true))
998 return SendCommand(msgCode, params, bExpectAck, bIsTransmission, bSendDirectly, true);
999 }
c9c282a4
LOK
1000 return false;
1001 }
1002
1003 delete output;
1004 return true;
1005}
d4db0c6f 1006
90008d10 1007cec_datapacket CUSBCECAdapterCommunication::GetSetting(cec_adapter_messagecode msgCode, uint8_t iResponseLength)
d4db0c6f
LOK
1008{
1009 cec_datapacket retVal;
1010 retVal.Clear();
1011
1012 CCECAdapterMessage params;
1013 if (!SendCommand(msgCode, params, false))
1014 {
1015 CLibCEC::AddLog(CEC_LOG_ERROR, "%s failed", CCECAdapterMessage::ToString(msgCode));
1016 return retVal;
1017 }
1018
1019 Sleep(250); // TODO ReadFromDevice() isn't waiting for the timeout to pass on win32
90008d10 1020 ReadFromDevice(CEC_DEFAULT_TRANSMIT_WAIT, iResponseLength + 3 /* start + msgcode + iResponseLength + end */);
d4db0c6f
LOK
1021 CCECAdapterMessage input;
1022 if (Read(input, 0))
1023 {
1024 if (input.Message() != msgCode)
1025 CLibCEC::AddLog(CEC_LOG_ERROR, "invalid response to %s received (%s)", CCECAdapterMessage::ToString(msgCode), CCECAdapterMessage::ToString(input.Message()));
1026 else
1027 {
1028 for (uint8_t iPtr = 1; iPtr < input.Size(); iPtr++)
1029 retVal.PushBack(input[iPtr]);
1030 }
1031 }
1032 else
1033 {
1034 CLibCEC::AddLog(CEC_LOG_ERROR, "no response to %s received", CCECAdapterMessage::ToString(msgCode));
1035 }
1036
1037 return retVal;
1038}