Commit | Line | Data |
---|---|---|
a75e3a5a LOK |
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 "USBCECAdapterCommands.h" | |
34 | #include "../LibCEC.h" | |
35 | #include "../CECProcessor.h" | |
36 | ||
37 | using namespace CEC; | |
38 | using namespace PLATFORM; | |
39 | ||
7c5c5bf4 LOK |
40 | CUSBCECAdapterCommands::CUSBCECAdapterCommands(CUSBCECAdapterCommunication *comm) : |
41 | m_comm(comm), | |
42 | m_bSettingsRetrieved(false), | |
43 | m_bSettingAutoEnabled(false), | |
44 | m_settingCecVersion(CEC_VERSION_UNKNOWN), | |
45 | m_iSettingLAMask(0), | |
46 | m_bNeedsWrite(false) | |
47 | { | |
48 | m_persistedConfiguration.Clear(); | |
49 | } | |
50 | ||
a75e3a5a LOK |
51 | cec_datapacket CUSBCECAdapterCommands::RequestSetting(cec_adapter_messagecode msgCode) |
52 | { | |
53 | cec_datapacket retVal; | |
54 | retVal.Clear(); | |
55 | ||
56 | CCECAdapterMessage params; | |
57 | CCECAdapterMessage *message = m_comm->SendCommand(msgCode, params); | |
58 | if (message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED) | |
59 | { | |
60 | retVal = message->response; | |
61 | retVal.Shift(2); // shift out start and msgcode | |
62 | retVal.size -= 1; // remove end | |
63 | } | |
64 | delete message; | |
65 | return retVal; | |
66 | } | |
67 | ||
68 | uint16_t CUSBCECAdapterCommands::RequestFirmwareVersion(void) | |
69 | { | |
7c5c5bf4 | 70 | m_persistedConfiguration.iFirmwareVersion = CEC_FW_VERSION_UNKNOWN; |
a75e3a5a LOK |
71 | unsigned int iFwVersionTry(0); |
72 | ||
7c5c5bf4 | 73 | while (m_persistedConfiguration.iFirmwareVersion == CEC_FW_VERSION_UNKNOWN && iFwVersionTry++ < 3) |
a75e3a5a LOK |
74 | { |
75 | CLibCEC::AddLog(CEC_LOG_DEBUG, "requesting the firmware version"); | |
76 | cec_datapacket response = RequestSetting(MSGCODE_FIRMWARE_VERSION); | |
77 | if (response.size == 2) | |
7c5c5bf4 | 78 | m_persistedConfiguration.iFirmwareVersion = (response[0] << 8 | response[1]); |
a75e3a5a LOK |
79 | else |
80 | { | |
81 | CLibCEC::AddLog(CEC_LOG_WARNING, "the adapter did not respond with a correct firmware version (try %d)", iFwVersionTry); | |
82 | CEvent::Sleep(500); | |
83 | } | |
84 | } | |
85 | ||
7c5c5bf4 | 86 | if (m_persistedConfiguration.iFirmwareVersion == CEC_FW_VERSION_UNKNOWN) |
a75e3a5a LOK |
87 | { |
88 | CLibCEC::AddLog(CEC_LOG_DEBUG, "defaulting to firmware version 1"); | |
7c5c5bf4 | 89 | m_persistedConfiguration.iFirmwareVersion = 1; |
a75e3a5a LOK |
90 | } |
91 | ||
7c5c5bf4 | 92 | return m_persistedConfiguration.iFirmwareVersion; |
a75e3a5a LOK |
93 | } |
94 | ||
7c5c5bf4 | 95 | bool CUSBCECAdapterCommands::RequestSettingAutoEnabled(void) |
a75e3a5a LOK |
96 | { |
97 | CLibCEC::AddLog(CEC_LOG_DEBUG, "requesting autonomous mode setting"); | |
98 | ||
99 | cec_datapacket response = RequestSetting(MSGCODE_GET_AUTO_ENABLED); | |
100 | if (response.size == 1) | |
101 | { | |
7c5c5bf4 | 102 | m_bSettingAutoEnabled = response[0] == 1; |
95acc41b | 103 | CLibCEC::AddLog(CEC_LOG_DEBUG, "using persisted autonomous mode setting: '%s'", m_bSettingAutoEnabled ? "enabled" : "disabled"); |
a75e3a5a LOK |
104 | return true; |
105 | } | |
106 | return false; | |
107 | } | |
108 | ||
7c5c5bf4 | 109 | bool CUSBCECAdapterCommands::RequestSettingCECVersion(void) |
a75e3a5a LOK |
110 | { |
111 | CLibCEC::AddLog(CEC_LOG_DEBUG, "requesting CEC version setting"); | |
112 | ||
113 | cec_datapacket response = RequestSetting(MSGCODE_GET_HDMI_VERSION); | |
114 | if (response.size == 1) | |
115 | { | |
7c5c5bf4 | 116 | m_settingCecVersion = (cec_version)response[0]; |
95acc41b | 117 | CLibCEC::AddLog(CEC_LOG_DEBUG, "using persisted CEC version setting: '%s'", CLibCEC::GetInstance()->ToString(m_settingCecVersion)); |
a75e3a5a LOK |
118 | return true; |
119 | } | |
120 | return false; | |
121 | } | |
122 | ||
7c5c5bf4 | 123 | bool CUSBCECAdapterCommands::RequestSettingDefaultLogicalAddress(void) |
a75e3a5a LOK |
124 | { |
125 | CLibCEC::AddLog(CEC_LOG_DEBUG, "requesting default logical address setting"); | |
126 | ||
127 | cec_datapacket response = RequestSetting(MSGCODE_GET_DEFAULT_LOGICAL_ADDRESS); | |
128 | if (response.size == 1) | |
129 | { | |
7c5c5bf4 | 130 | m_persistedConfiguration.logicalAddresses.primary = (cec_logical_address)response[0]; |
95acc41b | 131 | CLibCEC::AddLog(CEC_LOG_DEBUG, "using persisted logical address setting: '%s'", CLibCEC::GetInstance()->ToString(m_persistedConfiguration.logicalAddresses.primary)); |
a75e3a5a LOK |
132 | return true; |
133 | } | |
134 | return false; | |
135 | } | |
136 | ||
7c5c5bf4 | 137 | bool CUSBCECAdapterCommands::RequestSettingDeviceType(void) |
a75e3a5a LOK |
138 | { |
139 | CLibCEC::AddLog(CEC_LOG_DEBUG, "requesting device type setting"); | |
7c5c5bf4 | 140 | m_persistedConfiguration.deviceTypes.Clear(); |
a75e3a5a LOK |
141 | |
142 | cec_datapacket response = RequestSetting(MSGCODE_GET_DEVICE_TYPE); | |
143 | if (response.size == 1) | |
144 | { | |
7c5c5bf4 | 145 | m_persistedConfiguration.deviceTypes.Add((cec_device_type)response[0]); |
95acc41b | 146 | CLibCEC::AddLog(CEC_LOG_DEBUG, "using persisted device type setting: '%s'", CLibCEC::GetInstance()->ToString((cec_device_type)response[0])); |
a75e3a5a LOK |
147 | return true; |
148 | } | |
7c5c5bf4 | 149 | CLibCEC::AddLog(CEC_LOG_DEBUG, "no persisted device type setting"); |
a75e3a5a LOK |
150 | return false; |
151 | } | |
152 | ||
7c5c5bf4 | 153 | bool CUSBCECAdapterCommands::RequestSettingLogicalAddressMask(void) |
a75e3a5a LOK |
154 | { |
155 | CLibCEC::AddLog(CEC_LOG_DEBUG, "requesting logical address mask setting"); | |
156 | ||
157 | cec_datapacket response = RequestSetting(MSGCODE_GET_LOGICAL_ADDRESS_MASK); | |
158 | if (response.size == 2) | |
159 | { | |
7c5c5bf4 | 160 | m_iSettingLAMask = ((uint16_t)response[0] << 8) | ((uint16_t)response[1]); |
95acc41b | 161 | CLibCEC::AddLog(CEC_LOG_DEBUG, "using persisted logical address mask setting: '%x'", m_iSettingLAMask); |
a75e3a5a LOK |
162 | return true; |
163 | } | |
164 | return false; | |
165 | } | |
166 | ||
7c5c5bf4 | 167 | bool CUSBCECAdapterCommands::RequestSettingOSDName(void) |
a75e3a5a LOK |
168 | { |
169 | CLibCEC::AddLog(CEC_LOG_DEBUG, "requesting OSD name setting"); | |
170 | ||
7c5c5bf4 | 171 | memset(m_persistedConfiguration.strDeviceName, 0, 13); |
a75e3a5a LOK |
172 | cec_datapacket response = RequestSetting(MSGCODE_GET_OSD_NAME); |
173 | if (response.size == 0) | |
7c5c5bf4 LOK |
174 | { |
175 | CLibCEC::AddLog(CEC_LOG_DEBUG, "no persisted device name setting"); | |
a75e3a5a | 176 | return false; |
7c5c5bf4 | 177 | } |
a75e3a5a LOK |
178 | |
179 | char buf[14]; | |
180 | for (uint8_t iPtr = 0; iPtr < response.size && iPtr < 13; iPtr++) | |
181 | buf[iPtr] = (char)response[iPtr]; | |
182 | buf[response.size] = 0; | |
183 | ||
7c5c5bf4 | 184 | snprintf(m_persistedConfiguration.strDeviceName, 13, "%s", buf); |
95acc41b | 185 | CLibCEC::AddLog(CEC_LOG_DEBUG, "using persisted device name setting: '%s'", buf); |
a75e3a5a LOK |
186 | return true; |
187 | } | |
188 | ||
7c5c5bf4 | 189 | bool CUSBCECAdapterCommands::RequestSettingPhysicalAddress(void) |
a75e3a5a LOK |
190 | { |
191 | CLibCEC::AddLog(CEC_LOG_DEBUG, "requesting physical address setting"); | |
192 | ||
193 | cec_datapacket response = RequestSetting(MSGCODE_GET_PHYSICAL_ADDRESS); | |
194 | if (response.size == 2) | |
195 | { | |
7c5c5bf4 | 196 | m_persistedConfiguration.iPhysicalAddress = ((uint16_t)response[0] << 8) | ((uint16_t)response[1]); |
95acc41b | 197 | CLibCEC::AddLog(CEC_LOG_DEBUG, "using persisted physical address setting: '%4x'", m_persistedConfiguration.iPhysicalAddress); |
a75e3a5a LOK |
198 | return true; |
199 | } | |
7c5c5bf4 | 200 | CLibCEC::AddLog(CEC_LOG_DEBUG, "no persisted physical address setting"); |
a75e3a5a LOK |
201 | return false; |
202 | } | |
203 | ||
204 | bool CUSBCECAdapterCommands::SetSettingAutoEnabled(bool enabled) | |
205 | { | |
7c5c5bf4 LOK |
206 | bool bReturn(true); |
207 | ||
208 | /* check whether this value was changed */ | |
209 | if (m_bSettingAutoEnabled == enabled) | |
210 | { | |
211 | CLibCEC::AddLog(CEC_LOG_DEBUG, "autonomous mode setting unchanged (%s)", enabled ? "on" : "off"); | |
212 | return bReturn; | |
213 | } | |
214 | ||
215 | m_bNeedsWrite = true; | |
a75e3a5a LOK |
216 | CLibCEC::AddLog(CEC_LOG_DEBUG, "turning autonomous mode %s", enabled ? "on" : "off"); |
217 | ||
218 | CCECAdapterMessage params; | |
219 | params.PushEscaped(enabled ? 1 : 0); | |
220 | CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_SET_AUTO_ENABLED, params); | |
7c5c5bf4 | 221 | bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED; |
a75e3a5a | 222 | delete message; |
7c5c5bf4 LOK |
223 | |
224 | if (bReturn) | |
225 | m_bSettingAutoEnabled = enabled; | |
226 | ||
a75e3a5a LOK |
227 | return bReturn; |
228 | } | |
229 | ||
230 | bool CUSBCECAdapterCommands::SetSettingDeviceType(cec_device_type type) | |
231 | { | |
7c5c5bf4 LOK |
232 | bool bReturn(true); |
233 | ||
234 | /* check whether this value was changed */ | |
235 | if (m_persistedConfiguration.deviceTypes.types[0] == type) | |
236 | { | |
237 | CLibCEC::AddLog(CEC_LOG_DEBUG, "device type setting unchanged (%X)", (uint8_t)type); | |
238 | return bReturn; | |
239 | } | |
240 | ||
241 | m_bNeedsWrite = true; | |
a6157840 | 242 | CLibCEC::AddLog(CEC_LOG_DEBUG, "setting the device type to %X (previous: %X)", (uint8_t)type, (uint8_t)m_persistedConfiguration.deviceTypes.types[0]); |
a75e3a5a LOK |
243 | |
244 | CCECAdapterMessage params; | |
245 | params.PushEscaped((uint8_t)type); | |
246 | CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_SET_DEVICE_TYPE, params); | |
7c5c5bf4 | 247 | bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED; |
a75e3a5a | 248 | delete message; |
7c5c5bf4 | 249 | |
a75e3a5a LOK |
250 | return bReturn; |
251 | } | |
252 | ||
253 | bool CUSBCECAdapterCommands::SetSettingDefaultLogicalAddress(cec_logical_address address) | |
254 | { | |
7c5c5bf4 LOK |
255 | bool bReturn(true); |
256 | ||
257 | /* check whether this value was changed */ | |
258 | if (m_persistedConfiguration.logicalAddresses.primary == address) | |
259 | { | |
260 | CLibCEC::AddLog(CEC_LOG_DEBUG, "logical address setting unchanged (%X)", (uint8_t)address); | |
261 | return bReturn; | |
262 | } | |
263 | ||
264 | m_bNeedsWrite = true; | |
a6157840 | 265 | CLibCEC::AddLog(CEC_LOG_DEBUG, "setting the default logical address to %X (previous: %X)", (uint8_t)address, (uint8_t)m_persistedConfiguration.logicalAddresses.primary); |
a75e3a5a LOK |
266 | |
267 | CCECAdapterMessage params; | |
268 | params.PushEscaped((uint8_t)address); | |
269 | CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_SET_DEFAULT_LOGICAL_ADDRESS, params); | |
7c5c5bf4 | 270 | bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED; |
a75e3a5a | 271 | delete message; |
7c5c5bf4 LOK |
272 | |
273 | if (bReturn) | |
274 | m_persistedConfiguration.logicalAddresses.primary = address; | |
275 | ||
a75e3a5a LOK |
276 | return bReturn; |
277 | } | |
278 | ||
279 | bool CUSBCECAdapterCommands::SetSettingLogicalAddressMask(uint16_t iMask) | |
280 | { | |
7c5c5bf4 LOK |
281 | bool bReturn(true); |
282 | ||
283 | /* check whether this value was changed */ | |
284 | if (m_iSettingLAMask == iMask) | |
285 | { | |
286 | CLibCEC::AddLog(CEC_LOG_DEBUG, "logical address mask setting unchanged (%2X)", iMask); | |
287 | return bReturn; | |
288 | } | |
289 | ||
290 | m_bNeedsWrite = true; | |
a6157840 | 291 | CLibCEC::AddLog(CEC_LOG_DEBUG, "setting the logical address mask to %2X (previous: %2X)", iMask, m_iSettingLAMask); |
a75e3a5a LOK |
292 | |
293 | CCECAdapterMessage params; | |
294 | params.PushEscaped(iMask >> 8); | |
295 | params.PushEscaped((uint8_t)iMask); | |
296 | CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_SET_LOGICAL_ADDRESS_MASK, params); | |
7c5c5bf4 | 297 | bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED; |
a75e3a5a | 298 | delete message; |
7c5c5bf4 LOK |
299 | |
300 | if (bReturn) | |
301 | m_iSettingLAMask = iMask; | |
302 | ||
a75e3a5a LOK |
303 | return bReturn; |
304 | } | |
305 | ||
306 | bool CUSBCECAdapterCommands::SetSettingPhysicalAddress(uint16_t iPhysicalAddress) | |
307 | { | |
7c5c5bf4 LOK |
308 | bool bReturn(true); |
309 | ||
310 | /* check whether this value was changed */ | |
311 | if (m_persistedConfiguration.iPhysicalAddress == iPhysicalAddress) | |
312 | { | |
e35aa7ba | 313 | CLibCEC::AddLog(CEC_LOG_DEBUG, "physical address setting unchanged (%04X)", iPhysicalAddress); |
7c5c5bf4 LOK |
314 | return bReturn; |
315 | } | |
316 | ||
317 | m_bNeedsWrite = true; | |
a6157840 | 318 | CLibCEC::AddLog(CEC_LOG_DEBUG, "setting the physical address to %04X (previous: %04X)", iPhysicalAddress, m_persistedConfiguration.iPhysicalAddress); |
a75e3a5a LOK |
319 | |
320 | CCECAdapterMessage params; | |
321 | params.PushEscaped(iPhysicalAddress >> 8); | |
322 | params.PushEscaped((uint8_t)iPhysicalAddress); | |
323 | CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_SET_PHYSICAL_ADDRESS, params); | |
7c5c5bf4 | 324 | bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED; |
a75e3a5a | 325 | delete message; |
7c5c5bf4 LOK |
326 | |
327 | if (bReturn) | |
328 | m_persistedConfiguration.iPhysicalAddress = iPhysicalAddress; | |
329 | ||
a75e3a5a LOK |
330 | return bReturn; |
331 | } | |
332 | ||
333 | bool CUSBCECAdapterCommands::SetSettingCECVersion(cec_version version) | |
334 | { | |
7c5c5bf4 LOK |
335 | bool bReturn(true); |
336 | ||
337 | /* check whether this value was changed */ | |
338 | if (m_settingCecVersion == version) | |
339 | { | |
340 | CLibCEC::AddLog(CEC_LOG_DEBUG, "CEC version setting unchanged (%s)", CLibCEC::GetInstance()->ToString(version)); | |
341 | return bReturn; | |
342 | } | |
343 | ||
344 | m_bNeedsWrite = true; | |
a6157840 | 345 | CLibCEC::AddLog(CEC_LOG_DEBUG, "setting the CEC version to %s (previous: %s)", CLibCEC::GetInstance()->ToString(version), CLibCEC::GetInstance()->ToString(m_settingCecVersion)); |
a75e3a5a LOK |
346 | |
347 | CCECAdapterMessage params; | |
348 | params.PushEscaped((uint8_t)version); | |
349 | CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_SET_HDMI_VERSION, params); | |
7c5c5bf4 | 350 | bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED; |
a75e3a5a | 351 | delete message; |
7c5c5bf4 LOK |
352 | |
353 | if (bReturn) | |
354 | m_settingCecVersion = version; | |
355 | ||
a75e3a5a LOK |
356 | return bReturn; |
357 | } | |
358 | ||
359 | bool CUSBCECAdapterCommands::SetSettingOSDName(const char *strOSDName) | |
360 | { | |
7c5c5bf4 LOK |
361 | bool bReturn(true); |
362 | ||
363 | /* check whether this value was changed */ | |
364 | if (!strcmp(m_persistedConfiguration.strDeviceName, strOSDName)) | |
365 | { | |
366 | CLibCEC::AddLog(CEC_LOG_DEBUG, "OSD name setting unchanged (%s)", strOSDName); | |
367 | return bReturn; | |
368 | } | |
369 | ||
a6157840 | 370 | CLibCEC::AddLog(CEC_LOG_DEBUG, "setting the OSD name to %s (previous: %s)", strOSDName, m_persistedConfiguration.strDeviceName); |
a75e3a5a LOK |
371 | |
372 | CCECAdapterMessage params; | |
373 | for (size_t iPtr = 0; iPtr < strlen(strOSDName); iPtr++) | |
374 | params.PushEscaped(strOSDName[iPtr]); | |
375 | CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_SET_OSD_NAME, params); | |
7c5c5bf4 | 376 | bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED; |
a75e3a5a | 377 | delete message; |
7c5c5bf4 LOK |
378 | |
379 | if (bReturn) | |
380 | snprintf(m_persistedConfiguration.strDeviceName, 13, "%s", strOSDName); | |
381 | ||
a75e3a5a LOK |
382 | return bReturn; |
383 | } | |
384 | ||
385 | bool CUSBCECAdapterCommands::WriteEEPROM(void) | |
386 | { | |
7c5c5bf4 LOK |
387 | if (!m_bNeedsWrite) |
388 | return true; | |
389 | ||
a75e3a5a LOK |
390 | CLibCEC::AddLog(CEC_LOG_DEBUG, "writing settings in the EEPROM"); |
391 | ||
392 | CCECAdapterMessage params; | |
393 | CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_WRITE_EEPROM, params); | |
7c5c5bf4 | 394 | m_bNeedsWrite = !(message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED); |
a75e3a5a | 395 | delete message; |
7c5c5bf4 | 396 | return m_bNeedsWrite; |
a75e3a5a LOK |
397 | } |
398 | ||
399 | bool CUSBCECAdapterCommands::PersistConfiguration(libcec_configuration *configuration) | |
400 | { | |
7c5c5bf4 LOK |
401 | if (m_persistedConfiguration.iFirmwareVersion < 2) |
402 | return false; | |
403 | ||
404 | if (!RequestSettings()) | |
a75e3a5a LOK |
405 | return false; |
406 | ||
407 | bool bReturn(true); | |
408 | bReturn &= SetSettingAutoEnabled(true); | |
409 | bReturn &= SetSettingDeviceType(CLibCEC::GetType(configuration->logicalAddresses.primary)); | |
410 | bReturn &= SetSettingDefaultLogicalAddress(configuration->logicalAddresses.primary); | |
411 | bReturn &= SetSettingLogicalAddressMask(CLibCEC::GetMaskForType(configuration->logicalAddresses.primary)); | |
412 | bReturn &= SetSettingPhysicalAddress(configuration->iPhysicalAddress); | |
413 | bReturn &= SetSettingCECVersion(CEC_VERSION_1_3A); | |
414 | bReturn &= SetSettingOSDName(configuration->strDeviceName); | |
7c5c5bf4 | 415 | bReturn &= WriteEEPROM(); |
a75e3a5a LOK |
416 | return bReturn; |
417 | } | |
418 | ||
7c5c5bf4 | 419 | bool CUSBCECAdapterCommands::RequestSettings(void) |
a75e3a5a | 420 | { |
7c5c5bf4 | 421 | if (m_persistedConfiguration.iFirmwareVersion < 2) |
a75e3a5a | 422 | { |
4c70b3b6 | 423 | CLibCEC::AddLog(CEC_LOG_DEBUG, "%s - firmware version %d does not have any eeprom settings", __FUNCTION__, m_persistedConfiguration.iFirmwareVersion); |
7c5c5bf4 LOK |
424 | // settings can only be persisted with firmware v2+ |
425 | return false; | |
a75e3a5a LOK |
426 | } |
427 | ||
4c70b3b6 | 428 | if (m_bSettingsRetrieved) |
7c5c5bf4 | 429 | return true; |
a75e3a5a | 430 | |
7c5c5bf4 LOK |
431 | bool bReturn(true); |
432 | bReturn &= RequestSettingAutoEnabled(); | |
433 | bReturn &= RequestSettingCECVersion(); | |
434 | bReturn &= RequestSettingDefaultLogicalAddress(); | |
435 | bReturn &= RequestSettingDeviceType(); | |
436 | bReturn &= RequestSettingLogicalAddressMask(); | |
437 | bReturn &= RequestSettingOSDName(); | |
438 | bReturn &= RequestSettingPhysicalAddress(); | |
a75e3a5a LOK |
439 | |
440 | // don't read the following settings: | |
441 | // - auto enabled (always enabled) | |
442 | // - default logical address (autodetected) | |
443 | // - logical address mask (autodetected) | |
444 | // - CEC version (1.3a) | |
445 | ||
446 | // TODO to be added to the firmware: | |
447 | // - base device (4 bits) | |
448 | // - HDMI port number (4 bits) | |
449 | // - TV vendor id (12 bits) | |
450 | // - wake devices (8 bits) | |
451 | // - standby devices (8 bits) | |
452 | // - use TV menu language (1 bit) | |
453 | // - activate source (1 bit) | |
454 | // - power off screensaver (1 bit) | |
455 | // - power off on standby (1 bit) | |
456 | // - send inactive source (1 bit) | |
7c5c5bf4 LOK |
457 | |
458 | m_bSettingsRetrieved = true; | |
459 | ||
a75e3a5a LOK |
460 | return bReturn; |
461 | } | |
462 | ||
7c5c5bf4 LOK |
463 | bool CUSBCECAdapterCommands::GetConfiguration(libcec_configuration *configuration) |
464 | { | |
465 | // get the settings from the eeprom if needed | |
466 | if (!RequestSettings()) | |
467 | return false; | |
468 | ||
469 | // copy the settings | |
470 | configuration->iFirmwareVersion = m_persistedConfiguration.iFirmwareVersion; | |
471 | configuration->deviceTypes = m_persistedConfiguration.deviceTypes; | |
472 | configuration->iPhysicalAddress = m_persistedConfiguration.iPhysicalAddress; | |
473 | snprintf(configuration->strDeviceName, 13, "%s", m_persistedConfiguration.strDeviceName); | |
474 | ||
475 | return true; | |
476 | } | |
477 | ||
a75e3a5a LOK |
478 | bool CUSBCECAdapterCommands::PingAdapter(void) |
479 | { | |
480 | CLibCEC::AddLog(CEC_LOG_DEBUG, "sending ping"); | |
481 | ||
482 | CCECAdapterMessage params; | |
483 | CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_PING, params); | |
484 | bool bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED; | |
485 | delete message; | |
486 | return bReturn; | |
487 | } | |
488 | ||
489 | bool CUSBCECAdapterCommands::SetAckMask(uint16_t iMask) | |
490 | { | |
491 | CLibCEC::AddLog(CEC_LOG_DEBUG, "setting ackmask to %2x", iMask); | |
492 | ||
493 | CCECAdapterMessage params; | |
494 | params.PushEscaped(iMask >> 8); | |
495 | params.PushEscaped((uint8_t)iMask); | |
496 | CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_SET_ACK_MASK, params); | |
497 | bool bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED; | |
498 | delete message; | |
499 | return bReturn; | |
500 | } | |
501 | ||
502 | bool CUSBCECAdapterCommands::StartBootloader(void) | |
503 | { | |
504 | CLibCEC::AddLog(CEC_LOG_DEBUG, "starting the bootloader"); | |
505 | ||
506 | CCECAdapterMessage params; | |
507 | CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_START_BOOTLOADER, params); | |
508 | bool bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED; | |
509 | delete message; | |
510 | return bReturn; | |
511 | } | |
512 | ||
513 | bool CUSBCECAdapterCommands::SetLineTimeout(uint8_t iTimeout) | |
514 | { | |
515 | CLibCEC::AddLog(CEC_LOG_DEBUG, "setting the line timeout to %d", iTimeout); | |
516 | CCECAdapterMessage params; | |
517 | params.PushEscaped(iTimeout); | |
518 | CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_TRANSMIT_IDLETIME, params); | |
519 | bool bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED; | |
520 | delete message; | |
521 | return bReturn; | |
522 | } | |
523 | ||
524 | bool CUSBCECAdapterCommands::SetControlledMode(bool controlled) | |
525 | { | |
526 | CLibCEC::AddLog(CEC_LOG_DEBUG, "turning controlled mode %s", controlled ? "on" : "off"); | |
527 | ||
528 | CCECAdapterMessage params; | |
529 | params.PushEscaped(controlled ? 1 : 0); | |
530 | CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_SET_CONTROLLED, params); | |
531 | bool bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED; | |
532 | delete message; | |
533 | return bReturn; | |
534 | } |