updated copyright messages for 2013
[deb_libcec.git] / src / lib / implementations / SLCommandHandler.cpp
CommitLineData
e9de9629
LOK
1/*
2 * This file is part of the libCEC(R) library.
3 *
16f47961 4 * libCEC(R) is Copyright (C) 2011-2013 Pulse-Eight Limited. All rights reserved.
e9de9629
LOK
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
2b44051c 33#include "env.h"
e9de9629 34#include "SLCommandHandler.h"
2b44051c
LOK
35
36#include "lib/platform/util/timeutils.h"
37#include "lib/devices/CECBusDevice.h"
38#include "lib/devices/CECPlaybackDevice.h"
39#include "lib/CECProcessor.h"
40#include "lib/LibCEC.h"
e9de9629
LOK
41
42using namespace CEC;
cc1b9bc4 43using namespace PLATFORM;
e9de9629 44
0d4c3a7b
LOK
45#define SL_COMMAND_UNKNOWN_01 0x01
46#define SL_COMMAND_UNKNOWN_02 0x02
415e9bad
LOK
47
48#define SL_COMMAND_TYPE_HDDRECORDER_DISC 0x01
49#define SL_COMMAND_TYPE_VCR 0x02
50#define SL_COMMAND_TYPE_DVDPLAYER 0x03
51#define SL_COMMAND_TYPE_HDDRECORDER_DISC2 0x04
52#define SL_COMMAND_TYPE_HDDRECORDER 0x05
11d13a02 53
0d4c3a7b 54#define SL_COMMAND_REQUEST_POWER_STATUS 0xa0
9a0d7b9f 55#define SL_COMMAND_POWER_ON 0x03
0d4c3a7b 56#define SL_COMMAND_CONNECT_REQUEST 0x04
5abb18f3 57#define SL_COMMAND_SET_DEVICE_MODE 0x05
11d13a02 58
004b8382
LOK
59#define LIB_CEC m_busDevice->GetProcessor()->GetLib()
60#define ToString(p) LIB_CEC->ToString(p)
61
060a7b5e
LOK
62CSLCommandHandler::CSLCommandHandler(CCECBusDevice *busDevice,
63 int32_t iTransmitTimeout /* = CEC_DEFAULT_TRANSMIT_TIMEOUT */,
64 int32_t iTransmitWait /* = CEC_DEFAULT_TRANSMIT_WAIT */,
65 int8_t iTransmitRetries /* = CEC_DEFAULT_TRANSMIT_RETRIES */,
66 int64_t iActiveSourcePending /* = 0 */) :
67 CCECCommandHandler(busDevice, iTransmitTimeout, iTransmitWait, iTransmitRetries, iActiveSourcePending),
b4c4ef7d 68 m_bSLEnabled(false),
b8952342 69 m_bActiveSourceSent(false)
e9de9629 70{
cf4931be 71 m_vendorId = CEC_VENDOR_LG;
79f01d26 72
6b87ae0c
LOK
73 /* LG devices don't always reply to CEC version requests, so just set it to 1.3a */
74 m_busDevice->SetCecVersion(CEC_VERSION_1_3A);
79f01d26
LOK
75
76 /* LG devices always return "korean" as language */
77 cec_menu_language lang;
78 lang.device = m_busDevice->GetLogicalAddress();
79 snprintf(lang.language, 4, "eng");
80 m_busDevice->SetMenuLanguage(lang);
9f65e017
LOK
81}
82
468a1414
LOK
83bool CSLCommandHandler::InitHandler(void)
84{
85 if (m_bHandlerInited)
86 return true;
87 m_bHandlerInited = true;
88
0b835513
LOK
89 if (m_busDevice->GetLogicalAddress() != CECDEVICE_TV)
90 return true;
91
42d28d15
LOK
92 CCECBusDevice *primary = m_processor->GetPrimaryDevice();
93 if (primary && primary->GetLogicalAddress() != CECDEVICE_UNREGISTERED)
871934d3 94 {
42d28d15
LOK
95 /* imitate LG devices */
96 if (m_busDevice->GetLogicalAddress() != primary->GetLogicalAddress())
97 {
98 primary->SetVendorId(CEC_VENDOR_LG);
99 primary->ReplaceHandler(false);
100 }
101
102 if (m_busDevice->GetLogicalAddress() == CECDEVICE_TV)
103 {
104 /* start as 'in transition standby->on' */
105 primary->SetPowerStatus(CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON);
2b44051c 106 primary->TransmitPowerState(CECDEVICE_TV, false);
42d28d15
LOK
107
108 /* send the vendor id */
2b44051c 109 primary->TransmitVendorID(CECDEVICE_BROADCAST, false, false);
42d28d15 110 }
871934d3 111 }
468a1414 112
468a1414
LOK
113 return true;
114}
115
9a54dc82 116int CSLCommandHandler::HandleActiveSource(const cec_command &command)
468a1414
LOK
117{
118 if (command.parameters.size == 2)
119 {
120 uint16_t iAddress = ((uint16_t)command.parameters[0] << 8) | ((uint16_t)command.parameters[1]);
004b8382
LOK
121 CCECBusDevice *device = m_processor->GetDeviceByPhysicalAddress(iAddress);
122 if (device)
123 device->MarkAsActiveSource();
aab5cd7a 124
682b21de 125 {
aab5cd7a
LOK
126 CLockObject lock(m_SLMutex);
127 m_bActiveSourceSent = false;
682b21de 128 }
9a54dc82
LOK
129
130 return COMMAND_HANDLED;
468a1414
LOK
131 }
132
9a54dc82 133 return CEC_ABORT_REASON_INVALID_OPERAND;
bbc71623 134
468a1414
LOK
135}
136
9a54dc82 137int CSLCommandHandler::HandleDeviceVendorId(const cec_command &command)
a463f954
LOK
138{
139 SetVendorId(command);
140
632f5810 141 if (!SLInitialised() && command.initiator == CECDEVICE_TV)
468a1414 142 {
63047ed3
LOK
143 CCECBusDevice *destination = m_processor->GetDevice(command.destination);
144 if (destination && (destination->GetLogicalAddress() == CECDEVICE_BROADCAST || destination->IsHandledByLibCEC()))
145 {
146 cec_logical_address initiator = destination->GetLogicalAddress();
147 if (initiator == CECDEVICE_BROADCAST)
148 initiator = m_processor->GetPrimaryDevice()->GetLogicalAddress();
149
150 cec_command response;
151 cec_command::Format(response, initiator, command.initiator, CEC_OPCODE_FEATURE_ABORT);
2b44051c 152 Transmit(response, false, true);
9a54dc82 153 return COMMAND_HANDLED;
63047ed3 154 }
468a1414 155 }
9a54dc82
LOK
156
157 return CCECCommandHandler::HandleDeviceVendorId(command);
468a1414
LOK
158}
159
9a54dc82 160int CSLCommandHandler::HandleVendorCommand(const cec_command &command)
e54fd7d2 161{
004b8382 162 if (!m_processor->IsHandledByLibCEC(command.destination))
415e9bad
LOK
163 return true;
164
e54fd7d2 165 if (command.parameters.size == 1 &&
11d13a02 166 command.parameters[0] == SL_COMMAND_UNKNOWN_01)
e54fd7d2 167 {
5f316715 168 HandleVendorCommand01(command);
9a54dc82 169 return COMMAND_HANDLED;
e54fd7d2 170 }
9a0d7b9f
LOK
171 else if (command.parameters.size == 2 &&
172 command.parameters[0] == SL_COMMAND_POWER_ON)
173 {
0ecbcd4d 174 HandleVendorCommandPowerOn(command);
9a54dc82 175 return COMMAND_HANDLED;
9a0d7b9f 176 }
797dd7c4 177 else if (command.parameters.size == 2 &&
11d13a02 178 command.parameters[0] == SL_COMMAND_CONNECT_REQUEST)
9902f4e8 179 {
0ecbcd4d 180 HandleVendorCommandSLConnect(command);
9a54dc82 181 return COMMAND_HANDLED;
9902f4e8
LOK
182 }
183 else if (command.parameters.size == 1 &&
0d4c3a7b 184 command.parameters[0] == SL_COMMAND_REQUEST_POWER_STATUS)
9902f4e8 185 {
0ecbcd4d 186 HandleVendorCommandPowerOnStatus(command);
9a54dc82 187 return COMMAND_HANDLED;
9902f4e8 188 }
e54fd7d2 189
9a54dc82 190 return CCECCommandHandler::HandleVendorCommand(command);
e54fd7d2
LOK
191}
192
5f316715 193void CSLCommandHandler::HandleVendorCommand01(const cec_command &command)
fe6f8e37 194{
b818fb5a 195 m_processor->GetPrimaryDevice()->SetPowerStatus(CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON);
fe6f8e37
LOK
196 TransmitVendorCommand0205(command.destination, command.initiator);
197}
198
199void CSLCommandHandler::TransmitVendorCommand0205(const cec_logical_address iSource, const cec_logical_address iDestination)
5f316715
LOK
200{
201 cec_command response;
fe6f8e37 202 cec_command::Format(response, iSource, iDestination, CEC_OPCODE_VENDOR_COMMAND);
5f316715 203 response.PushBack(SL_COMMAND_UNKNOWN_02);
415e9bad 204 response.PushBack(SL_COMMAND_TYPE_HDDRECORDER);
5f316715 205
2b44051c 206 Transmit(response, false, true);
fe6f8e37 207}
5f316715 208
0ecbcd4d 209void CSLCommandHandler::HandleVendorCommandPowerOn(const cec_command &command)
9a0d7b9f 210{
632f5810
LOK
211 if (command.initiator != CECDEVICE_TV)
212 return;
213
842262d8 214 CCECBusDevice *device = m_processor->GetPrimaryDevice();
9a0d7b9f
LOK
215 if (device)
216 {
cc1b9bc4 217 SetSLInitialised();
004b8382 218 device->MarkAsActiveSource();
60383b11 219 device->SetPowerStatus(CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON);
2b44051c 220 device->TransmitPowerState(command.initiator, true);
60383b11
LOK
221
222 CEvent::Sleep(2000);
223 device->SetPowerStatus(CEC_POWER_STATUS_ON);
2b44051c
LOK
224 device->TransmitPowerState(command.initiator, false);
225 device->TransmitPhysicalAddress(false);
60383b11
LOK
226 {
227 CLockObject lock(m_SLMutex);
228 m_bActiveSourceSent = false;
229 }
468a1414 230 }
5f316715 231}
0ecbcd4d 232void CSLCommandHandler::HandleVendorCommandPowerOnStatus(const cec_command &command)
5f316715
LOK
233{
234 if (command.destination != CECDEVICE_BROADCAST)
235 {
004b8382
LOK
236 CCECBusDevice *device = m_processor->GetPrimaryDevice();
237 if (device)
238 {
239 device->SetPowerStatus(CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON);
2b44051c 240 device->TransmitPowerState(command.initiator, true);
004b8382
LOK
241 device->SetPowerStatus(CEC_POWER_STATUS_ON);
242 }
5f316715
LOK
243 }
244}
245
468a1414 246void CSLCommandHandler::HandleVendorCommandSLConnect(const cec_command &command)
8d915412 247{
cc1b9bc4 248 SetSLInitialised();
004b8382 249 TransmitVendorCommandSetDeviceMode(command.destination, command.initiator, CEC_DEVICE_TYPE_RECORDING_DEVICE);
37acf382 250
2abe628c 251 ActivateSource();
8d915412 252}
0d4c3a7b 253
5abb18f3 254void CSLCommandHandler::TransmitVendorCommandSetDeviceMode(const cec_logical_address iSource, const cec_logical_address iDestination, const cec_device_type type)
0d4c3a7b 255{
468a1414
LOK
256 cec_command response;
257 cec_command::Format(response, iSource, iDestination, CEC_OPCODE_VENDOR_COMMAND);
5abb18f3
LOK
258 response.PushBack(SL_COMMAND_SET_DEVICE_MODE);
259 response.PushBack((uint8_t)type);
2b44051c 260 Transmit(response, false, true);
0d4c3a7b 261}
fe6f8e37 262
9a54dc82 263int CSLCommandHandler::HandleGiveDeckStatus(const cec_command &command)
9f65e017 264{
9a54dc82
LOK
265 if (!m_processor->CECInitialised() ||
266 !m_processor->IsHandledByLibCEC(command.destination))
267 return CEC_ABORT_REASON_NOT_IN_CORRECT_MODE_TO_RESPOND;
268
269 CCECPlaybackDevice *device = CCECBusDevice::AsPlaybackDevice(GetDevice(command.destination));
270 if (!device || command.parameters.size == 0)
271 return CEC_ABORT_REASON_INVALID_OPERAND;
272
aab5cd7a 273 device->SetDeckStatus(CEC_DECK_INFO_OTHER_STATUS_LG);
9a54dc82 274 if (command.parameters[0] == CEC_STATUS_REQUEST_ON)
b818fb5a 275 {
2b44051c 276 device->TransmitDeckStatus(command.initiator, true);
9a54dc82
LOK
277 if (!ActiveSourceSent())
278 ActivateSource();
279 return COMMAND_HANDLED;
280 }
281 else if (command.parameters[0] == CEC_STATUS_REQUEST_ONCE)
282 {
2b44051c 283 device->TransmitDeckStatus(command.initiator, true);
9a54dc82 284 return COMMAND_HANDLED;
b818fb5a 285 }
9f65e017 286
9a54dc82 287 return CCECCommandHandler::HandleGiveDeckStatus(command);
9f65e017 288}
718b3632 289
9a54dc82 290int CSLCommandHandler::HandleGiveDevicePowerStatus(const cec_command &command)
718b3632 291{
0b8c7eab 292 if (m_processor->CECInitialised() && m_processor->IsHandledByLibCEC(command.destination) && command.initiator == CECDEVICE_TV)
718b3632
LOK
293 {
294 CCECBusDevice *device = GetDevice(command.destination);
004b8382 295 if (device && device->GetCurrentPowerStatus() != CEC_POWER_STATUS_ON)
2abe628c 296 {
2b44051c 297 device->TransmitPowerState(command.initiator, true);
2abe628c
LOK
298 device->SetPowerStatus(CEC_POWER_STATUS_ON);
299 }
2abe628c
LOK
300 else
301 {
cc1b9bc4 302 if (!ActiveSourceSent())
3faa971c
LOK
303 {
304 device->SetPowerStatus(CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON);
2b44051c 305 device->TransmitPowerState(command.initiator, true);
3faa971c
LOK
306 ActivateSource();
307 }
308 else if (m_resetPowerState.IsSet() && m_resetPowerState.TimeLeft() > 0)
309 {
415e9bad 310 /* TODO assume that we've bugged out. the return button no longer works after this */
004b8382 311 LIB_CEC->AddLog(CEC_LOG_WARNING, "FIXME: LG seems to have bugged out. resetting to 'in transition standby to on'. the return button will not work");
cc1b9bc4
LOK
312 {
313 CLockObject lock(m_SLMutex);
314 m_bActiveSourceSent = false;
315 }
3faa971c 316 device->SetPowerStatus(CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON);
2b44051c 317 device->TransmitPowerState(command.initiator, true);
3faa971c
LOK
318 device->SetPowerStatus(CEC_POWER_STATUS_ON);
319 m_resetPowerState.Init(5000);
320 }
321 else
322 {
2b44051c 323 device->TransmitPowerState(command.initiator, true);
3faa971c
LOK
324 m_resetPowerState.Init(5000);
325 }
b818fb5a 326 }
9a54dc82
LOK
327
328 return COMMAND_HANDLED;
718b3632
LOK
329 }
330
9a54dc82 331 return CEC_ABORT_REASON_NOT_IN_CORRECT_MODE_TO_RESPOND;
2abe628c
LOK
332}
333
9a54dc82 334int CSLCommandHandler::HandleRequestActiveSource(const cec_command &command)
2abe628c 335{
0b8c7eab 336 if (m_processor->CECInitialised())
2abe628c 337 {
1fee1b3d 338 if (ActiveSourceSent())
004b8382 339 LIB_CEC->AddLog(CEC_LOG_DEBUG, ">> %i requests active source, ignored", (uint8_t) command.initiator);
1fee1b3d
LOK
340 else
341 ActivateSource();
9a54dc82 342 return COMMAND_HANDLED;
2abe628c 343 }
9a54dc82 344 return CEC_ABORT_REASON_NOT_IN_CORRECT_MODE_TO_RESPOND;
718b3632 345}
5c3b1f92 346
9a54dc82 347int CSLCommandHandler::HandleFeatureAbort(const cec_command &command)
5c3b1f92 348{
004b8382 349 if (command.parameters.size == 0 && m_processor->GetPrimaryDevice()->GetCurrentPowerStatus() == CEC_POWER_STATUS_ON && !SLInitialised() &&
632f5810 350 command.initiator == CECDEVICE_TV)
5c3b1f92 351 {
2b44051c
LOK
352 m_processor->GetPrimaryDevice()->TransmitPowerState(command.initiator, false);
353 m_processor->GetPrimaryDevice()->TransmitVendorID(CECDEVICE_BROADCAST, false, false);
5c3b1f92
LOK
354 }
355
356 return CCECCommandHandler::HandleFeatureAbort(command);
357}
358
9a54dc82 359int CSLCommandHandler::HandleStandby(const cec_command &command)
5c3b1f92
LOK
360{
361 if (command.initiator == CECDEVICE_TV)
1fee1b3d
LOK
362 {
363 CLockObject lock(m_SLMutex);
364 m_bActiveSourceSent = false;
365 }
5c3b1f92 366
cc1b9bc4
LOK
367 return CCECCommandHandler::HandleStandby(command);
368}
5c3b1f92 369
cc1b9bc4
LOK
370void CSLCommandHandler::ResetSLState(void)
371{
004b8382 372 LIB_CEC->AddLog(CEC_LOG_NOTICE, "resetting SL initialised state");
cc1b9bc4
LOK
373 CLockObject lock(m_SLMutex);
374 m_bSLEnabled = false;
375 m_bActiveSourceSent = false;
376 m_processor->GetPrimaryDevice()->SetPowerStatus(CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON);
377}
378
379void CSLCommandHandler::SetSLInitialised(void)
380{
004b8382 381 LIB_CEC->AddLog(CEC_LOG_NOTICE, "SL initialised");
cc1b9bc4
LOK
382 CLockObject lock(m_SLMutex);
383 m_bSLEnabled = true;
384}
385
386bool CSLCommandHandler::SLInitialised(void)
387{
388 CLockObject lock(m_SLMutex);
389 return m_bSLEnabled;
390}
391
392bool CSLCommandHandler::ActiveSourceSent(void)
393{
394 CLockObject lock(m_SLMutex);
395 return m_bActiveSourceSent;
5c3b1f92 396}
632f5810
LOK
397
398bool CSLCommandHandler::PowerOn(const cec_logical_address iInitiator, const cec_logical_address iDestination)
399{
400 if (iDestination != CECDEVICE_TV)
401 {
bbc71623 402 /* LG devices only allow themselves to be woken up by the TV with a vendor command */
632f5810 403 cec_command command;
8b5e50ec
LOK
404
405 if (!m_bSLEnabled)
869ff027 406 TransmitVendorID(CECDEVICE_TV, iDestination, CEC_VENDOR_LG, false);
8b5e50ec 407
632f5810
LOK
408 cec_command::Format(command, CECDEVICE_TV, iDestination, CEC_OPCODE_VENDOR_COMMAND);
409 command.PushBack(SL_COMMAND_POWER_ON);
410 command.PushBack(0);
2b44051c 411 return Transmit(command, false, false);
632f5810
LOK
412 }
413
414 return CCECCommandHandler::PowerOn(iInitiator, iDestination);
415}
7b01619d
LOK
416
417void CSLCommandHandler::VendorPreActivateSourceHook(void)
418{
419 CCECPlaybackDevice *device = m_busDevice->AsPlaybackDevice();
420 if (device)
421 device->SetDeckStatus(!device->IsActiveSource() ? CEC_DECK_INFO_OTHER_STATUS : CEC_DECK_INFO_OTHER_STATUS_LG);
422}