common.hxx

// dawn/include/dawn/io/common.hxx
//
// SPDX-License-Identifier: Apache-2.0
//
 
#pragma once
 
#include <cstdlib>
 
#include "dawn/common/object.hxx"
#include "dawn/debug.hxx"
#include "dawn/io/ddata.hxx"
#include "dawn/io/inotifier.hxx"
#include "dawn/io/limits.hxx"
#include "dawn/porting/config.hxx"
 
namespace dawn
{
class CIOCommon : public CObject
{
public:
#ifdef CONFIG_DAWN_IO_HAS_STATS
  struct SIOStats
  {
    uint32_t read_count;  
    uint32_t write_count; 
    uint32_t error_count; 
  } typedef IOStats;
 
  const IOStats &getStats() const
  {
    return stats;
  }
 
  void resetStats()
  {
    stats.read_count = 0;
    stats.write_count = 0;
    stats.error_count = 0;
  }
#endif // CONFIG_DAWN_IO_HAS_STATS
 
  enum
  {
    IO_FLAGS_NONE = 0,      
    IO_FLAGS_TS = (1 << 0), 
 
  } typedef EIOFlags;
 
  enum
  {
    IO_CLASS_ANY = 0, 
 
    // Special purpose IOs
 
    IO_CLASS_CONFIG = 1,         
    IO_CLASS_TRIGGER = 2,        
    IO_CLASS_DESCRIPTOR = 3,     
    IO_CLASS_CONTROL = 4,        
    IO_CLASS_CAPABILITIES = 53,  
    IO_CLASS_DESC_SELECTOR = 54, 
 
    // Dummy
 
    IO_CLASS_DUMMY = 5, 
 
    // Number generators
 
    IO_CLASS_TIMESTAMP = 6,    
    IO_CLASS_RAND = 7,         
    IO_CLASS_DUMMY_NOTIFY = 8, 
 
    // File I/O
 
    IO_CLASS_FILE = 9, 
 
    // Sensors
 
    IO_CLASS_SENSOR_ACCELEROMETER = 10, 
    IO_CLASS_SENSOR_MAGNETICFIELD = 11, 
    IO_CLASS_SENSOR_GYROSCOPE = 12,     
    IO_CLASS_SENSOR_LIGHT = 13,         
    IO_CLASS_SENSOR_BAROMETER = 14,     
    IO_CLASS_SENSOR_PROXIMITY = 15,     
    IO_CLASS_SENSOR_HUMIDITY = 16,      
    IO_CLASS_SENSOR_TEMPERATURE = 17,   
    IO_CLASS_SENSOR_ATEMPERATURE = 18,  
    IO_CLASS_SENSOR_RGB = 19,           
    IO_CLASS_SENSOR_IR = 20,            
    IO_CLASS_SENSOR_UV = 21,            
    IO_CLASS_SENSOR_GAS = 22,           
    IO_CLASS_SENSOR_CO2 = 23,           
    IO_CLASS_SENSOR_TVOC = 24,          
 
    // Sensor producers
 
    IO_CLASS_SENSOR_PRODUCER_ACCELEROMETER = 25, 
    IO_CLASS_SENSOR_PRODUCER_MAGNETICFIELD = 26, 
    IO_CLASS_SENSOR_PRODUCER_GYROSCOPE = 27,     
    IO_CLASS_SENSOR_PRODUCER_LIGHT = 28,         
    IO_CLASS_SENSOR_PRODUCER_BAROMETER = 29,     
    IO_CLASS_SENSOR_PRODUCER_PROXIMITY = 30,     
    IO_CLASS_SENSOR_PRODUCER_HUMIDITY = 31,      
    IO_CLASS_SENSOR_PRODUCER_TEMPERATURE = 32,   
    IO_CLASS_SENSOR_PRODUCER_ATEMPERATURE = 33,  
    IO_CLASS_SENSOR_PRODUCER_RGB = 34,           
    IO_CLASS_SENSOR_PRODUCER_IR = 35,            
    IO_CLASS_SENSOR_PRODUCER_UV = 36,            
    IO_CLASS_SENSOR_PRODUCER_GAS = 37,           
    IO_CLASS_SENSOR_PRODUCER_CO2 = 38,           
    IO_CLASS_SENSOR_PRODUCER_TVOC = 39,          
 
