[deb_libcec.git] / src / lib / adapter / Pulse-Eight / USBCECAdapterCommunication.h

#pragma once
/*
 * This file is part of the libCEC(R) library.
 *
 * libCEC(R) is Copyright (C) 2011-2013 Pulse-Eight Limited.  All rights reserved.
 * libCEC(R) is an original work, containing original code.
 *
 * libCEC(R) is a trademark of Pulse-Eight Limited.
 *
 * This program is dual-licensed; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 *
 * Alternatively, you can license this library under a commercial license,
 * please contact Pulse-Eight Licensing for more information.
 *
 * For more information contact:
 * Pulse-Eight Licensing       <license@pulse-eight.com>
 *     http://www.pulse-eight.com/
 *     http://www.pulse-eight.net/
 */

#include "lib/platform/threads/threads.h"
#include "lib/adapter/AdapterCommunication.h"
#include "USBCECAdapterMessage.h"

namespace PLATFORM
{
  class ISocket;
}

namespace CEC
{
  class CCECProcessor;
  class CAdapterPingThread;
  class CAdapterEepromWriteThread;
  class CUSBCECAdapterCommands;
  class CCECAdapterMessageQueue;
  class CCECAdapterMessage;

  class CUSBCECAdapterCommunication : public IAdapterCommunication, public PLATFORM::CThread
  {
    friend class CUSBCECAdapterCommands;
    friend class CCECAdapterMessageQueue;
    friend class CAdapterEepromWriteThread;

  public:
    /*!
     * @brief Create a new USB-CEC communication handler.
     * @param callback The callback to use for incoming CEC commands.
     * @param strPort The name of the com port to use.
     * @param iBaudRate The baudrate to use on the com port connection.
     */
    CUSBCECAdapterCommunication(IAdapterCommunicationCallback *callback, const char *strPort, uint16_t iBaudRate = CEC_SERIAL_DEFAULT_BAUDRATE);
    virtual ~CUSBCECAdapterCommunication(void);

    /** @name IAdapterCommunication implementation */
    ///{
    bool Open(uint32_t iTimeoutMs = CEC_DEFAULT_CONNECT_TIMEOUT, bool bSkipChecks = false, bool bStartListening = true);
    void Close(void);
    bool IsOpen(void);
    std::string GetError(void) const;
    cec_adapter_message_state Write(const cec_command &data, bool &bRetry, uint8_t iLineTimeout, bool bIsReply);

    bool StartBootloader(void);
    bool SetLogicalAddresses(const cec_logical_addresses &addresses);
    cec_logical_addresses GetLogicalAddresses(void);
    bool PingAdapter(void);
    uint16_t GetFirmwareVersion(void);
    uint32_t GetFirmwareBuildDate(void);
    bool IsRunningLatestFirmware(void);
    bool PersistConfiguration(const libcec_configuration &configuration);
    bool GetConfiguration(libcec_configuration &configuration);
    std::string GetPortName(void);
    uint16_t GetPhysicalAddress(void);
    bool SetControlledMode(bool controlled);
    cec_vendor_id GetVendorId(void) { return CEC_VENDOR_UNKNOWN; }
    bool SupportsSourceLogicalAddress(const cec_logical_address UNUSED(address)) { return true; }
    cec_adapter_type GetAdapterType(void);
    uint16_t GetAdapterVendorId(void) const;
    uint16_t GetAdapterProductId(void) const;
    void SetActiveSource(bool bSetTo, bool bClientUnregistered);
    ///}

    bool ProvidesExtendedResponse(void);

    void *Process(void);

  private:
    /*!
     * @brief Clear all input bytes.
     * @param iTimeout Timeout when anything was received.
     */
    void ClearInputBytes(uint32_t iTimeout = CEC_CLEAR_INPUT_DEFAULT_WAIT);

    /*!
     * @brief Change the current CEC line timeout.
     * @param iTimeout The new timeout.
     * @return True when acked by the controller, false otherwise.
     */
    bool SetLineTimeout(uint8_t iTimeout);

