5d13368e50a3c569667ab0b812ed3d824b534c50
[deb_libcec.git] / src / lib / adapter / RPi / RPiCECAdapterCommunication.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 "env.h"
34
35 #if defined(HAVE_RPI_API)
36 #include "RPiCECAdapterCommunication.h"
37
38 extern "C" {
39 #include <bcm_host.h>
40 }
41
42 #include "lib/CECTypeUtils.h"
43 #include "lib/LibCEC.h"
44 #include "lib/platform/util/StdString.h"
45 #include "RPiCECAdapterMessageQueue.h"
46
47 using namespace CEC;
48 using namespace PLATFORM;
49
50 #define LIB_CEC m_callback->GetLib()
51
52 static bool g_bHostInited = false;
53
54 // callback for the RPi CEC service
55 void rpi_cec_callback(void *callback_data, uint32_t p0, uint32_t p1, uint32_t p2, uint32_t p3, uint32_t p4)
56 {
57 if (callback_data)
58 static_cast<CRPiCECAdapterCommunication *>(callback_data)->OnDataReceived(p0, p1, p2, p3, p4);
59 }
60
61 CRPiCECAdapterCommunication::CRPiCECAdapterCommunication(IAdapterCommunicationCallback *callback) :
62 IAdapterCommunication(callback),
63 m_logicalAddress(CECDEVICE_UNKNOWN),
64 m_bLogicalAddressChanged(false)
65 {
66 m_queue = new CRPiCECAdapterMessageQueue(this);
67 }
68
69 CRPiCECAdapterCommunication::~CRPiCECAdapterCommunication(void)
70 {
71 delete(m_queue);
72 Close();
73 }
74
75 const char *ToString(const VC_CEC_ERROR_T error)
76 {
77 switch(error)
78 {
79 case VC_CEC_SUCCESS:
80 return "success";
81 case VC_CEC_ERROR_NO_ACK:
82 return "no ack";
83 case VC_CEC_ERROR_SHUTDOWN:
84 return "shutdown";
85 case VC_CEC_ERROR_BUSY:
86 return "device is busy";
87 case VC_CEC_ERROR_NO_LA:
88 return "no logical address";
89 case VC_CEC_ERROR_NO_PA:
90 return "no physical address";
91 case VC_CEC_ERROR_NO_TOPO:
92 return "no topology";
93 case VC_CEC_ERROR_INVALID_FOLLOWER:
94 return "invalid follower";
95 case VC_CEC_ERROR_INVALID_ARGUMENT:
96 return "invalid arg";
97 default:
98 return "unknown";
99 }
100 }
101
102 bool CRPiCECAdapterCommunication::IsInitialised(void)
103 {
104 CLockObject lock(m_mutex);
105 return m_bInitialised;
106 }
107
108 void CRPiCECAdapterCommunication::OnDataReceived(uint32_t header, uint32_t p0, uint32_t p1, uint32_t p2, uint32_t p3)
109 {
110 VC_CEC_NOTIFY_T reason = (VC_CEC_NOTIFY_T)CEC_CB_REASON(header);
111
112 LIB_CEC->AddLog(CEC_LOG_DEBUG, "received data: header:%08X p0:%08X p1:%08X p2:%08X p3:%08X reason:%x", header, p0, p1, p2, p3, reason);
113
114 switch (reason)
115 {
116 case VC_CEC_RX:
117 // CEC data received
118 {
119 // translate into a VC_CEC_MESSAGE_T
120 VC_CEC_MESSAGE_T message;
121 vc_cec_param2message(header, p0, p1, p2, p3, &message);
122
123 // translate to a cec_command
124 cec_command command;
125 cec_command::Format(command,
126 (cec_logical_address)message.initiator,
127 (cec_logical_address)message.follower,
128 (cec_opcode)CEC_CB_OPCODE(p0));
129
130 // copy parameters
131 for (uint8_t iPtr = 1; iPtr < message.length; iPtr++)
132 command.PushBack(message.payload[iPtr]);
133
134 // send to libCEC
135 m_callback->OnCommandReceived(command);
136 }
137 break;
138 case VC_CEC_TX:
139 {
140 // handle response to a command that was sent earlier
141 m_queue->MessageReceived((cec_opcode)CEC_CB_OPCODE(p0), (cec_logical_address)CEC_CB_INITIATOR(p0), (cec_logical_address)CEC_CB_FOLLOWER(p0), CEC_CB_RC(header));
142 }
143 break;
144 case VC_CEC_BUTTON_PRESSED:
145 case VC_CEC_REMOTE_PRESSED:
146 {
147 // translate into a cec_command
148 cec_command command;
149 cec_command::Format(command,
150 (cec_logical_address)CEC_CB_INITIATOR(p0),
151 (cec_logical_address)CEC_CB_FOLLOWER(p0),
152 reason == VC_CEC_BUTTON_PRESSED ? CEC_OPCODE_USER_CONTROL_PRESSED : CEC_OPCODE_VENDOR_REMOTE_BUTTON_DOWN);
153 command.parameters.PushBack((uint8_t)CEC_CB_OPERAND1(p0));
154
155 // send to libCEC
156 m_callback->OnCommandReceived(command);
157 }
158 break;
159 case VC_CEC_BUTTON_RELEASE:
160 case VC_CEC_REMOTE_RELEASE:
161 {
162 // translate into a cec_command
163 cec_command command;
164 cec_command::Format(command,
165 (cec_logical_address)CEC_CB_INITIATOR(p0),
166 (cec_logical_address)CEC_CB_FOLLOWER(p0),
167 reason == VC_CEC_BUTTON_PRESSED ? CEC_OPCODE_USER_CONTROL_RELEASE : CEC_OPCODE_VENDOR_REMOTE_BUTTON_UP);
168 command.parameters.PushBack((uint8_t)CEC_CB_OPERAND1(p0));
169
170 // send to libCEC
171 m_callback->OnCommandReceived(command);
172 }
173 break;
174 case VC_CEC_LOGICAL_ADDR:
175 {
176 CLockObject lock(m_mutex);
177 if (CEC_CB_RC(header) == VCHIQ_SUCCESS)
178 {
179 m_bLogicalAddressChanged = true;
180 m_logicalAddress = (cec_logical_address)(p0 & 0xF);
181 LIB_CEC->AddLog(CEC_LOG_DEBUG, "logical address changed to %s (%x)", LIB_CEC->ToString(m_logicalAddress), m_logicalAddress);
182 }
183 else
184 {
185 m_logicalAddress = CECDEVICE_BROADCAST;
186 LIB_CEC->AddLog(CEC_LOG_DEBUG, "failed to change the logical address, reset to %s (%x)", LIB_CEC->ToString(m_logicalAddress), m_logicalAddress);
187 }
188 m_logicalAddressCondition.Signal();
189 }
190 break;
191 case VC_CEC_LOGICAL_ADDR_LOST:
192 {
193 // the logical address was taken by another device
194 cec_logical_address previousAddress = m_logicalAddress;
195 m_logicalAddress = CECDEVICE_UNKNOWN;
196
197 // notify libCEC that we lost our LA when the connection was initialised
198 if (m_bInitialised)
199 m_callback->HandleLogicalAddressLost(previousAddress);
200 }
201 break;
202 case VC_CEC_TOPOLOGY:
203 break;
204 default:
205 LIB_CEC->AddLog(CEC_LOG_DEBUG, "ignoring unknown reason %x", reason);
206 break;
207 }
208 }
209
210 int CRPiCECAdapterCommunication::InitHostCEC(void)
211 {
212 VCHIQ_INSTANCE_T vchiq_instance;
213 int iResult;
214
215 if ((iResult = vchiq_initialise(&vchiq_instance)) != VCHIQ_SUCCESS)
216 {
217 LIB_CEC->AddLog(CEC_LOG_ERROR, "%s - vchiq_initialise failed (%d)", __FUNCTION__, iResult);
218 CStdString strError;
219 strError.Format("%s - vchiq_initialise failed (%d)", __FUNCTION__, iResult);
220 m_strError = strError;
221 return iResult;
222 }
223 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - vchiq_initialise succeeded", __FUNCTION__);
224
225 if ((iResult = vchi_initialise(&m_vchi_instance)) != VCHIQ_SUCCESS)
226 {
227 LIB_CEC->AddLog(CEC_LOG_ERROR, "%s - vchi_initialise failed (%d)", __FUNCTION__, iResult);
228 CStdString strError;
229 strError.Format("%s - vchi_initialise failed (%d)", __FUNCTION__, iResult);
230 m_strError = strError;
231 return iResult;
232 }
233 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - vchi_initialise succeeded", __FUNCTION__);
234
235 vchiq_instance = (VCHIQ_INSTANCE_T)m_vchi_instance;
236
237 m_vchi_connection = vchi_create_connection(single_get_func_table(),
238 vchi_mphi_message_driver_func_table());
239
240 if ((iResult = vchi_connect(&m_vchi_connection, 1, m_vchi_instance)) != VCHIQ_SUCCESS)
241 {
242 LIB_CEC->AddLog(CEC_LOG_ERROR, "%s - vchi_connect failed (%d)", __FUNCTION__, iResult);
243 CStdString strError;
244 strError.Format("%s - vchi_connect failed (%d)", __FUNCTION__, iResult);
245 m_strError = strError;
246 return iResult;
247 }
248 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - vchi_connect succeeded", __FUNCTION__);
249
250 return VCHIQ_SUCCESS;
251 }
252
253 bool CRPiCECAdapterCommunication::Open(uint32_t iTimeoutMs /* = CEC_DEFAULT_CONNECT_TIMEOUT */, bool UNUSED(bSkipChecks) /* = false */, bool bStartListening)
254 {
255 Close();
256
257 if (InitHostCEC() != VCHIQ_SUCCESS)
258 return false;
259
260 if (bStartListening)
261 {
262 // enable passive mode
263 vc_cec_set_passive(true);
264
265 // register the callback
266 vc_cec_register_callback(((CECSERVICE_CALLBACK_T)rpi_cec_callback), (void*)this);
267
268 // release previous LA
269 vc_cec_release_logical_address();
270 if (!m_logicalAddressCondition.Wait(m_mutex, m_bLogicalAddressChanged, iTimeoutMs))
271 {
272 LIB_CEC->AddLog(CEC_LOG_ERROR, "failed to release the previous LA");
273 return false;
274 }
275
276 // register LA "freeuse"
277 if (RegisterLogicalAddress(CECDEVICE_FREEUSE))
278 {
279 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - vc_cec initialised", __FUNCTION__);
280 CLockObject lock(m_mutex);
281 m_bInitialised = true;
282 }
283 else
284 LIB_CEC->AddLog(CEC_LOG_ERROR, "%s - vc_cec could not be initialised", __FUNCTION__);
285 }
286
287 return true;
288 }
289
290 uint16_t CRPiCECAdapterCommunication::GetPhysicalAddress(void)
291 {
292 uint16_t iPA(CEC_INVALID_PHYSICAL_ADDRESS);
293 if (!IsInitialised())
294 return iPA;
295
296 if (vc_cec_get_physical_address(&iPA) == VCHIQ_SUCCESS)
297 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - physical address = %04x", __FUNCTION__, iPA);
298 else
299 {
300 LIB_CEC->AddLog(CEC_LOG_WARNING, "%s - failed to get the physical address", __FUNCTION__);
301 iPA = CEC_INVALID_PHYSICAL_ADDRESS;
302 }
303
304 return iPA;
305 }
306
307 void CRPiCECAdapterCommunication::Close(void)
308 {
309 {
310 CLockObject lock(m_mutex);
311 if (m_bInitialised)
312 m_bInitialised = false;
313 else
314 return;
315 }
316 UnregisterLogicalAddress();
317
318 // disable passive mode
319 vc_cec_set_passive(false);
320
321 if (!g_bHostInited)
322 {
323 g_bHostInited = false;
324 bcm_host_deinit();
325 }
326 }
327
328 std::string CRPiCECAdapterCommunication::GetError(void) const
329 {
330 std::string strError(m_strError);
331 return strError;
332 }
333
334 cec_adapter_message_state CRPiCECAdapterCommunication::Write(const cec_command &data, bool &UNUSED(bRetry), uint8_t UNUSED(iLineTimeout), bool bIsReply)
335 {
336 // ensure that the source LA is registered
337 if (!RegisterLogicalAddress(data.initiator))
338 {
339 LIB_CEC->AddLog(CEC_LOG_DEBUG, "failed to register logical address %s (%X)", CCECTypeUtils::ToString(data.initiator), data.initiator);
340 return (data.initiator == data.destination) ? ADAPTER_MESSAGE_STATE_SENT_NOT_ACKED : ADAPTER_MESSAGE_STATE_ERROR;
341 }
342
343 if (!data.opcode_set && data.initiator == data.destination)
344 {
345 // registration of the logical address would have failed
346 return ADAPTER_MESSAGE_STATE_SENT_NOT_ACKED;
347 }
348
349 return m_queue->Write(data, bIsReply) ? ADAPTER_MESSAGE_STATE_SENT_ACKED : ADAPTER_MESSAGE_STATE_SENT_NOT_ACKED;
350 }
351
352 uint16_t CRPiCECAdapterCommunication::GetFirmwareVersion(void)
353 {
354 return VC_CECSERVICE_VER;
355 }
356
357 cec_logical_address CRPiCECAdapterCommunication::GetLogicalAddress(void)
358 {
359 {
360 CLockObject lock(m_mutex);
361 if (m_logicalAddress != CECDEVICE_UNKNOWN)
362 return m_logicalAddress;
363 }
364
365 CEC_AllDevices_T address;
366 return (vc_cec_get_logical_address(&address) == VCHIQ_SUCCESS) ?
367 (cec_logical_address)address : CECDEVICE_UNKNOWN;
368 }
369
370 bool CRPiCECAdapterCommunication::UnregisterLogicalAddress(void)
371 {
372 CLockObject lock(m_mutex);
373 if (m_logicalAddress == CECDEVICE_UNKNOWN ||
374 m_logicalAddress == CECDEVICE_BROADCAST)
375 return true;
376
377 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - releasing previous logical address", __FUNCTION__);
378 m_bLogicalAddressChanged = false;
379
380 vc_cec_release_logical_address();
381
382 return m_logicalAddressCondition.Wait(m_mutex, m_bLogicalAddressChanged);
383 }
384
385 bool CRPiCECAdapterCommunication::RegisterLogicalAddress(const cec_logical_address address)
386 {
387 {
388 CLockObject lock(m_mutex);
389 if (m_logicalAddress == address)
390 return true;
391 }
392
393 if (!UnregisterLogicalAddress())
394 return false;
395
396 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - registering address %x", __FUNCTION__, address);
397
398 CLockObject lock(m_mutex);
399 m_bLogicalAddressChanged = false;
400 vc_cec_poll_address((CEC_AllDevices_T)address);
401
402 // register the new LA
403 int iRetval = vc_cec_set_logical_address((CEC_AllDevices_T)address, (CEC_DEVICE_TYPE_T)CCECTypeUtils::GetType(address), CEC_VENDOR_ID_BROADCOM);
404 if (iRetval != VCHIQ_SUCCESS)
405 {
406 LIB_CEC->AddLog(CEC_LOG_ERROR, "%s - vc_cec_set_logical_address(%X) returned %s (%d)", __FUNCTION__, address, ToString((VC_CEC_ERROR_T)iRetval), iRetval);
407 return false;
408 }
409
410 return m_logicalAddressCondition.Wait(m_mutex, m_bLogicalAddressChanged);
411 }
412
413 cec_logical_addresses CRPiCECAdapterCommunication::GetLogicalAddresses(void)
414 {
415 cec_logical_addresses addresses; addresses.Clear();
416 cec_logical_address current = GetLogicalAddress();
417 if (current != CECDEVICE_UNKNOWN)
418 addresses.Set(current);
419
420 return addresses;
421 }
422
423 bool CRPiCECAdapterCommunication::SetLogicalAddresses(const cec_logical_addresses &addresses)
424 {
425 // the current generation RPi only supports 1 LA, so just ensure that the primary address is registered
426 return SupportsSourceLogicalAddress(addresses.primary) &&
427 RegisterLogicalAddress(addresses.primary);
428 }
429
430 void CRPiCECAdapterCommunication::InitHost(void)
431 {
432 if (!g_bHostInited)
433 {
434 g_bHostInited = true;
435 bcm_host_init();
436 }
437 }
438
439 #endif