    // GNSS sensor (uORB sensor_gnss). Read-only, so it has no producer
    // counterpart and lives outside the aligned sensor/producer ranges above.
 
    IO_CLASS_SENSOR_GNSS = 40,            
    IO_CLASS_SENSOR_GNSS_TIME = 41,       
    IO_CLASS_SENSOR_GNSS_INFO = 42,       
    IO_CLASS_SENSOR_GNSS_SATELLITES = 43, 
 
    // there is 59 sensor types in Nuttx now, most likely it grows later
    // we still have many free slots, but in the future, it there are no free IO slots
    // we can thing about combining sensor and sensor producer
 
    // System information
 
    IO_CLASS_SYSTEM_UPTIME = 44,     
    IO_CLASS_SYSTEM_CPULOAD = 45,    
    IO_CLASS_SYSTEM_RESET = 46,      
    IO_CLASS_SYSTEM_RESETCAUSE = 47, 
    IO_CLASS_SYSTEM_POWEROFF = 48,   
    IO_CLASS_SYSTEM_HOSTNAME = 49,   
    IO_CLASS_SYSTEM_UUID = 50,       
    IO_CLASS_SYSTEM_SYSTEMTIME = 51, 
 
    // Slots 52-59 reserved for future system classes (serial number,
    // firmware version, firmware update, etc.).
 
    // GPIO
 
    IO_CLASS_GPI_SINGLE = 60, 
    IO_CLASS_GPO_SINGLE = 61, 
    IO_CLASS_BUTTONS = 62,    
    IO_CLASS_LEDS = 63,       
    IO_CLASS_RGBLED = 64,     
 
    // PWM / pulse output
 
    IO_CLASS_PWM = 78,        
    IO_CLASS_PULSECOUNT = 79, 
 
    // ADC/DAC
 
    IO_CLASS_DAC = 81,        
    IO_CLASS_ADC_FETCH = 82,  
    IO_CLASS_ADC_SYNC = 83,   
    IO_CLASS_ADC_STREAM = 84, 
 
    // Ecnoder input
 
    IO_CLASS_ENCODER = 85,       
    IO_CLASS_ENCODER_INDEX = 86, 
 
    // Battery (fuel gauge)
 
    IO_CLASS_BATTERY_VOLTAGE = 90, 
    IO_CLASS_BATTERY_SOC = 91,     
    IO_CLASS_BATTERY_STATE = 92,   
 
    // Cellular modem
 
    IO_CLASS_LTE_SIGNAL = 93, 
 
    // Virtual IO
 
    IO_CLASS_VIRT = 100, 
 
    // User defined
 
    IO_CLASS_USER_START = 500, 
    IO_CLASS_USER,             
 
    IO_CLASS_LAST              
  } typedef EIOClass;
 
  static_assert(IO_CLASS_LAST - 1 <= SObjectId::CLS_MAX);
 
  enum
  {
    IO_CFG_FIRST = 0,      
    IO_CFG_DEVNO = 1,      
    IO_CFG_LIMIT_MIN = 2,  
    IO_CFG_LIMIT_MAX = 3,  
    IO_CFG_LIMIT_STEP = 4, 
    IO_CFG_NOTIFY = 5,     
    IO_CFG_LAST = 31       
  };
 
  enum
  {
    IO_NOTIFY_POLL = 0,   
    IO_NOTIFY_STREAM = 1, 
  } typedef EIONotifyType;
 
  template<uint16_t CLASS_ID, uint8_t DEFAULT_DTYPE>
  class IOObjectIdHelper
  {
  public:
    constexpr static SObjectId::ObjectId create(bool ts, uint16_t inst)
    {
      uint8_t flags = 0;
 
#ifdef CONFIG_DAWN_IO_TIMESTAMP
      if (ts)
        {
          flags |= CIOCommon::IO_FLAGS_TS;
        }
#else
      DAWNASSERT(ts == false, "ts not supported");
#endif
 
      return SObjectId::objectId(SObjectId::OBJTYPE_IO, CLASS_ID, DEFAULT_DTYPE, flags, inst);
    }
 
