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