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