    constexpr static SObjectId::ObjectId create(SObjectId::EObjectDataType dtype,
                                                bool ts,
                                                uint16_t inst)
    {
      uint8_t flags = 0;
 
#ifdef CONFIG_DAWN_IO_TIMESTAMP
      if (ts)
        {
          flags |= CIOCommon::IO_FLAGS_TS;
        }
#else
      DAWNASSERT(ts == false, "ts not supported");
#endif
 
      return SObjectId::objectId(SObjectId::OBJTYPE_IO, CLASS_ID, dtype, flags, inst);
    }
  };
 
  template<uint16_t CLASS_ID, uint8_t DEFAULT_DTYPE>
  class IOObjectIdHelperNoTS
  {
  public:
    constexpr static SObjectId::ObjectId create(uint16_t inst)
    {
      return IOObjectIdHelper<CLASS_ID, DEFAULT_DTYPE>::create(false, inst);
    }
 
    constexpr static SObjectId::ObjectId create(SObjectId::EObjectDataType dtype, uint16_t inst)
    {
      return IOObjectIdHelper<CLASS_ID, DEFAULT_DTYPE>::create(dtype, false, inst);
    }
  };
 
  explicit CIOCommon(CDescObject &desc);
 
  int getData(IODataCmn &data, size_t len, size_t offset = 0)
  {
    int ret;
 
#ifdef CONFIG_DAWN_IO_SEEKABLE
    ret = isSeekable() ? getDataAtImpl(data, len, offset)
                       : (offset == 0 ? getDataImpl(data, len) : -ENOTSUP);
#else
    ret = (offset == 0) ? getDataImpl(data, len) : -ENOTSUP;
#endif
#ifdef CONFIG_DAWN_IO_HAS_STATS
    if (ret == OK)
      {
        if (offset == 0)
          {
            stats.read_count++;
          }
      }
    else if (ret != -ENOTSUP)
      {
        stats.error_count++;
      }
#endif
    return ret;
  }
 
  int setData(IODataCmn &data, size_t offset = 0)
  {
    int ret;
 
#ifdef CONFIG_DAWN_IO_SEEKABLE
    ret = isSeekable() ? setDataAtImpl(data, offset) : (offset == 0 ? setDataImpl(data) : -ENOTSUP);
#else
    ret = (offset == 0) ? setDataImpl(data) : -ENOTSUP;
#endif
#ifdef CONFIG_DAWN_IO_HAS_STATS
    if (ret == OK)
      {
        if (offset == 0)
          {
            stats.write_count++;
          }
      }
    else if (ret != -ENOTSUP)
      {
        stats.error_count++;
      }
#endif
    return ret;
  }
 
  virtual int getFd() const
  {
    return -ENOTSUP;
  };
 
  virtual size_t getDataSize() const = 0;
 
  virtual size_t getDataDim() const = 0;
 
  virtual bool isRead() const = 0;
 
  virtual bool isWrite() const = 0;
 
  virtual bool isNotify() const = 0;
 
  virtual bool isBatch() const = 0;
 
  bool isTimestamp() const;
 
  virtual bool isSeekable() const
  {
    return false;
  }
 
#ifdef CONFIG_DAWN_IO_NOTIFY
  void bindNotifier(IIONotifier *n);
 
  int setNotifier(IIONotifier::notifier_cb_t cb, int prio, void *priv);
#endif
 
  io_ddata_t *ddata_alloc(size_t batch, size_t chunk_size = 0);
 
  int getConfig(uint32_t cfgid, uint32_t *data, size_t len)
  {
    return this->getObjConfig(cfgid, data, len);
  };
 
  int setConfig(uint32_t cfgid, uint32_t *data, size_t len)
  {
    return this->setObjConfig(cfgid, data, len);
  };
 
