rpi: register callback for HPD. re-read the physical address when we received VC_HDMI...
[deb_libcec.git] / src / lib / CECProcessor.cpp
... / ...
CommitLineData
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#include "CECProcessor.h"
35
36#include "adapter/AdapterFactory.h"
37#include "devices/CECBusDevice.h"
38#include "devices/CECAudioSystem.h"
39#include "devices/CECPlaybackDevice.h"
40#include "devices/CECRecordingDevice.h"
41#include "devices/CECTuner.h"
42#include "devices/CECTV.h"
43#include "implementations/CECCommandHandler.h"
44#include "LibCEC.h"
45#include "CECClient.h"
46#include "CECTypeUtils.h"
47#include "platform/util/timeutils.h"
48#include "platform/util/util.h"
49
50using namespace CEC;
51using namespace std;
52using namespace PLATFORM;
53
54#define CEC_PROCESSOR_SIGNAL_WAIT_TIME 1000
55#define ACTIVE_SOURCE_CHECK_INTERVAL 500
56
57#define ToString(x) CCECTypeUtils::ToString(x)
58
59CCECProcessor::CCECProcessor(CLibCEC *libcec) :
60 m_bInitialised(false),
61 m_communication(NULL),
62 m_libcec(libcec),
63 m_iStandardLineTimeout(3),
64 m_iRetryLineTimeout(3),
65 m_iLastTransmission(0),
66 m_bMonitor(true),
67 m_addrAllocator(NULL),
68 m_bStallCommunication(false)
69{
70 m_busDevices = new CCECDeviceMap(this);
71}
72
73CCECProcessor::~CCECProcessor(void)
74{
75 m_bStallCommunication = false;
76 DELETE_AND_NULL(m_addrAllocator);
77 Close();
78 DELETE_AND_NULL(m_busDevices);
79}
80
81bool CCECProcessor::Start(const char *strPort, uint16_t iBaudRate /* = CEC_SERIAL_DEFAULT_BAUDRATE */, uint32_t iTimeoutMs /* = CEC_DEFAULT_CONNECT_TIMEOUT */)
82{
83 CLockObject lock(m_mutex);
84 // open a connection
85 if (!OpenConnection(strPort, iBaudRate, iTimeoutMs))
86 return false;
87
88 // create the processor thread
89 if (!IsRunning())
90 {
91 if (!CreateThread())
92 {
93 m_libcec->AddLog(CEC_LOG_ERROR, "could not create a processor thread");
94 return false;
95 }
96 }
97
98 return true;
99}
100
101void CCECProcessor::Close(void)
102{
103 // mark as uninitialised
104 SetCECInitialised(false);
105
106 // stop the processor
107 StopThread(-1);
108 m_inBuffer.Broadcast();
109 StopThread();
110
111 // close the connection
112 DELETE_AND_NULL(m_communication);
113}
114
115void CCECProcessor::ResetMembers(void)
116{
117 // close the connection
118 DELETE_AND_NULL(m_communication);
119
120 // reset the other members to the initial state
121 m_iStandardLineTimeout = 3;
122 m_iRetryLineTimeout = 3;
123 m_iLastTransmission = 0;
124 m_busDevices->ResetDeviceStatus();
125}
126
127bool CCECProcessor::OpenConnection(const char *strPort, uint16_t iBaudRate, uint32_t iTimeoutMs, bool bStartListening /* = true */)
128{
129 bool bReturn(false);
130 CTimeout timeout(iTimeoutMs > 0 ? iTimeoutMs : CEC_DEFAULT_TRANSMIT_WAIT);
131
132 // ensure that a previous connection is closed
133 Close();
134
135 // reset all member to the initial state
136 ResetMembers();
137
138 // check whether the Close() method deleted any previous connection
139 if (m_communication)
140 {
141 m_libcec->AddLog(CEC_LOG_ERROR, "previous connection could not be closed");
142 return bReturn;
143 }
144
145 // create a new connection
146 m_communication = CAdapterFactory(this->m_libcec).GetInstance(strPort, iBaudRate);
147
148 // open a new connection
149 unsigned iConnectTry(0);
150 while (timeout.TimeLeft() > 0 && (bReturn = m_communication->Open((timeout.TimeLeft() / CEC_CONNECT_TRIES), false, bStartListening)) == false)
151 {
152 m_libcec->AddLog(CEC_LOG_ERROR, "could not open a connection (try %d)", ++iConnectTry);
153 m_communication->Close();
154 CEvent::Sleep(CEC_DEFAULT_CONNECT_RETRY_WAIT);
155 }
156
157 m_libcec->AddLog(CEC_LOG_NOTICE, "connection opened");
158
159 // mark as initialised
160 SetCECInitialised(true);
161
162 return bReturn;
163}
164
165bool CCECProcessor::CECInitialised(void)
166{
167 CLockObject lock(m_threadMutex);
168 return m_bInitialised;
169}
170
171void CCECProcessor::SetCECInitialised(bool bSetTo /* = true */)
172{
173 {
174 CLockObject lock(m_mutex);
175 m_bInitialised = bSetTo;
176 }
177 if (!bSetTo)
178 UnregisterClients();
179}
180
181bool CCECProcessor::TryLogicalAddress(cec_logical_address address, cec_version libCECSpecVersion /* = CEC_VERSION_1_4 */)
182{
183 // find the device
184 CCECBusDevice *device = m_busDevices->At(address);
185 if (device)
186 {
187 // check if it's already marked as present or used
188 if (device->IsPresent() || device->IsHandledByLibCEC())
189 return false;
190
191 // poll the LA if not
192 return device->TryLogicalAddress(libCECSpecVersion);
193 }
194
195 return false;
196}
197
198void CCECProcessor::ReplaceHandlers(void)
199{
200 if (!CECInitialised())
201 return;
202
203 // check each device
204 for (CECDEVICEMAP::iterator it = m_busDevices->Begin(); it != m_busDevices->End(); it++)
205 it->second->ReplaceHandler(true);
206}
207
208bool CCECProcessor::OnCommandReceived(const cec_command &command)
209{
210 return m_inBuffer.Push(command);
211}
212
213void *CCECProcessor::Process(void)
214{
215 m_libcec->AddLog(CEC_LOG_DEBUG, "processor thread started");
216
217 cec_command command; command.Clear();
218 CTimeout activeSourceCheck(ACTIVE_SOURCE_CHECK_INTERVAL);
219
220 // as long as we're not being stopped and the connection is open
221 while (!IsStopped() && m_communication->IsOpen())
222 {
223 // wait for a new incoming command, and process it
224 if (m_inBuffer.Pop(command, CEC_PROCESSOR_SIGNAL_WAIT_TIME))
225 ProcessCommand(command);
226
227 if (CECInitialised() && !IsStopped())
228 {
229 // check clients for keypress timeouts
230 m_libcec->CheckKeypressTimeout();
231
232 // check if we need to replace handlers
233 ReplaceHandlers();
234
235 // check whether we need to activate a source, if it failed before
236 if (activeSourceCheck.TimeLeft() == 0)
237 {
238 if (CECInitialised())
239 TransmitPendingActiveSourceCommands();
240 activeSourceCheck.Init(ACTIVE_SOURCE_CHECK_INTERVAL);
241 }
242 }
243 }
244
245 return NULL;
246}
247
248bool CCECProcessor::ActivateSource(uint16_t iStreamPath)
249{
250 bool bReturn(false);
251
252 // find the device with the given PA
253 CCECBusDevice *device = GetDeviceByPhysicalAddress(iStreamPath);
254 // and make it the active source when found
255 if (device)
256 bReturn = device->ActivateSource();
257 else
258 m_libcec->AddLog(CEC_LOG_DEBUG, "device with PA '%04x' not found", iStreamPath);
259
260 return bReturn;
261}
262
263void CCECProcessor::SetActiveSource(bool bSetTo, bool bClientUnregistered)
264{
265 if (m_communication)
266 m_communication->SetActiveSource(bSetTo, bClientUnregistered);
267}
268
269void CCECProcessor::SetStandardLineTimeout(uint8_t iTimeout)
270{
271 CLockObject lock(m_mutex);
272 m_iStandardLineTimeout = iTimeout;
273}
274
275uint8_t CCECProcessor::GetStandardLineTimeout(void)
276{
277 CLockObject lock(m_mutex);
278 return m_iStandardLineTimeout;
279}
280
281void CCECProcessor::SetRetryLineTimeout(uint8_t iTimeout)
282{
283 CLockObject lock(m_mutex);
284 m_iRetryLineTimeout = iTimeout;
285}
286
287uint8_t CCECProcessor::GetRetryLineTimeout(void)
288{
289 CLockObject lock(m_mutex);
290 return m_iRetryLineTimeout;
291}
292
293bool CCECProcessor::PhysicalAddressInUse(uint16_t iPhysicalAddress)
294{
295 CCECBusDevice *device = GetDeviceByPhysicalAddress(iPhysicalAddress);
296 return device != NULL;
297}
298
299void CCECProcessor::LogOutput(const cec_command &data)
300{
301 CStdString strTx;
302
303 // initiator and destination
304 strTx.Format("<< %02x", ((uint8_t)data.initiator << 4) + (uint8_t)data.destination);
305
306 // append the opcode
307 if (data.opcode_set)
308 strTx.AppendFormat(":%02x", (uint8_t)data.opcode);
309
310 // append the parameters
311 for (uint8_t iPtr = 0; iPtr < data.parameters.size; iPtr++)
312 strTx.AppendFormat(":%02x", data.parameters[iPtr]);
313
314 // and log it
315 m_libcec->AddLog(CEC_LOG_TRAFFIC, strTx.c_str());
316}
317
318bool CCECProcessor::PollDevice(cec_logical_address iAddress)
319{
320 // try to find the primary device
321 CCECBusDevice *primary = GetPrimaryDevice();
322 // poll the destination, with the primary as source
323 if (primary)
324 return primary->TransmitPoll(iAddress, true);
325
326 CCECBusDevice *device = m_busDevices->At(CECDEVICE_UNREGISTERED);
327 if (device)
328 return device->TransmitPoll(iAddress, true);
329
330 return false;
331}
332
333CCECBusDevice *CCECProcessor::GetDeviceByPhysicalAddress(uint16_t iPhysicalAddress, bool bSuppressUpdate /* = true */)
334{
335 return m_busDevices ?
336 m_busDevices->GetDeviceByPhysicalAddress(iPhysicalAddress, bSuppressUpdate) :
337 NULL;
338}
339
340CCECBusDevice *CCECProcessor::GetDevice(cec_logical_address address) const
341{
342 return m_busDevices ?
343 m_busDevices->At(address) :
344 NULL;
345}
346
347cec_logical_address CCECProcessor::GetActiveSource(bool bRequestActiveSource /* = true */)
348{
349 // get the device that is marked as active source from the device map
350 CCECBusDevice *activeSource = m_busDevices->GetActiveSource();
351 if (activeSource)
352 return activeSource->GetLogicalAddress();
353
354 if (bRequestActiveSource)
355 {
356 // request the active source from the bus
357 CCECBusDevice *primary = GetPrimaryDevice();
358 if (primary)
359 {
360 primary->RequestActiveSource();
361 return GetActiveSource(false);
362 }
363 }
364
365 // unknown or none
366 return CECDEVICE_UNKNOWN;
367}
368
369bool CCECProcessor::IsActiveSource(cec_logical_address iAddress)
370{
371 CCECBusDevice *device = m_busDevices->At(iAddress);
372 return device && device->IsActiveSource();
373}
374
375bool CCECProcessor::Transmit(const cec_command &data, bool bIsReply)
376{
377 cec_command transmitData(data);
378 uint8_t iMaxTries(0);
379 bool bRetry(true);
380 uint8_t iTries(0);
381
382 // get the current timeout setting
383 uint8_t iLineTimeout(GetStandardLineTimeout());
384
385 // reset the state of this message to 'unknown'
386 cec_adapter_message_state adapterState = ADAPTER_MESSAGE_STATE_UNKNOWN;
387
388 if (!m_communication->SupportsSourceLogicalAddress(transmitData.initiator))
389 {
390 if (transmitData.initiator == CECDEVICE_UNREGISTERED && m_communication->SupportsSourceLogicalAddress(CECDEVICE_FREEUSE))
391 {
392 m_libcec->AddLog(CEC_LOG_DEBUG, "initiator '%s' is not supported by the CEC adapter. using '%s' instead", ToString(transmitData.initiator), ToString(CECDEVICE_FREEUSE));
393 transmitData.initiator = CECDEVICE_FREEUSE;
394 }
395 else
396 {
397 m_libcec->AddLog(CEC_LOG_DEBUG, "initiator '%s' is not supported by the CEC adapter", ToString(transmitData.initiator));
398 return false;
399 }
400 }
401
402 LogOutput(transmitData);
403
404 // find the initiator device
405 CCECBusDevice *initiator = m_busDevices->At(transmitData.initiator);
406 if (!initiator)
407 {
408 m_libcec->AddLog(CEC_LOG_WARNING, "invalid initiator");
409 return false;
410 }
411
412 // find the destination device, if it's not the broadcast address
413 if (transmitData.destination != CECDEVICE_BROADCAST)
414 {
415 // check if the device is marked as handled by libCEC
416 CCECBusDevice *destination = m_busDevices->At(transmitData.destination);
417 if (destination && destination->IsHandledByLibCEC())
418 {
419 // and reject the command if it's trying to send data to a device that is handled by libCEC
420 m_libcec->AddLog(CEC_LOG_WARNING, "not sending data to myself!");
421 return false;
422 }
423 }
424
425 // wait until we finished allocating a new LA if it got lost
426 while (m_bStallCommunication) Sleep(5);
427
428 {
429 CLockObject lock(m_mutex);
430 m_iLastTransmission = GetTimeMs();
431 // set the number of tries
432 iMaxTries = initiator->GetHandler()->GetTransmitRetries() + 1;
433 initiator->MarkHandlerReady();
434 }
435
436 // and try to send the command
437 while (bRetry && ++iTries < iMaxTries)
438 {
439 if (initiator->IsUnsupportedFeature(transmitData.opcode))
440 return false;
441
442 adapterState = !IsStopped() && m_communication && m_communication->IsOpen() ?
443 m_communication->Write(transmitData, bRetry, iLineTimeout, bIsReply) :
444 ADAPTER_MESSAGE_STATE_ERROR;
445 iLineTimeout = m_iRetryLineTimeout;
446 }
447
448 return bIsReply ?
449 adapterState == ADAPTER_MESSAGE_STATE_SENT_ACKED || adapterState == ADAPTER_MESSAGE_STATE_SENT || adapterState == ADAPTER_MESSAGE_STATE_WAITING_TO_BE_SENT :
450 adapterState == ADAPTER_MESSAGE_STATE_SENT_ACKED;
451}
452
453void CCECProcessor::TransmitAbort(cec_logical_address source, cec_logical_address destination, cec_opcode opcode, cec_abort_reason reason /* = CEC_ABORT_REASON_UNRECOGNIZED_OPCODE */)
454{
455 m_libcec->AddLog(CEC_LOG_DEBUG, "<< transmitting abort message");
456
457 cec_command command;
458 cec_command::Format(command, source, destination, CEC_OPCODE_FEATURE_ABORT);
459 command.parameters.PushBack((uint8_t)opcode);
460 command.parameters.PushBack((uint8_t)reason);
461
462 Transmit(command, true);
463}
464
465void CCECProcessor::ProcessCommand(const cec_command &command)
466{
467 // log the command
468 CStdString dataStr;
469 dataStr.Format(">> %1x%1x", command.initiator, command.destination);
470 if (command.opcode_set == 1)
471 dataStr.AppendFormat(":%02x", command.opcode);
472 for (uint8_t iPtr = 0; iPtr < command.parameters.size; iPtr++)
473 dataStr.AppendFormat(":%02x", (unsigned int)command.parameters[iPtr]);
474 m_libcec->AddLog(CEC_LOG_TRAFFIC, dataStr.c_str());
475
476 // find the initiator
477 CCECBusDevice *device = m_busDevices->At(command.initiator);
478
479 if (device)
480 device->HandleCommand(command);
481}
482
483bool CCECProcessor::IsPresentDevice(cec_logical_address address)
484{
485 CCECBusDevice *device = m_busDevices->At(address);
486 return device && device->GetStatus() == CEC_DEVICE_STATUS_PRESENT;
487}
488
489bool CCECProcessor::IsPresentDeviceType(cec_device_type type)
490{
491 CECDEVICEVEC devices;
492 m_busDevices->GetByType(type, devices);
493 CCECDeviceMap::FilterActive(devices);
494 return !devices.empty();
495}
496
497uint16_t CCECProcessor::GetDetectedPhysicalAddress(void) const
498{
499 return m_communication ? m_communication->GetPhysicalAddress() : CEC_INVALID_PHYSICAL_ADDRESS;
500}
501
502bool CCECProcessor::ClearLogicalAddresses(void)
503{
504 cec_logical_addresses addresses; addresses.Clear();
505 return SetLogicalAddresses(addresses);
506}
507
508bool CCECProcessor::SetLogicalAddresses(const cec_logical_addresses &addresses)
509{
510 return m_communication ? m_communication->SetLogicalAddresses(addresses) : false;
511}
512
513bool CCECProcessor::StandbyDevices(const cec_logical_address initiator, const CECDEVICEVEC &devices)
514{
515 bool bReturn(true);
516 for (CECDEVICEVEC::const_iterator it = devices.begin(); it != devices.end(); it++)
517 bReturn &= (*it)->Standby(initiator);
518 return bReturn;
519}
520
521bool CCECProcessor::StandbyDevice(const cec_logical_address initiator, cec_logical_address address)
522{
523 CCECBusDevice *device = m_busDevices->At(address);
524 return device ? device->Standby(initiator) : false;
525}
526
527bool CCECProcessor::PowerOnDevices(const cec_logical_address initiator, const CECDEVICEVEC &devices)
528{
529 bool bReturn(true);
530 for (CECDEVICEVEC::const_iterator it = devices.begin(); it != devices.end(); it++)
531 bReturn &= (*it)->PowerOn(initiator);
532 return bReturn;
533}
534
535bool CCECProcessor::PowerOnDevice(const cec_logical_address initiator, cec_logical_address address)
536{
537 CCECBusDevice *device = m_busDevices->At(address);
538 return device ? device->PowerOn(initiator) : false;
539}
540
541bool CCECProcessor::StartBootloader(const char *strPort /* = NULL */)
542{
543 bool bReturn(false);
544 // open a connection if no connection has been opened
545 if (!m_communication && strPort)
546 {
547 CAdapterFactory factory(this->m_libcec);
548 IAdapterCommunication *comm = factory.GetInstance(strPort);
549 CTimeout timeout(CEC_DEFAULT_CONNECT_TIMEOUT);
550 int iConnectTry(0);
551 while (timeout.TimeLeft() > 0 && (bReturn = comm->Open(timeout.TimeLeft() / CEC_CONNECT_TRIES, true)) == false)
552 {
553 m_libcec->AddLog(CEC_LOG_ERROR, "could not open a connection (try %d)", ++iConnectTry);
554 comm->Close();
555 Sleep(CEC_DEFAULT_TRANSMIT_RETRY_WAIT);
556 }
557 if (comm->IsOpen())
558 {
559 bReturn = comm->StartBootloader();
560 DELETE_AND_NULL(comm);
561 }
562 return bReturn;
563 }
564 else
565 {
566 m_communication->StartBootloader();
567 Close();
568 bReturn = true;
569 }
570
571 return bReturn;
572}
573
574bool CCECProcessor::PingAdapter(void)
575{
576 return m_communication->PingAdapter();
577}
578
579void CCECProcessor::HandlePoll(cec_logical_address initiator, cec_logical_address destination)
580{
581 CCECBusDevice *device = m_busDevices->At(destination);
582 if (device)
583 device->HandlePollFrom(initiator);
584}
585
586bool CCECProcessor::HandleReceiveFailed(cec_logical_address initiator)
587{
588 CCECBusDevice *device = m_busDevices->At(initiator);
589 return !device || !device->HandleReceiveFailed();
590}
591
592bool CCECProcessor::CanPersistConfiguration(void)
593{
594 return m_communication ? m_communication->GetFirmwareVersion() >= 2 : false;
595}
596
597bool CCECProcessor::PersistConfiguration(const libcec_configuration &configuration)
598{
599 libcec_configuration persistConfiguration = configuration;
600 if (!CLibCEC::IsValidPhysicalAddress(configuration.iPhysicalAddress))
601 {
602 CCECBusDevice *device = GetPrimaryDevice();
603 if (device)
604 persistConfiguration.iPhysicalAddress = device->GetCurrentPhysicalAddress();
605 }
606
607 return m_communication ? m_communication->PersistConfiguration(persistConfiguration) : false;
608}
609
610void CCECProcessor::RescanActiveDevices(void)
611{
612 for (CECDEVICEMAP::iterator it = m_busDevices->Begin(); it != m_busDevices->End(); it++)
613 it->second->GetStatus(true);
614}
615
616bool CCECProcessor::GetDeviceInformation(const char *strPort, libcec_configuration *config, uint32_t iTimeoutMs /* = CEC_DEFAULT_CONNECT_TIMEOUT */)
617{
618 if (!OpenConnection(strPort, CEC_SERIAL_DEFAULT_BAUDRATE, iTimeoutMs, false))
619 return false;
620
621 config->iFirmwareVersion = m_communication->GetFirmwareVersion();
622 config->iPhysicalAddress = m_communication->GetPhysicalAddress();
623 config->iFirmwareBuildDate = m_communication->GetFirmwareBuildDate();
624 config->adapterType = m_communication->GetAdapterType();
625
626 Close();
627
628 return true;
629}
630
631bool CCECProcessor::TransmitPendingActiveSourceCommands(void)
632{
633 bool bReturn(true);
634 for (CECDEVICEMAP::iterator it = m_busDevices->Begin(); it != m_busDevices->End(); it++)
635 bReturn &= it->second->TransmitPendingActiveSourceCommands();
636 return bReturn;
637}
638
639CCECTV *CCECProcessor::GetTV(void) const
640{
641 return CCECBusDevice::AsTV(m_busDevices->At(CECDEVICE_TV));
642}
643
644CCECAudioSystem *CCECProcessor::GetAudioSystem(void) const
645{
646 return CCECBusDevice::AsAudioSystem(m_busDevices->At(CECDEVICE_AUDIOSYSTEM));
647}
648
649CCECPlaybackDevice *CCECProcessor::GetPlaybackDevice(cec_logical_address address) const
650{
651 return CCECBusDevice::AsPlaybackDevice(m_busDevices->At(address));
652}
653
654CCECRecordingDevice *CCECProcessor::GetRecordingDevice(cec_logical_address address) const
655{
656 return CCECBusDevice::AsRecordingDevice(m_busDevices->At(address));
657}
658
659CCECTuner *CCECProcessor::GetTuner(cec_logical_address address) const
660{
661 return CCECBusDevice::AsTuner(m_busDevices->At(address));
662}
663
664bool CCECProcessor::AllocateLogicalAddresses(CCECClient* client)
665{
666 libcec_configuration &configuration = *client->GetConfiguration();
667
668 // mark as unregistered
669 client->SetRegistered(false);
670
671 // unregister this client from the old addresses
672 CECDEVICEVEC devices;
673 m_busDevices->GetByLogicalAddresses(devices, configuration.logicalAddresses);
674 for (CECDEVICEVEC::const_iterator it = devices.begin(); it != devices.end(); it++)
675 {
676 // remove client entry
677 CLockObject lock(m_mutex);
678 m_clients.erase((*it)->GetLogicalAddress());
679 }
680
681 // find logical addresses for this client
682 if (!client->AllocateLogicalAddresses())
683 {
684 m_libcec->AddLog(CEC_LOG_ERROR, "failed to find a free logical address for the client");
685 return false;
686 }
687
688 // register this client on the new addresses
689 devices.clear();
690 m_busDevices->GetByLogicalAddresses(devices, configuration.logicalAddresses);
691 for (CECDEVICEVEC::const_iterator it = devices.begin(); it != devices.end(); it++)
692 {
693 // set the physical address of the device at this LA
694 if (CLibCEC::IsValidPhysicalAddress(configuration.iPhysicalAddress))
695 (*it)->SetPhysicalAddress(configuration.iPhysicalAddress);
696
697 // replace a previous client
698 CLockObject lock(m_mutex);
699 m_clients.erase((*it)->GetLogicalAddress());
700 m_clients.insert(make_pair<cec_logical_address, CCECClient *>((*it)->GetLogicalAddress(), client));
701 }
702
703 // set the new ackmask
704 SetLogicalAddresses(GetLogicalAddresses());
705
706 // resume outgoing communication
707 m_bStallCommunication = false;
708
709 return true;
710}
711
712uint16_t CCECProcessor::GetPhysicalAddressFromEeprom(void)
713{
714 libcec_configuration config; config.Clear();
715 if (m_communication)
716 m_communication->GetConfiguration(config);
717 return config.iPhysicalAddress;
718}
719
720bool CCECProcessor::RegisterClient(CCECClient *client)
721{
722 if (!client)
723 return false;
724
725 libcec_configuration &configuration = *client->GetConfiguration();
726
727 if (configuration.clientVersion < CEC_CLIENT_VERSION_2_0_0)
728 {
729 m_libcec->AddLog(CEC_LOG_ERROR, "failed to register a new CEC client: client version %s is no longer supported", ToString((cec_client_version)configuration.clientVersion));
730 return false;
731 }
732
733 if (configuration.bMonitorOnly == 1)
734 return true;
735
736 if (!CECInitialised())
737 {
738 m_libcec->AddLog(CEC_LOG_ERROR, "failed to register a new CEC client: CEC processor is not initialised");
739 return false;
740 }
741
742 // unregister the client first if it's already been marked as registered
743 if (client->IsRegistered())
744 UnregisterClient(client);
745
746 // ensure that controlled mode is enabled
747 m_communication->SetControlledMode(true);
748 m_bMonitor = false;
749
750 // source logical address for requests
751 cec_logical_address sourceAddress(CECDEVICE_UNREGISTERED);
752 if (!m_communication->SupportsSourceLogicalAddress(CECDEVICE_UNREGISTERED))
753 {
754 if (m_communication->SupportsSourceLogicalAddress(CECDEVICE_FREEUSE))
755 sourceAddress = CECDEVICE_FREEUSE;
756 else
757 {
758 m_libcec->AddLog(CEC_LOG_ERROR, "failed to register a new CEC client: both unregistered and free use are not supported by the device");
759 return false;
760 }
761 }
762
763 // ensure that we know the vendor id of the TV
764 CCECBusDevice *tv = GetTV();
765 cec_vendor_id tvVendor(tv->GetVendorId(sourceAddress));
766
767 // wait until the handler is replaced, to avoid double registrations
768 if (tvVendor != CEC_VENDOR_UNKNOWN &&
769 CCECCommandHandler::HasSpecificHandler(tvVendor))
770 {
771 while (!tv->ReplaceHandler(false))
772 CEvent::Sleep(5);
773 }
774
775 // get the configuration from the client
776 m_libcec->AddLog(CEC_LOG_NOTICE, "registering new CEC client - v%s", ToString((cec_client_version)configuration.clientVersion));
777
778 // get the current ackmask, so we can restore it if polling fails
779 cec_logical_addresses previousMask = GetLogicalAddresses();
780
781 // mark as uninitialised
782 client->SetInitialised(false);
783
784 // find logical addresses for this client
785 if (!AllocateLogicalAddresses(client))
786 {
787 m_libcec->AddLog(CEC_LOG_ERROR, "failed to register the new CEC client - cannot allocate the requested device types");
788 SetLogicalAddresses(previousMask);
789 return false;
790 }
791
792 // get the settings from the rom
793 if (configuration.bGetSettingsFromROM == 1)
794 {
795 libcec_configuration config; config.Clear();
796 m_communication->GetConfiguration(config);
797
798 CLockObject lock(m_mutex);
799 if (!config.deviceTypes.IsEmpty())
800 configuration.deviceTypes = config.deviceTypes;
801 if (CLibCEC::IsValidPhysicalAddress(config.iPhysicalAddress))
802 configuration.iPhysicalAddress = config.iPhysicalAddress;
803 snprintf(configuration.strDeviceName, 13, "%s", config.strDeviceName);
804 }
805
806 // set the firmware version and build date
807 configuration.serverVersion = LIBCEC_VERSION_CURRENT;
808 configuration.iFirmwareVersion = m_communication->GetFirmwareVersion();
809 configuration.iFirmwareBuildDate = m_communication->GetFirmwareBuildDate();
810 configuration.adapterType = m_communication->GetAdapterType();
811
812 // mark the client as registered
813 client->SetRegistered(true);
814
815 sourceAddress = client->GetPrimaryLogicalAdddress();
816
817 // initialise the client
818 bool bReturn = client->OnRegister();
819
820 // log the new registration
821 CStdString strLog;
822 strLog.Format("%s: %s", bReturn ? "CEC client registered" : "failed to register the CEC client", client->GetConnectionInfo().c_str());
823 m_libcec->AddLog(bReturn ? CEC_LOG_NOTICE : CEC_LOG_ERROR, strLog);
824
825 // display a warning if the firmware can be upgraded
826 if (bReturn && !IsRunningLatestFirmware())
827 {
828 const char *strUpgradeMessage = "The firmware of this adapter can be upgraded. Please visit http://blog.pulse-eight.com/ for more information.";
829 m_libcec->AddLog(CEC_LOG_WARNING, strUpgradeMessage);
830 libcec_parameter param;
831 param.paramData = (void*)strUpgradeMessage; param.paramType = CEC_PARAMETER_TYPE_STRING;
832 client->Alert(CEC_ALERT_SERVICE_DEVICE, param);
833 }
834
835 // ensure that the command handler for the TV is initialised
836 if (bReturn)
837 {
838 CCECCommandHandler *handler = GetTV()->GetHandler();
839 if (handler)
840 handler->InitHandler();
841 GetTV()->MarkHandlerReady();
842 }
843
844 // report our OSD name to the TV, since some TVs don't request it
845 client->GetPrimaryDevice()->TransmitOSDName(CECDEVICE_TV, false);
846
847 // request the power status of the TV
848 tv->RequestPowerStatus(sourceAddress, true);
849
850 return bReturn;
851}
852
853bool CCECProcessor::UnregisterClient(CCECClient *client)
854{
855 if (!client)
856 return false;
857
858 if (client->IsRegistered())
859 m_libcec->AddLog(CEC_LOG_NOTICE, "unregistering client: %s", client->GetConnectionInfo().c_str());
860
861 // notify the client that it will be unregistered
862 client->OnUnregister();
863
864 {
865 CLockObject lock(m_mutex);
866 // find all devices that match the LA's of this client
867 CECDEVICEVEC devices;
868 m_busDevices->GetByLogicalAddresses(devices, client->GetConfiguration()->logicalAddresses);
869 for (CECDEVICEVEC::const_iterator it = devices.begin(); it != devices.end(); it++)
870 {
871 // find the client
872 map<cec_logical_address, CCECClient *>::iterator entry = m_clients.find((*it)->GetLogicalAddress());
873 // unregister the client
874 if (entry != m_clients.end())
875 m_clients.erase(entry);
876
877 // reset the device status
878 (*it)->ResetDeviceStatus(true);
879 }
880 }
881
882 // set the new ackmask
883 cec_logical_addresses addresses = GetLogicalAddresses();
884 if (SetLogicalAddresses(addresses))
885 {
886 // no more clients left, disable controlled mode
887 if (addresses.IsEmpty() && !m_bMonitor)
888 m_communication->SetControlledMode(false);
889
890 return true;
891 }
892
893 return false;
894}
895
896void CCECProcessor::UnregisterClients(void)
897{
898 m_libcec->AddLog(CEC_LOG_DEBUG, "unregistering all CEC clients");
899
900 vector<CCECClient *> clients = m_libcec->GetClients();
901 for (vector<CCECClient *>::iterator client = clients.begin(); client != clients.end(); client++)
902 UnregisterClient(*client);
903
904 CLockObject lock(m_mutex);
905 m_clients.clear();
906}
907
908CCECClient *CCECProcessor::GetClient(const cec_logical_address address)
909{
910 CLockObject lock(m_mutex);
911 map<cec_logical_address, CCECClient *>::const_iterator client = m_clients.find(address);
912 if (client != m_clients.end())
913 return client->second;
914 return NULL;
915}
916
917CCECClient *CCECProcessor::GetPrimaryClient(void)
918{
919 CLockObject lock(m_mutex);
920 map<cec_logical_address, CCECClient *>::const_iterator client = m_clients.begin();
921 if (client != m_clients.end())
922 return client->second;
923 return NULL;
924}
925
926CCECBusDevice *CCECProcessor::GetPrimaryDevice(void)
927{
928 return m_busDevices->At(GetLogicalAddress());
929}
930
931cec_logical_address CCECProcessor::GetLogicalAddress(void)
932{
933 cec_logical_addresses addresses = GetLogicalAddresses();
934 return addresses.primary;
935}
936
937cec_logical_addresses CCECProcessor::GetLogicalAddresses(void)
938{
939 CLockObject lock(m_mutex);
940 cec_logical_addresses addresses;
941 addresses.Clear();
942 for (map<cec_logical_address, CCECClient *>::const_iterator client = m_clients.begin(); client != m_clients.end(); client++)
943 addresses.Set(client->first);
944
945 return addresses;
946}
947
948bool CCECProcessor::IsHandledByLibCEC(const cec_logical_address address) const
949{
950 CCECBusDevice *device = GetDevice(address);
951 return device && device->IsHandledByLibCEC();
952}
953
954bool CCECProcessor::IsRunningLatestFirmware(void)
955{
956 return m_communication && m_communication->IsOpen() ?
957 m_communication->IsRunningLatestFirmware() :
958 true;
959}
960
961void CCECProcessor::SwitchMonitoring(bool bSwitchTo)
962{
963 {
964 CLockObject lock(m_mutex);
965 m_bMonitor = bSwitchTo;
966 }
967 if (bSwitchTo)
968 UnregisterClients();
969}
970
971void CCECProcessor::HandleLogicalAddressLost(cec_logical_address oldAddress)
972{
973 // stall outgoing messages until we know our new LA
974 m_bStallCommunication = true;
975
976 m_libcec->AddLog(CEC_LOG_NOTICE, "logical address %x was taken by another device, allocating a new address", oldAddress);
977 CCECClient* client = GetClient(oldAddress);
978 if (!client)
979 client = GetPrimaryClient();
980 if (client)
981 {
982 if (m_addrAllocator)
983 while (m_addrAllocator->IsRunning()) Sleep(5);
984 delete m_addrAllocator;
985
986 m_addrAllocator = new CCECAllocateLogicalAddress(this, client);
987 m_addrAllocator->CreateThread();
988 }
989}
990
991void CCECProcessor::HandlePhysicalAddressChanged(uint16_t iNewAddress)
992{
993 m_libcec->AddLog(CEC_LOG_NOTICE, "physical address changed to %04x", iNewAddress);
994 CCECClient* client = GetPrimaryClient();
995 if (client)
996 client->SetPhysicalAddress(iNewAddress);
997}
998
999uint16_t CCECProcessor::GetAdapterVendorId(void) const
1000{
1001 return m_communication ? m_communication->GetAdapterVendorId() : 0;
1002}
1003
1004uint16_t CCECProcessor::GetAdapterProductId(void) const
1005{
1006 return m_communication ? m_communication->GetAdapterProductId() : 0;
1007}
1008
1009CCECAllocateLogicalAddress::CCECAllocateLogicalAddress(CCECProcessor* processor, CCECClient* client) :
1010 m_processor(processor),
1011 m_client(client) { }
1012
1013void* CCECAllocateLogicalAddress::Process(void)
1014{
1015 m_processor->AllocateLogicalAddresses(m_client);
1016 return NULL;
1017}