    /*!
     * @brief Send a command to the controller and wait for an ack.
     * @param msgCode The command to send.
     * @param params The parameters to the command.
     * @param bIsRetry True when this command is being retried, false otherwise.
     * @return The message. Delete when done with it.
     */
    CCECAdapterMessage *SendCommand(cec_adapter_messagecode msgCode, CCECAdapterMessage &params, bool bIsRetry = false);

    /*!
     * @brief Change the "initialised" status.
     * @param bSetTo The new value.
     */
    void SetInitialised(bool bSetTo = true);

    /*!
     * @return True when initialised, false otherwise.
     */
    bool IsInitialised(void);

    /*!
     * @brief Pings the adapter, checks the firmware version and sets controlled mode.
     * @param iTimeoutMs The timeout after which this fails if no proper data was received.
     * @return True when the checks passed, false otherwise.
     */
    bool CheckAdapter(uint32_t iTimeoutMs = CEC_DEFAULT_CONNECT_TIMEOUT);

    /*!
     * @brief Handle a poll message inside the adapter message (checks if one is present).
     * @param msg The adapter message to parse.
     * @return True when the message resulted in a CEC error, false otherwise.
     */
    bool HandlePoll(const CCECAdapterMessage &msg);

    /*!
     * @brief Read data from the device.
     * @param iTimeout The read timeout to use.
     * @param iSize The maximum read size.
     * @return True when something was read, false otherwise.
     */
    bool ReadFromDevice(uint32_t iTimeout, size_t iSize = 256);

    /*!
     * @brief Writes a message to the serial port.
     * @param message The message to write.
     * @return True when written, false otherwise.
     */
    bool WriteToDevice(CCECAdapterMessage *message);

    /*!
     * @brief Called before sending a CEC command over the line, so we know we're expecting an ack.
     * @param dest The destination of the CEC command.
     */
    void MarkAsWaiting(const cec_logical_address dest);

    /*!
     * @brief Clear and reset the message queue.
     */
    void ResetMessageQueue(void);

    PLATFORM::ISocket *                          m_port;                 /**< the com port connection */
    PLATFORM::CMutex                             m_mutex;                /**< mutex for changes in this class */
    uint8_t                                      m_iLineTimeout;         /**< the current line timeout on the CEC line */
    cec_logical_address                          m_lastPollDestination;  /**< the destination of the last poll message that was received */
    bool                                         m_bInitialised;         /**< true when the connection is initialised, false otherwise */
    bool                                         m_bWaitingForAck[15];   /**< array in which we store from which devices we're expecting acks */
    CAdapterPingThread *                         m_pingThread;           /**< ping thread, that pings the adapter every 15 seconds */
    CAdapterEepromWriteThread *                  m_eepromWriteThread;    /**< eeprom writes are done async */
    CUSBCECAdapterCommands *                     m_commands;             /**< commands that can be sent to the adapter */
    CCECAdapterMessageQueue *                    m_adapterMessageQueue;  /**< the incoming and outgoing message queue */
    cec_logical_addresses                        m_logicalAddresses;     /**< the logical address list that this instance is using */
    PLATFORM::CMutex                             m_waitingMutex;
  };

  class CAdapterEepromWriteThread : public PLATFORM::CThread
  {
  public:
    CAdapterEepromWriteThread(CUSBCECAdapterCommunication *com) :
        m_com(com),
        m_bWrite(false),
        m_iLastEepromWrite(0),
        m_iScheduleEepromWrite(0) {}
    virtual ~CAdapterEepromWriteThread(void) {}

    bool Write(void);
    void* Process(void);
    void Stop(void);
  private:
    CUSBCECAdapterCommunication *m_com;
    bool                         m_bWrite;
    PLATFORM::CCondition<bool>   m_condition;
    PLATFORM::CMutex             m_mutex;
    int64_t                      m_iLastEepromWrite;     /**< last time that this instance did an eeprom write */
    int64_t                      m_iScheduleEepromWrite; /**< in case there were more than 2 changes within 30 seconds, do another write at this time */
  };

  class CAdapterPingThread : public PLATFORM::CThread
  {
  public:
    CAdapterPingThread(CUSBCECAdapterCommunication *com, uint32_t iTimeout) :
        m_com(com),
        m_timeout(iTimeout){}
    virtual ~CAdapterPingThread(void) {}

