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 #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     ///}
  92
  93     bool ProvidesExtendedResponse(void);
  94
  95     void *Process(void);
  96
  97   private:
  98     /*!
  99      * @brief Clear all input bytes.
 100      * @param iTimeout Timeout when anything was received.
 101      */
 102     void ClearInputBytes(uint32_t iTimeout = CEC_CLEAR_INPUT_DEFAULT_WAIT);
 103
 104     /*!
 105      * @brief Change the current CEC line timeout.
 106      * @param iTimeout The new timeout.
 107      * @return True when acked by the controller, false otherwise.
 108      */
 109     bool SetLineTimeout(uint8_t iTimeout);
 110
 111     /*!
 112      * @brief Send a command to the controller and wait for an ack.
 113      * @param msgCode The command to send.
 114      * @param params The parameters to the command.
 115      * @param bIsRetry True when this command is being retried, false otherwise.
 116      * @return The message. Delete when done with it.
 117      */
 118     CCECAdapterMessage *SendCommand(cec_adapter_messagecode msgCode, CCECAdapterMessage &params, bool bIsRetry = false);
 119
 120     /*!
 121      * @brief Change the "initialised" status.
 122      * @param bSetTo The new value.
 123      */
 124     void SetInitialised(bool bSetTo = true);
 125
 126     /*!
 127      * @return True when initialised, false otherwise.
 128      */
 129     bool IsInitialised(void);
 130
 131     /*!
 132      * @brief Pings the adapter, checks the firmware version and sets controlled mode.
 133      * @param iTimeoutMs The timeout after which this fails if no proper data was received.
 134      * @return True when the checks passed, false otherwise.
 135      */
 136     bool CheckAdapter(uint32_t iTimeoutMs = CEC_DEFAULT_CONNECT_TIMEOUT);
 137
 138     /*!
 139      * @brief Handle a poll message inside the adapter message (checks if one is present).
 140      * @param msg The adapter message to parse.
 141      * @return True when the message resulted in a CEC error, false otherwise.
 142      */
 143     bool HandlePoll(const CCECAdapterMessage &msg);
 144
 145     /*!
 146      * @brief Read data from the device.
 147      * @param iTimeout The read timeout to use.
 148      * @param iSize The maximum read size.
 149      * @return True when something was read, false otherwise.
 150      */
 151     bool ReadFromDevice(uint32_t iTimeout, size_t iSize = 256);
 152
 153     /*!
 154      * @brief Writes a message to the serial port.
 155      * @param message The message to write.
 156      * @return True when written, false otherwise.
 157      */
 158     bool WriteToDevice(CCECAdapterMessage *message);
 159
 160     /*!
 161      * @brief Called before sending a CEC command over the line, so we know we're expecting an ack.
 162      * @param dest The destination of the CEC command.
 163      */
 164     void MarkAsWaiting(const cec_logical_address dest);
 165
 166     /*!
 167      * @brief Clear and reset the message queue.
 168      */
 169     void ResetMessageQueue(void);
 170
 171     PLATFORM::ISocket *                          m_port;                 /**< the com port connection */
 172     PLATFORM::CMutex                             m_mutex;                /**< mutex for changes in this class */
 173     uint8_t                                      m_iLineTimeout;         /**< the current line timeout on the CEC line */
 174     cec_logical_address                          m_lastPollDestination;  /**< the destination of the last poll message that was received */
 175     bool                                         m_bInitialised;         /**< true when the connection is initialised, false otherwise */
 176     bool                                         m_bWaitingForAck[15];   /**< array in which we store from which devices we're expecting acks */
 177     CAdapterPingThread *                         m_pingThread;           /**< ping thread, that pings the adapter every 15 seconds */
 178     CAdapterEepromWriteThread *                  m_eepromWriteThread;    /**< eeprom writes are done async */
 179     CUSBCECAdapterCommands *                     m_commands;             /**< commands that can be sent to the adapter */
 180     CCECAdapterMessageQueue *                    m_adapterMessageQueue;  /**< the incoming and outgoing message queue */
 181     cec_logical_addresses                        m_logicalAddresses;     /**< the logical address list that this instance is using */
 182   };
 183
 184   class CAdapterEepromWriteThread : public PLATFORM::CThread
 185   {
 186   public:
 187     CAdapterEepromWriteThread(CUSBCECAdapterCommunication *com) :
 188         m_com(com),
 189         m_bWrite(false),
 190         m_iLastEepromWrite(0),
 191         m_iScheduleEepromWrite(0) {}
 192     virtual ~CAdapterEepromWriteThread(void) {}
 193
 194     bool Write(void);
 195     void* Process(void);
 196     void Stop(void);
 197   private:
 198     CUSBCECAdapterCommunication *m_com;
 199     bool                         m_bWrite;
 200     PLATFORM::CCondition<bool>   m_condition;
 201     PLATFORM::CMutex             m_mutex;
 202     int64_t                      m_iLastEepromWrite;     /**< last time that this instance did an eeprom write */
 203     int64_t                      m_iScheduleEepromWrite; /**< in case there were more than 2 changes within 30 seconds, do another write at this time */
 204   };
 205
 206   class CAdapterPingThread : public PLATFORM::CThread
 207   {
 208   public:
 209     CAdapterPingThread(CUSBCECAdapterCommunication *com, uint32_t iTimeout) :
 210         m_com(com),
 211         m_timeout(iTimeout){}
 212     virtual ~CAdapterPingThread(void) {}
 213
 214     void* Process(void);
 215   private:
 216     CUSBCECAdapterCommunication *m_com;
 217     PLATFORM::CTimeout           m_timeout;
 218   };
 219 };