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