    void* Process(void);
  private:
    CUSBCECAdapterCommunication *m_com;
    PLATFORM::CTimeout           m_timeout;
  };
};
Commit	Line	Data
cbbe90dd JB	1	#pragma once
	2	/*
	3	* This file is part of the libCEC(R) library.
	4	*
	5	* libCEC(R) is Copyright (C) 2011-2013 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	#include "USBCECAdapterMessage.h"
	37
	38	namespace PLATFORM
	39	{
	40	class ISocket;
	41	}
	42
	43	namespace CEC
	44	{
	45	class CCECProcessor;
	46	class CAdapterPingThread;
	47	class CAdapterEepromWriteThread;
	48	class CUSBCECAdapterCommands;
	49	class CCECAdapterMessageQueue;
	50	class CCECAdapterMessage;
	51
	52	class CUSBCECAdapterCommunication : public IAdapterCommunication, public PLATFORM::CThread
	53	{
	54	friend class CUSBCECAdapterCommands;
	55	friend class CCECAdapterMessageQueue;
	56	friend class CAdapterEepromWriteThread;
	57
	58	public:
	59	/*!
	60	* @brief Create a new USB-CEC communication handler.
	61	* @param callback The callback to use for incoming CEC commands.
	62	* @param strPort The name of the com port to use.
	63	* @param iBaudRate The baudrate to use on the com port connection.
	64	*/
