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