2 * This file is part of the libCEC(R) library.
4 * libCEC(R) is Copyright (C) 2011-2012 Pulse-Eight Limited. All rights reserved.
5 * libCEC(R) is an original work, containing original code.
7 * libCEC(R) is a trademark of Pulse-Eight Limited.
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.
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.
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.
24 * Alternatively, you can license this library under a commercial license,
25 * please contact Pulse-Eight Licensing for more information.
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/
34 #include "USBCECAdapterMessageQueue.h"
36 #include "USBCECAdapterCommunication.h"
37 #include "USBCECAdapterMessage.h"
38 #include "lib/platform/sockets/socket.h"
39 #include "lib/LibCEC.h"
40 #include "lib/platform/util/StdString.h"
43 using namespace PLATFORM
;
46 #define MESSAGE_QUEUE_SIGNAL_WAIT_TIME 1000
48 CCECAdapterMessageQueueEntry::CCECAdapterMessageQueueEntry(CCECAdapterMessageQueue
*queue
, CCECAdapterMessage
*message
) :
51 m_iPacketsLeft(message
->IsTranmission() ? message
->Size() / 4 : 1),
55 CCECAdapterMessageQueueEntry::~CCECAdapterMessageQueueEntry(void) { }
57 void CCECAdapterMessageQueueEntry::Broadcast(void)
59 CLockObject
lock(m_mutex
);
60 m_condition
.Broadcast();
63 bool CCECAdapterMessageQueueEntry::MessageReceived(const CCECAdapterMessage
&message
)
67 if (IsResponse(message
))
69 switch (message
.Message())
71 case MSGCODE_COMMAND_ACCEPTED
:
72 bHandled
= MessageReceivedCommandAccepted(message
);
74 case MSGCODE_TRANSMIT_SUCCEEDED
:
75 bHandled
= MessageReceivedTransmitSucceeded(message
);
78 bHandled
= MessageReceivedResponse(message
);
86 void CCECAdapterMessageQueueEntry::Signal(void)
88 CLockObject
lock(m_mutex
);
93 bool CCECAdapterMessageQueueEntry::Wait(uint32_t iTimeout
)
96 /* wait until we receive a signal when the tranmission succeeded */
98 CLockObject
lock(m_mutex
);
99 bReturn
= m_bSucceeded
? true : m_condition
.Wait(m_mutex
, m_bSucceeded
, iTimeout
);
105 bool CCECAdapterMessageQueueEntry::IsWaiting(void)
107 CLockObject
lock(m_mutex
);
111 cec_adapter_messagecode
CCECAdapterMessageQueueEntry::MessageCode(void)
113 return m_message
->Message();
116 bool CCECAdapterMessageQueueEntry::IsResponseOld(const CCECAdapterMessage
&msg
)
118 cec_adapter_messagecode msgCode
= msg
.Message();
120 return msgCode
== MessageCode() ||
121 msgCode
== MSGCODE_COMMAND_ACCEPTED
||
122 msgCode
== MSGCODE_COMMAND_REJECTED
||
123 (m_message
->IsTranmission() && (msgCode
== MSGCODE_TIMEOUT_ERROR
||
124 msgCode
== MSGCODE_HIGH_ERROR
||
125 msgCode
== MSGCODE_LOW_ERROR
||
126 msgCode
== MSGCODE_RECEIVE_FAILED
||
127 msgCode
== MSGCODE_TRANSMIT_FAILED_LINE
||
128 msgCode
== MSGCODE_TRANSMIT_FAILED_ACK
||
129 msgCode
== MSGCODE_TRANSMIT_FAILED_TIMEOUT_DATA
||
130 msgCode
== MSGCODE_TRANSMIT_FAILED_TIMEOUT_LINE
||
131 msgCode
== MSGCODE_TRANSMIT_SUCCEEDED
));
134 bool CCECAdapterMessageQueueEntry::IsResponse(const CCECAdapterMessage
&msg
)
136 cec_adapter_messagecode thisMsgCode
= m_message
->Message();
137 cec_adapter_messagecode msgCode
= msg
.Message();
138 cec_adapter_messagecode msgResponse
= msg
.ResponseTo();
140 // msgcode matches, always a response
141 if (msgCode
== MessageCode())
144 if (!ProvidesExtendedResponse())
145 return IsResponseOld(msg
);
147 // response without a msgcode
148 if (msgResponse
== MSGCODE_NOTHING
)
150 m_queue
->m_com
->m_callback
->GetLib()->AddLog(CEC_LOG_WARNING
, "no response code received");
154 // commands that only repond with accepted/rejected
155 if (thisMsgCode
== MSGCODE_PING
||
156 thisMsgCode
== MSGCODE_SET_ACK_MASK
||
157 thisMsgCode
== MSGCODE_SET_CONTROLLED
||
158 thisMsgCode
== MSGCODE_SET_AUTO_ENABLED
||
159 thisMsgCode
== MSGCODE_SET_DEFAULT_LOGICAL_ADDRESS
||
160 thisMsgCode
== MSGCODE_SET_LOGICAL_ADDRESS_MASK
||
161 thisMsgCode
== MSGCODE_SET_PHYSICAL_ADDRESS
||
162 thisMsgCode
== MSGCODE_SET_DEVICE_TYPE
||
163 thisMsgCode
== MSGCODE_SET_HDMI_VERSION
||
164 thisMsgCode
== MSGCODE_SET_OSD_NAME
||
165 thisMsgCode
== MSGCODE_WRITE_EEPROM
||
166 thisMsgCode
== MSGCODE_TRANSMIT_IDLETIME
)
167 return thisMsgCode
== msgResponse
;
169 if (!m_message
->IsTranmission())
171 m_queue
->m_com
->m_callback
->GetLib()->AddLog(CEC_LOG_WARNING
, "FIXME! not a transmission");
175 return ((msgCode
== MSGCODE_COMMAND_ACCEPTED
|| msgCode
== MSGCODE_COMMAND_REJECTED
) &&
176 (msgResponse
== MSGCODE_TRANSMIT_ACK_POLARITY
|| msgResponse
== MSGCODE_TRANSMIT
|| msgResponse
== MSGCODE_TRANSMIT_EOM
)) ||
177 msgCode
== MSGCODE_TIMEOUT_ERROR
||
178 msgCode
== MSGCODE_HIGH_ERROR
||
179 msgCode
== MSGCODE_LOW_ERROR
||
180 msgCode
== MSGCODE_RECEIVE_FAILED
||
181 msgCode
== MSGCODE_TRANSMIT_FAILED_LINE
||
182 msgCode
== MSGCODE_TRANSMIT_FAILED_ACK
||
183 msgCode
== MSGCODE_TRANSMIT_FAILED_TIMEOUT_DATA
||
184 msgCode
== MSGCODE_TRANSMIT_FAILED_TIMEOUT_LINE
||
185 msgCode
== MSGCODE_TRANSMIT_SUCCEEDED
;
188 const char *CCECAdapterMessageQueueEntry::ToString(void) const
190 /* CEC transmissions got the 'set ack polarity' msgcode, which doesn't look nice */
191 if (m_message
->IsTranmission())
192 return "CEC transmission";
194 return CCECAdapterMessage::ToString(m_message
->Message());
197 bool CCECAdapterMessageQueueEntry::MessageReceivedCommandAccepted(const CCECAdapterMessage
&message
)
199 bool bSendSignal(false);
200 bool bHandled(false);
202 CLockObject
lock(m_mutex
);
203 if (m_iPacketsLeft
> 0)
208 /* log this message */
210 strLog
.Format("%s - command accepted", ToString());
211 if (m_iPacketsLeft
> 0)
212 strLog
.AppendFormat(" - waiting for %d more", m_iPacketsLeft
);
213 m_queue
->m_com
->m_callback
->GetLib()->AddLog(CEC_LOG_DEBUG
, strLog
);
215 /* no more packets left and not a transmission, so we're done */
216 if (!m_message
->IsTranmission() && m_iPacketsLeft
== 0)
218 m_message
->state
= ADAPTER_MESSAGE_STATE_SENT_ACKED
;
219 m_message
->response
= message
.packet
;
232 bool CCECAdapterMessageQueueEntry::MessageReceivedTransmitSucceeded(const CCECAdapterMessage
&message
)
235 CLockObject
lock(m_mutex
);
236 if (m_iPacketsLeft
== 0)
238 /* transmission succeeded, so we're done */
239 m_queue
->m_com
->m_callback
->GetLib()->AddLog(CEC_LOG_DEBUG
, "%s - transmit succeeded", ToString());
240 m_message
->state
= ADAPTER_MESSAGE_STATE_SENT_ACKED
;
241 m_message
->response
= message
.packet
;
245 /* error, we expected more acks
246 since the messages are processed in order, this should not happen, so this is an error situation */
247 m_queue
->m_com
->m_callback
->GetLib()->AddLog(CEC_LOG_WARNING
, "%s - received 'transmit succeeded' but not enough 'command accepted' messages (%d left)", ToString(), m_iPacketsLeft
);
248 m_message
->state
= ADAPTER_MESSAGE_STATE_ERROR
;
257 bool CCECAdapterMessageQueueEntry::MessageReceivedResponse(const CCECAdapterMessage
&message
)
260 CLockObject
lock(m_mutex
);
261 m_queue
->m_com
->m_callback
->GetLib()->AddLog(CEC_LOG_DEBUG
, "%s - received response - %s", ToString(), message
.ToString().c_str());
262 m_message
->response
= message
.packet
;
263 if (m_message
->IsTranmission())
264 m_message
->state
= message
.Message() == MSGCODE_TRANSMIT_SUCCEEDED
? ADAPTER_MESSAGE_STATE_SENT_ACKED
: ADAPTER_MESSAGE_STATE_SENT_NOT_ACKED
;
266 m_message
->state
= ADAPTER_MESSAGE_STATE_SENT_ACKED
;
274 bool CCECAdapterMessageQueueEntry::ProvidesExtendedResponse(void)
276 return m_queue
&& m_queue
->ProvidesExtendedResponse();
279 CCECAdapterMessageQueue::CCECAdapterMessageQueue(CUSBCECAdapterCommunication
*com
) :
284 m_incomingAdapterMessage
= new CCECAdapterMessage
;
285 m_currentCECFrame
.Clear();
288 CCECAdapterMessageQueue::~CCECAdapterMessageQueue(void)
292 delete m_incomingAdapterMessage
;
295 void CCECAdapterMessageQueue::Clear(void)
298 CLockObject
lock(m_mutex
);
299 m_writeQueue
.Clear();
303 void *CCECAdapterMessageQueue::Process(void)
305 CCECAdapterMessageQueueEntry
*message(NULL
);
308 /* wait for a new message */
309 if (m_writeQueue
.Pop(message
, MESSAGE_QUEUE_SIGNAL_WAIT_TIME
) && message
)
311 /* write this message */
313 CLockObject
lock(m_mutex
);
314 m_com
->WriteToDevice(message
->m_message
);
316 if (message
->m_message
->state
== ADAPTER_MESSAGE_STATE_ERROR
||
317 message
->m_message
->Message() == MSGCODE_START_BOOTLOADER
)
328 void CCECAdapterMessageQueue::MessageReceived(const CCECAdapterMessage
&msg
)
330 bool bHandled(false);
331 CLockObject
lock(m_mutex
);
332 /* send the received message to each entry in the queue until it is handled */
333 for (map
<uint64_t, CCECAdapterMessageQueueEntry
*>::iterator it
= m_messages
.begin(); !bHandled
&& it
!= m_messages
.end(); it
++)
334 bHandled
= it
->second
->MessageReceived(msg
);
338 /* the message wasn't handled */
339 bool bIsError(m_com
->HandlePoll(msg
));
340 m_com
->m_callback
->GetLib()->AddLog(bIsError
? CEC_LOG_WARNING
: CEC_LOG_DEBUG
, msg
.ToString().c_str());
342 /* push this message to the current frame */
343 if (!bIsError
&& msg
.PushToCecCommand(m_currentCECFrame
))
345 /* and push the current frame back over the callback method when a full command was received */
346 if (m_com
->IsInitialised())
347 m_com
->m_callback
->OnCommandReceived(m_currentCECFrame
);
349 /* clear the current frame */
350 m_currentCECFrame
.Clear();
355 void CCECAdapterMessageQueue::AddData(uint8_t *data
, size_t iLen
)
357 for (size_t iPtr
= 0; iPtr
< iLen
; iPtr
++)
359 bool bFullMessage(false);
361 CLockObject
lock(m_mutex
);
362 bFullMessage
= m_incomingAdapterMessage
->PushReceivedByte(data
[iPtr
]);
367 /* a full message was received */
368 CCECAdapterMessage newMessage
;
369 newMessage
.packet
= m_incomingAdapterMessage
->packet
;
370 MessageReceived(newMessage
);
372 /* clear the current message */
373 CLockObject
lock(m_mutex
);
374 m_incomingAdapterMessage
->Clear();
379 bool CCECAdapterMessageQueue::Write(CCECAdapterMessage
*msg
)
381 msg
->state
= ADAPTER_MESSAGE_STATE_WAITING_TO_BE_SENT
;
383 /* set the correct line timeout */
384 if (msg
->IsTranmission())
386 m_com
->SetLineTimeout(msg
->lineTimeout
);
389 CCECAdapterMessageQueueEntry
*entry
= new CCECAdapterMessageQueueEntry(this, msg
);
390 uint64_t iEntryId(0);
391 /* add to the wait for ack queue */
392 if (msg
->Message() != MSGCODE_START_BOOTLOADER
)
394 CLockObject
lock(m_mutex
);
395 iEntryId
= m_iNextMessage
++;
396 m_messages
.insert(make_pair(iEntryId
, entry
));
399 /* add the message to the write queue */
400 m_writeQueue
.Push(entry
);
405 if (!entry
->Wait(msg
->transmit_timeout
<= 5 ? CEC_DEFAULT_TRANSMIT_WAIT
: msg
->transmit_timeout
))
407 m_com
->m_callback
->GetLib()->AddLog(CEC_LOG_DEBUG
, "command '%s' was not acked by the controller", CCECAdapterMessage::ToString(msg
->Message()));
408 msg
->state
= ADAPTER_MESSAGE_STATE_SENT_NOT_ACKED
;
412 if (msg
->Message() != MSGCODE_START_BOOTLOADER
)
414 CLockObject
lock(m_mutex
);
415 m_messages
.erase(iEntryId
);
423 bool CCECAdapterMessageQueue::ProvidesExtendedResponse(void)
425 return m_com
&& m_com
->ProvidesExtendedResponse();