Merge branch 'development'
[deb_libcec.git] / src / lib / adapter / Pulse-Eight / USBCECAdapterCommunication.h
1 #pragma once
2 /*
3 * This file is part of the libCEC(R) library.
4 *
5 * libCEC(R) is Copyright (C) 2011-2012 Pulse-Eight Limited. All rights reserved.
6 * libCEC(R) is an original work, containing original code.
7 *
8 * libCEC(R) is a trademark of Pulse-Eight Limited.
9 *
10 * This program is dual-licensed; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
23 *
24 *
25 * Alternatively, you can license this library under a commercial license,
26 * please contact Pulse-Eight Licensing for more information.
27 *
28 * For more information contact:
29 * Pulse-Eight Licensing <license@pulse-eight.com>
30 * http://www.pulse-eight.com/
31 * http://www.pulse-eight.net/
32 */
33
34 #include "lib/platform/threads/threads.h"
35 #include "lib/adapter/AdapterCommunication.h"
36
37 namespace PLATFORM
38 {
39 class ISocket;
40 }
41
42 namespace CEC
43 {
44 class CCECProcessor;
45 class CAdapterPingThread;
46 class CAdapterEepromWriteThread;
47 class CUSBCECAdapterCommands;
48 class CCECAdapterMessageQueue;
49 class CCECAdapterMessage;
50
51 class CUSBCECAdapterCommunication : public IAdapterCommunication, public PLATFORM::CThread
52 {
53 friend class CUSBCECAdapterCommands;
54 friend class CCECAdapterMessageQueue;
55 friend class CAdapterEepromWriteThread;
56
57 public:
58 /*!
59 * @brief Create a new USB-CEC communication handler.
60 * @param callback The callback to use for incoming CEC commands.
61 * @param strPort The name of the com port to use.
62 * @param iBaudRate The baudrate to use on the com port connection.
63 */
64 CUSBCECAdapterCommunication(IAdapterCommunicationCallback *callback, const char *strPort, uint16_t iBaudRate = CEC_SERIAL_DEFAULT_BAUDRATE);
65 virtual ~CUSBCECAdapterCommunication(void);
66
67 /** @name IAdapterCommunication implementation */
68 ///{
69 bool Open(uint32_t iTimeoutMs = CEC_DEFAULT_CONNECT_TIMEOUT, bool bSkipChecks = false, bool bStartListening = true);
70 void Close(void);
71 bool IsOpen(void);
72 std::string GetError(void) const;
73 cec_adapter_message_state Write(const cec_command &data, bool &bRetry, uint8_t iLineTimeout, bool bIsReply);
74
75 bool StartBootloader(void);
76 bool SetLogicalAddresses(const cec_logical_addresses &addresses);
77 cec_logical_addresses GetLogicalAddresses(void);
78 bool PingAdapter(void);
79 uint16_t GetFirmwareVersion(void);
80 uint32_t GetFirmwareBuildDate(void);
81 bool IsRunningLatestFirmware(void);
82 bool PersistConfiguration(const libcec_configuration &configuration);
83 bool GetConfiguration(libcec_configuration &configuration);
84 std::string GetPortName(void);
85 uint16_t GetPhysicalAddress(void);
86 bool SetControlledMode(bool controlled);
87 cec_vendor_id GetVendorId(void) { return CEC_VENDOR_UNKNOWN; }
88 bool SupportsSourceLogicalAddress(const cec_logical_address UNUSED(address)) { return true; }
89 ///}
90
91 bool ProvidesExtendedResponse(void);
92
93 void *Process(void);
94
95 private:
96 /*!
97 * @brief Clear all input bytes.
98 * @param iTimeout Timeout when anything was received.
99 */
100 void ClearInputBytes(uint32_t iTimeout = CEC_CLEAR_INPUT_DEFAULT_WAIT);
101
102 /*!
103 * @brief Change the current CEC line timeout.
104 * @param iTimeout The new timeout.
105 * @return True when acked by the controller, false otherwise.
106 */
107 bool SetLineTimeout(uint8_t iTimeout);
108
109 /*!
110 * @brief Send a command to the controller and wait for an ack.
111 * @param msgCode The command to send.
112 * @param params The parameters to the command.
113 * @param bIsRetry True when this command is being retried, false otherwise.
114 * @return The message. Delete when done with it.
115 */
116 CCECAdapterMessage *SendCommand(cec_adapter_messagecode msgCode, CCECAdapterMessage &params, bool bIsRetry = false);
117
118 /*!
119 * @brief Change the "initialised" status.
120 * @param bSetTo The new value.
121 */
122 void SetInitialised(bool bSetTo = true);
123
124 /*!
125 * @return True when initialised, false otherwise.
126 */
127 bool IsInitialised(void);
128
129 /*!
130 * @brief Pings the adapter, checks the firmware version and sets controlled mode.
131 * @param iTimeoutMs The timeout after which this fails if no proper data was received.
132 * @return True when the checks passed, false otherwise.
133 */
134 bool CheckAdapter(uint32_t iTimeoutMs = CEC_DEFAULT_CONNECT_TIMEOUT);
135
136 /*!
137 * @brief Handle a poll message inside the adapter message (checks if one is present).
138 * @param msg The adapter message to parse.
139 * @return True when the message resulted in a CEC error, false otherwise.
140 */
141 bool HandlePoll(const CCECAdapterMessage &msg);
142
143 /*!
144 * @brief Read data from the device.
145 * @param iTimeout The read timeout to use.
146 * @param iSize The maximum read size.
147 * @return True when something was read, false otherwise.
148 */
149 bool ReadFromDevice(uint32_t iTimeout, size_t iSize = 256);
150
151 /*!
152 * @brief Writes a message to the serial port.
153 * @param message The message to write.
154 * @return True when written, false otherwise.
155 */
156 bool WriteToDevice(CCECAdapterMessage *message);
157
158 /*!
159 * @brief Called before sending a CEC command over the line, so we know we're expecting an ack.
160 * @param dest The destination of the CEC command.
161 */
162 void MarkAsWaiting(const cec_logical_address dest);
163
164 /*!
165 * @brief Clear and reset the message queue.
166 */
167 void ResetMessageQueue(void);
168
169 PLATFORM::ISocket * m_port; /**< the com port connection */
170 PLATFORM::CMutex m_mutex; /**< mutex for changes in this class */
171 uint8_t m_iLineTimeout; /**< the current line timeout on the CEC line */
172 cec_logical_address m_lastPollDestination; /**< the destination of the last poll message that was received */
173 bool m_bInitialised; /**< true when the connection is initialised, false otherwise */
174 bool m_bWaitingForAck[15]; /**< array in which we store from which devices we're expecting acks */
175 CAdapterPingThread * m_pingThread; /**< ping thread, that pings the adapter every 15 seconds */
176 CAdapterEepromWriteThread * m_eepromWriteThread; /**< eeprom writes are done async */
177 CUSBCECAdapterCommands * m_commands; /**< commands that can be sent to the adapter */
178 CCECAdapterMessageQueue * m_adapterMessageQueue; /**< the incoming and outgoing message queue */
179 cec_logical_addresses m_logicalAddresses; /**< the logical address list that this instance is using */
180 };
181
182 class CAdapterEepromWriteThread : public PLATFORM::CThread
183 {
184 public:
185 CAdapterEepromWriteThread(CUSBCECAdapterCommunication *com) :
186 m_com(com),
187 m_bWrite(false),
188 m_iLastEepromWrite(0),
189 m_iScheduleEepromWrite(0) {}
190 virtual ~CAdapterEepromWriteThread(void) {}
191
192 bool Write(void);
193 void* Process(void);
194 void Stop(void);
195 private:
196 CUSBCECAdapterCommunication *m_com;
197 bool m_bWrite;
198 PLATFORM::CCondition<bool> m_condition;
199 PLATFORM::CMutex m_mutex;
200 int64_t m_iLastEepromWrite; /**< last time that this instance did an eeprom write */
201 int64_t m_iScheduleEepromWrite; /**< in case there were more than 2 changes within 30 seconds, do another write at this time */
202 };
203
204 class CAdapterPingThread : public PLATFORM::CThread
205 {
206 public:
207 CAdapterPingThread(CUSBCECAdapterCommunication *com, uint32_t iTimeout) :
208 m_com(com),
209 m_timeout(iTimeout){}
210 virtual ~CAdapterPingThread(void) {}
211
212 void* Process(void);
213 private:
214 CUSBCECAdapterCommunication *m_com;
215 PLATFORM::CTimeout m_timeout;
216 };
217 };