simplebase.hxx

// dawn/include/dawn/proto/simplebase.hxx
//
// SPDX-License-Identifier: Apache-2.0
//
 
#pragma once
 
#include <cstddef>
#include <cstdint>
#include <mutex>
#include <set>
#include <vector>
 
#include "dawn/porting/config.hxx"
#include "dawn/proto/common.hxx"
 
namespace dawn
{
// Forward declaration
 
class CIOCommon;
struct io_ddata_t;
 
class CProtoSimpleBase : public CProtoCommon
{
public:
  static constexpr uint8_t FRAME_SYNC = 0xAA;
  static constexpr uint8_t FRAME_MIN_LEN = 6;
  static constexpr size_t FRAME_MAX_PAYLOAD = 1024;
 
  static constexpr size_t SEEK_HDR_SIZE = 8;
  static constexpr size_t SEEK_CHUNK_CAP = FRAME_MAX_PAYLOAD - SEEK_HDR_SIZE;
 
  enum
  {
    CMD_PING = 0x00,
    CMD_PONG = 0x01,
    CMD_GET_IO = 0x10,
    CMD_SET_IO = 0x11,
    CMD_GET_IO_SEEK = 0x14,
    CMD_SET_IO_SEEK = 0x15,
    CMD_GET_CFG = 0x12,
    CMD_SET_CFG = 0x13,
    CMD_GET_INFO = 0x20,
    CMD_LIST_IOS = 0x21,
    CMD_SUBSCRIBE = 0x30,
    CMD_UNSUBSCRIBE = 0x31,
    CMD_NOTIFY = 0xF0,
    CMD_ERROR = 0xFF,
  };
 
  enum
  {
    STATUS_OK = 0x00,
    STATUS_INVALID_CMD = 0x01,
    STATUS_INVALID_OBJ = 0x02,
    STATUS_INVALID_CFG = 0x03,
    STATUS_READ_ONLY = 0x04,
    STATUS_WRITE_ONLY = 0x05,
    STATUS_INVALID_FORMAT = 0x06,
    STATUS_ERROR = 0xFF,
  };
 
  /* @brief I/O direction codes returned by the GET_INFO response */
 
  enum
  {
    IO_TYPE_READ_ONLY = 0x01,
    IO_TYPE_WRITE_ONLY = 0x02,
    IO_TYPE_READ_WRITE = 0x03,
  };
 
  struct
  {
    SObjectId::ObjectId objid;
  } typedef SProtoSimpleIOBind;
 
  explicit CProtoSimpleBase(CDescObject &desc)
    : CProtoCommon(desc)
    , initialized(false)
  {
  }
 
protected:
  struct
  {
    const SProtoSimpleIOBind *cfg;
    io_ddata_t *iodata;
  } typedef SProtoSimpleData;
 
#ifdef CONFIG_DAWN_IO_NOTIFY
  struct
  {
    SObjectId::ObjectId objid;
    CIOCommon *io;
    CProtoSimpleBase *proto;
  } typedef SProtoSimpleNotify;
#endif
 
  uint8_t rxbuffer[FRAME_MAX_PAYLOAD + FRAME_MIN_LEN]; //< Shared receive frame buffer
  bool initialized;                                    //< Initialization completion flag
  std::vector<SProtoSimpleIOBind *> iobinds; //< Vector of I/O bind configurations (from descriptor)
  std::vector<SProtoSimpleData *> iobuffers; //< Vector of runtime I/O data structures
 
#ifdef CONFIG_DAWN_IO_NOTIFY
  std::mutex subsMutex;                      //< Mutex for subscription set access
  std::set<SObjectId::ObjectId> subscriptions;      //< Set of subscribed IO object IDs
  std::vector<SProtoSimpleNotify *> notifyContexts; //< Vector of notification callback contexts
#endif
 
  uint16_t calculateCrc(const uint8_t *data, size_t len);
 
  int handleFrame(const uint8_t *frame, size_t len);
 
  void allocObject(SProtoSimpleIOBind *cfg);
 
  int createBuffers();
 
  int destroyBuffers();
 
#ifdef CONFIG_DAWN_IO_NOTIFY
  int setupNotifications();
 
  void cleanupNotifications();
 
  void destroyNotifications();
 
  static int notifierCb(void *priv, io_ddata_t *data);
#endif
 
  virtual int sendFrame(uint8_t cmd, const uint8_t *payload, size_t len) = 0;
 
private:
  io_ddata_t *findIOBuffer(SObjectId::ObjectId objid);
 
  void sendError(uint8_t error_code, uint8_t context);
 
  void cmdPing();
 
  void cmdGetIO(const uint8_t *payload, size_t len);
 
  void cmdSetIO(const uint8_t *payload, size_t len);
 
  void cmdGetIOSeek(const uint8_t *payload, size_t len);
 
  void cmdSetIOSeek(const uint8_t *payload, size_t len);
 
  void cmdGetCfg(const uint8_t *payload, size_t len);
 
  void cmdSetCfg(const uint8_t *payload, size_t len);
 
  void cmdGetInfo(const uint8_t *payload, size_t len);
 
  void cmdListIOs();
 
#ifdef CONFIG_DAWN_IO_NOTIFY
  void cmdSubscribe(const uint8_t *payload, size_t len);
 
  void cmdUnsubscribe(const uint8_t *payload, size_t len);
#endif
};
} // Namespace dawn