20 #include "cfg_subsys.h"
28 #define _MAX_VIRTUAL_BUF 256
32 typedef void (*VirtFunc)(
void ** ptr);
34 static inline void xsSubAndIdx(
int varID,
int * sub,
int * idx)
36 *sub = ( varID & VID_SUBSYS_MASK ) >> VID_SUBSYS_SHIFT;
37 *idx = ( varID & VID_VARIDX_MASK ) >> VID_VARIDX_SHIFT;
41 static bool xsReadVirtual(
int varID,
void * target,
void * source)
43 ((VirtFunc)source)(target);
47 static bool xsWriteVirtual(
int varID,
void * target,
void * source)
51 ((VirtFunc)(target + 1))(source);
53 ((VirtFunc)target)(source);
60 bool xsRead(
int varID,
void * target,
int size)
66 xsSubAndIdx(varID, &sub, &idx);
67 void * source = subsys_info[sub].ptrs[idx];
70 if (!xsReadVirtual(varID, target, source))
return false;
72 memcpy(target, source, size);
78 bool xsWrite(
int varID,
void * source,
int size)
80 logTrace(
"Writing varID %08x with %d bytes", varID, size);
85 xsSubAndIdx(varID, &sub, &idx);
86 void * target = subsys_info[sub].ptrs[idx];
88 if (!xsWriteVirtual(varID, target, source))
return false;
90 memcpy(target, source, size);
93 memcpy(target, source, size);
97 #define XS_READ_DB_FUNC(SUFFIX, TYPE, DBWRFUNC) \
98 static inline void xsReadDb ## SUFFIX(int varID, DataBuffer * target, void * src) { \
100 TYPE * s = (TYPE *)src; \
101 for (i = 0; i < vidArrSize(varID); ++i) DBWRFUNC(target, s[i]); \
120 static
void xsReadDBSrc(
int varID,
DataBuffer * target,
void * source)
122 switch (( varID & VID_SCLTYP_MASK ) >> VID_SCLTYP_SHIFT)
124 case VID_SCLTYP_U8: xsReadDbU8(varID, target, source);
break;
128 case VID_SCLTYP_I8: xsReadDbI8(varID, target, source);
break;
142 xsSubAndIdx(varID, &sub, &idx);
143 if (sub < 0 || sub >= CLB_SUB_MAX)
return false;
144 if (idx >= subsys_info[sub].count)
return false;
146 return subsys_info[sub].ptrs[idx] != NULL;
154 xsSubAndIdx(varID, &sub, &idx);
158 void * source = subsys_info[sub].ptrs[idx];
166 uint8_t swap[_MAX_VIRTUAL_BUF];
167 xsReadVirtual(varID, swap, source);
168 xsReadDBSrc(varID, target, swap);
170 xsReadDBSrc(varID, target, source);
178 #define XS_WRITE_DB_FUNC(SUFFIX, TYPE, DBWRFUNC) \
179 static inline void xsWriteDb ## SUFFIX(int varID, void * target, DataBuffer * src) { \
181 TYPE * t = (TYPE *)target; \
182 for (i = 0; i < vidArrSize(varID); ++i) DBWRFUNC(src, &(t[i])); \
185 XS_WRITE_DB_FUNC(U8, uint8_t,
dbReadU8)
186 XS_WRITE_DB_FUNC(U16, uint16_t,
dbReadU16)
187 XS_WRITE_DB_FUNC(U32, uint32_t,
dbReadU32)
188 XS_WRITE_DB_FUNC(U64, uint64_t,
dbReadU64)
189 XS_WRITE_DB_FUNC(I8, int8_t,
dbReadI8)
190 XS_WRITE_DB_FUNC(I16, int16_t,
dbReadI16)
191 XS_WRITE_DB_FUNC(I32, int32_t,
dbReadI32)
192 XS_WRITE_DB_FUNC(I64, int64_t,
dbReadI64)
198 static
void xsWriteDBSrc(
int varID,
void * target,
DataBuffer * source)
200 switch (( varID & VID_SCLTYP_MASK ) >> VID_SCLTYP_SHIFT)
202 case VID_SCLTYP_U8: xsWriteDbU8(varID, target, source);
break;
206 case VID_SCLTYP_I8: xsWriteDbI8(varID, target, source);
break;
221 logTrace(
"Writing varID %08x from DB", varID);
224 xsSubAndIdx(varID, &sub, &idx);
228 void * target = subsys_info[sub].ptrs[idx];
235 uint8_t swap[_MAX_VIRTUAL_BUF];
236 xsWriteDBSrc(varID, swap, source);
237 xsWriteVirtual(varID, target, swap);
239 xsWriteDBSrc(varID, target, source);
#define VID_SCLTYP_I8
Signed 8 bit integer.
bool dbReadF64(DataBuffer *buf, f64_t *flt)
Reads an 64-bit floating point.
#define VID_VIRTUAL
Indicates variable is virtual, does not really exist.
bool dbReadU8(DataBuffer *buf, uint8_t *byte)
Reads an unsigned byte.
bool xsWrite(int varID, void *source, int size)
Writes variable from target buffer into variable structure.
#define VID_SCLTYP_U16
Unsigned 16 bit integer.
Application specific error codes.
bool xsWriteDB(int varID, DataBuffer *source)
Writes variable from target data buffer into variable structure.
bool dbWriteI16(DataBuffer *buf, int16_t i)
Writes a short (16 bits signed) integer.
static bool dbWriteBool(DataBuffer *buf, bool boolean)
Writes a boolean.
bool dbReadU16(DataBuffer *buf, uint16_t *u)
Reads a unsigned short (16 bits unsigned) integer.
bool dbWriteI32(DataBuffer *buf, int32_t i)
Writes an 32 bits signed integer.
#define VID_SCLTYP_F32
32 bit IEEE floating point
bool dbWriteI8(DataBuffer *buf, int8_t byte)
Writes a byte.
#define E_NOTFOUND
Generic error: not found (ID or resource.
bool dbReadF32(DataBuffer *buf, f32_t *flt)
Reads an 32-bit floating point.
#define DB_ERR_NONE
Indicates no error.
#define VID_SCLTYP_I64
Signed 64 bit integer.
static int vidVarSize(int varID)
Returns the total size of the variable.
bool xsVarExists(int varID)
Returns whether or not the specified variable exists.
#define VID_SCLTYP_I16
Signed 16 bit integer.
#define E_INVSTATE
Generic error: Module is in a state in which.
Defines a DataBuffer structure.
#define VID_SCLTYP_BOOL
Boolean, encoded as a byte (0 - false, 1 - true)
#define E_INVARGUMENT
Generic error: invalid argument.
static bool dbReadBool(DataBuffer *buf, bool *boolean)
Reads a boolean.
#define VID_SCLTYP_U64
Unsigned 64 bit integer.
bool dbReadI64(DataBuffer *buf, int64_t *i)
Reads an 64 bits signed integer.
#define VID_WRITABLE
Variable is readable.
Manages the global system error.
#define VID_CONFIG
Config variables may not be writable in some states.
bool xsLockConfig
Variable to lock or unlock writing of configuration variables.
bool dbWriteF64(DataBuffer *buf, f64_t flt)
Writes a 64-bit floating point.
uint32_t f32_t
32 bit representation for float.
bool dbWriteF32(DataBuffer *buf, f32_t flt)
Writes a 32-bit floating point.
bool xsReadDB(int varID, DataBuffer *target)
Reads variable into target data buffer from variable structure.
uint64_t f64_t
642 bit representation for float
#define E_OUTOFMEMORY
Generic error: There is no more memory.
bool dbWriteU8(DataBuffer *buf, uint8_t byte)
Writes a unsigned byte.
bool dbReadI8(DataBuffer *buf, int8_t *byte)
Reads an byte.
bool dbReadU32(DataBuffer *buf, uint32_t *u)
Reads an 32 bits unsigned integer.
#define LOG_DEF(NAME,...)
Define a logger for a module.
bool dbWriteI64(DataBuffer *buf, int64_t i)
Writes an 64 bits signed integer.
#define VID_SCLTYP_U8
Unsigned 8 bit integer.
bool xsRead(int varID, void *target, int size)
Reads variable into target buffer from variable structure.
#define VID_SCLTYP_U32
Unsigned 32 bit integer.
#define VID_READABLE
Variable is writable.
bool dbReadI32(DataBuffer *buf, int32_t *i)
Reads an 32 bits signed integer.
bool errSet(uint32_t code, const char *error, const char *name)
Sets an error.
bool dbReadI16(DataBuffer *buf, int16_t *i)
Reads a short (16 bits signed) integer.
#define VID_SCLTYP_I32
Signed 32 bit integer.
Implements a generic logger facility.
Access provides 'introspective' access to process variables.
#define VID_SCLTYP_F64
64 bit IEEE double precision floating point
#define E_NOTSUPPORTED
Generic error: not supported.
bool dbWriteU32(DataBuffer *buf, uint32_t u)
Writes an 32 bits unsigned integer.
bool dbWriteU16(DataBuffer *buf, uint16_t u)
Writes a unsigned short (16 bits unsigned) integer.
bool dbReadU64(DataBuffer *buf, uint64_t *i)
Reads an 64 bits unsigned integer.