  constexpr static SObjectCfg::ObjectCfgId cfgIdCmn(bool rw,
                                                    uint8_t dtype,
                                                    uint8_t size,
                                                    uint8_t id)
  {
    return SObjectCfg::objectCfg(
      SObjectId::OBJTYPE_IO, CIOCommon::IO_CLASS_ANY, dtype, rw, size, id);
  }
 
  constexpr static SObjectCfg::ObjectCfgId cfgIdDevno(bool rw = false)
  {
    return CIOCommon::cfgIdCmn(rw, SObjectId::DTYPE_UINT32, 1, IO_CFG_DEVNO);
  }
 
  constexpr static SObjectCfg::ObjectCfgId cfgIdLimitMin(uint8_t dtype, uint16_t size)
  {
    return CIOCommon::cfgIdCmn(false, dtype, size, IO_CFG_LIMIT_MIN);
  }
 
  constexpr static SObjectCfg::ObjectCfgId cfgIdLimitMax(uint8_t dtype, uint16_t size)
  {
    return CIOCommon::cfgIdCmn(false, dtype, size, IO_CFG_LIMIT_MAX);
  }
 
  constexpr static SObjectCfg::ObjectCfgId cfgIdLimitStep(uint8_t dtype, uint16_t size)
  {
    return CIOCommon::cfgIdCmn(false, dtype, size, IO_CFG_LIMIT_STEP);
  }
 
  constexpr static SObjectCfg::ObjectCfgId cfgIdNotify(bool rw = false)
  {
    return CIOCommon::cfgIdCmn(rw, SObjectId::DTYPE_UINT32, 3, IO_CFG_NOTIFY);
  }
 
#ifdef CONFIG_DAWN_IO_NOTIFY
  uint8_t getNotifyType() const
  {
    return notifyType;
  }
 
  int getNotifyPrio() const
  {
    return notifyPrio;
  }
 
  size_t getNotifyBatch() const
  {
    return notifyBatch;
  }
#endif
 
protected:
#ifdef CONFIG_DAWN_IO_NOTIFY
  IIONotifier *notifier;
#endif
 
  virtual int getDataImpl(IODataCmn &data, size_t len)
  {
    (void)data;
    (void)len;
    return -ENOTSUP;
  }
 
  virtual int setDataImpl(IODataCmn &data)
  {
    (void)data;
    return -ENOTSUP;
  }
 
  virtual int getDataAtImpl(IODataCmn &data, size_t len, size_t offset)
  {
    (void)data;
    (void)len;
    (void)offset;
    return -ENOTSUP;
  }
 
  virtual int setDataAtImpl(IODataCmn &data, size_t offset)
  {
    (void)data;
    (void)offset;
    return -ENOTSUP;
  }
 
#ifdef CONFIG_DAWN_IO_NOTIFY
  int notifyData(io_ddata_t *data);
#endif
 
  int getCmnDevno() const
  {
    return this->devno;
  }
 
  const uint32_t *getCmnLimitMin()
  {
    return this->limits.getMin();
  }
 
  const uint32_t *getCmnLimitMax()
  {
    return this->limits.getMax();
  }
 
  const uint32_t *getCmnLimitStep()
  {
    return this->limits.getStep();
  }
 
  size_t getCmnLimitWords()
  {
    return this->limits.getWords();
  }
 
  const CIOLimits &getCmnLimits() const
  {
    return this->limits;
  }
 
  size_t cfgCmnOffset(const SObjectCfg::SObjectCfgItem *cfg);
 
  uint64_t getTimestamp();
 
private:
  int devno;          
  CIOLimits limits;   
#ifdef CONFIG_DAWN_IO_NOTIFY
  uint8_t notifyType; 
  int notifyPrio;     
  size_t notifyBatch; 
#endif
#ifdef CONFIG_DAWN_IO_HAS_STATS
  IOStats stats;      
#endif
 
  int configureDesc(const CDescObject &desc);
};
} // Namespace dawn