65	CUSBCECAdapterCommunication(IAdapterCommunicationCallback callback, const char strPort, uint16_t iBaudRate = CEC_SERIAL_DEFAULT_BAUDRATE);
66	virtual ~CUSBCECAdapterCommunication(void);
67
68	/** @name IAdapterCommunication implementation */
69	///{
70	bool Open(uint32_t iTimeoutMs = CEC_DEFAULT_CONNECT_TIMEOUT, bool bSkipChecks = false, bool bStartListening = true);
71	void Close(void);
72	bool IsOpen(void);
73	std::string GetError(void) const;
74	cec_adapter_message_state Write(const cec_command &data, bool &bRetry, uint8_t iLineTimeout, bool bIsReply);
75
76	bool StartBootloader(void);
77	bool SetLogicalAddresses(const cec_logical_addresses &addresses);
78	cec_logical_addresses GetLogicalAddresses(void);
79	bool PingAdapter(void);
80	uint16_t GetFirmwareVersion(void);
81	uint32_t GetFirmwareBuildDate(void);
82	bool IsRunningLatestFirmware(void);
83	bool PersistConfiguration(const libcec_configuration &configuration);
84	bool GetConfiguration(libcec_configuration &configuration);
85	std::string GetPortName(void);
86	uint16_t GetPhysicalAddress(void);
87	bool SetControlledMode(bool controlled);
88	cec_vendor_id GetVendorId(void) { return CEC_VENDOR_UNKNOWN; }
89	bool SupportsSourceLogicalAddress(const cec_logical_address UNUSED(address)) { return true; }
90	cec_adapter_type GetAdapterType(void);
91	uint16_t GetAdapterVendorId(void) const;
92	uint16_t GetAdapterProductId(void) const;
93	void SetActiveSource(bool bSetTo, bool bClientUnregistered);
94	///}
95
96	bool ProvidesExtendedResponse(void);
97
98	void *Process(void);
99
100	private:
101	/*!
102	* @brief Clear all input bytes.
103	* @param iTimeout Timeout when anything was received.
104	*/
105	void ClearInputBytes(uint32_t iTimeout = CEC_CLEAR_INPUT_DEFAULT_WAIT);
106
107	/*!
108	* @brief Change the current CEC line timeout.
109	* @param iTimeout The new timeout.
110	* @return True when acked by the controller, false otherwise.
111	*/
112	bool SetLineTimeout(uint8_t iTimeout);
113
114	/*!
115	* @brief Send a command to the controller and wait for an ack.
116	* @param msgCode The command to send.
117	* @param params The parameters to the command.
118	* @param bIsRetry True when this command is being retried, false otherwise.
119	* @return The message. Delete when done with it.
120	*/
121	CCECAdapterMessage *SendCommand(cec_adapter_messagecode msgCode, CCECAdapterMessage &params, bool bIsRetry = false);
122
123	/*!
124	* @brief Change the "initialised" status.
125	* @param bSetTo The new value.
126	*/
127	void SetInitialised(bool bSetTo = true);
128
129	/*!
130	* @return True when initialised, false otherwise.
131	*/
132	bool IsInitialised(void);
133
134	/*!
135	* @brief Pings the adapter, checks the firmware version and sets controlled mode.
136	* @param iTimeoutMs The timeout after which this fails if no proper data was received.
137	* @return True when the checks passed, false otherwise.
138	*/
139	bool CheckAdapter(uint32_t iTimeoutMs = CEC_DEFAULT_CONNECT_TIMEOUT);
140
141	/*!
142	* @brief Handle a poll message inside the adapter message (checks if one is present).
143	* @param msg The adapter message to parse.
144	* @return True when the message resulted in a CEC error, false otherwise.
145	*/
146	bool HandlePoll(const CCECAdapterMessage &msg);
147
148	/*!
149	* @brief Read data from the device.
150	* @param iTimeout The read timeout to use.
151	* @param iSize The maximum read size.
152	* @return True when something was read, false otherwise.
153	*/
154	bool ReadFromDevice(uint32_t iTimeout, size_t iSize = 256);
155
156	/*!
157	* @brief Writes a message to the serial port.
158	* @param message The message to write.
159	* @return True when written, false otherwise.
160	*/
161	bool WriteToDevice(CCECAdapterMessage *message);
162
163	/*!
164	* @brief Called before sending a CEC command over the line, so we know we're expecting an ack.
165	* @param dest The destination of the CEC command.
166	*/
167	void MarkAsWaiting(const cec_logical_address dest);
168
169	/*!
170	* @brief Clear and reset the message queue.
171	*/
172	void ResetMessageQueue(void);
173
174	PLATFORM::ISocket * m_port; /*< the com port connection /
175	PLATFORM::CMutex m_mutex; /*< mutex for changes in this class /
176	uint8_t m_iLineTimeout; /*< the current line timeout on the CEC line /
177	cec_logical_address m_lastPollDestination; /*< the destination of the last poll message that was received /
178	bool m_bInitialised; /*< true when the connection is initialised, false otherwise /
179	bool m_bWaitingForAck[15]; /*< array in which we store from which devices we're expecting acks /
180	CAdapterPingThread * m_pingThread; /*< ping thread, that pings the adapter every 15 seconds /
181	CAdapterEepromWriteThread * m_eepromWriteThread; /*< eeprom writes are done async /
182	CUSBCECAdapterCommands * m_commands; /*< commands that can be sent to the adapter /
183	CCECAdapterMessageQueue * m_adapterMessageQueue; /*< the incoming and outgoing message queue /
184	cec_logical_addresses m_logicalAddresses; /*< the logical address list that this instance is using /
185	PLATFORM::CMutex m_waitingMutex;
186	};
187
188	class CAdapterEepromWriteThread : public PLATFORM::CThread
189	{
190	public:
191	CAdapterEepromWriteThread(CUSBCECAdapterCommunication *com) :
192	m_com(com),
193	m_bWrite(false),
194	m_iLastEepromWrite(0),
195	m_iScheduleEepromWrite(0) {}
196	virtual ~CAdapterEepromWriteThread(void) {}
197
198	bool Write(void);
199	void* Process(void);
200	void Stop(void);
201	private:
202	CUSBCECAdapterCommunication *m_com;
203	bool m_bWrite;
204	PLATFORM::CCondition<bool> m_condition;
205	PLATFORM::CMutex m_mutex;
206	int64_t m_iLastEepromWrite; /*< last time that this instance did an eeprom write /
207	int64_t m_iScheduleEepromWrite; /*< in case there were more than 2 changes within 30 seconds, do another write at this time /
208	};
209
210	class CAdapterPingThread : public PLATFORM::CThread
211	{
212	public:
213	CAdapterPingThread(CUSBCECAdapterCommunication *com, uint32_t iTimeout) :
214	m_com(com),
215	m_timeout(iTimeout){}
216	virtual ~CAdapterPingThread(void) {}
217
218	void* Process(void);
219	private:
220	CUSBCECAdapterCommunication *m_com;
221	PLATFORM::CTimeout m_timeout;
222	};
223	};