KM3NeT CLB  2.0
KM3NeT CLB v2 Embedded Software
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
access.c
1 /*
2  * KM3NeT CLB v2 Firmware
3  * ----------------------
4  *
5  * Copyright 2013 KM3NeT Collaboration
6  *
7  * All Rights Reserved.
8  *
9  *
10  * File : access.c
11  * Created : 26 feb. 2014
12  * Author : Vincent van Beveren
13  */
14 
15 #include "pv/access.h"
16 
17 #include <string.h>
18 
19 #include "pv/vars.h"
20 #include "cfg_subsys.h"
21 #include "kernel/err.h"
22 #include "appcode.h"
23 
24 #include "util/log.h"
25 
26 LOG_DEF(Access)
27 
28 #define _MAX_VIRTUAL_BUF 256
29 
30 bool xsLockConfig = false;
31 
32 typedef void (*VirtFunc)(void ** ptr);
33 
34 static inline void xsSubAndIdx(int varID, int * sub, int * idx)
35 {
36  *sub = ( varID & VID_SUBSYS_MASK ) >> VID_SUBSYS_SHIFT;
37  *idx = ( varID & VID_VARIDX_MASK ) >> VID_VARIDX_SHIFT;
38 }
39 
40 
41 static bool xsReadVirtual(int varID, void * target, void * source)
42 {
43  ((VirtFunc)source)(target);
44  return true;
45 }
46 
47 static bool xsWriteVirtual(int varID, void * target, void * source)
48 {
49  if (varID & VID_READABLE) {
50  // if its readable, the write pointer will be one ptr away.
51  ((VirtFunc)(target + 1))(source);
52  } else {
53  ((VirtFunc)target)(source);
54  }
55 
56  return true;
57 }
58 
59 
60 bool xsRead(int varID, void * target, int size)
61 {
62  int sub, idx;
63 
64  if (!(varID & VID_READABLE)) return errSet(ERROR_CTX(E_NOTSUPPORTED));
65  if (vidVarSize(varID) > size) return errSet(ERROR_CTX(E_INVARGUMENT));
66  xsSubAndIdx(varID, &sub, &idx);
67  void * source = subsys_info[sub].ptrs[idx];
68 
69  if (varID & VID_VIRTUAL) {
70  if (!xsReadVirtual(varID, target, source)) return false;
71  } else {
72  memcpy(target, source, size);
73  }
74  return true;
75 }
76 
77 
78 bool xsWrite(int varID, void * source, int size)
79 {
80  logTrace("Writing varID %08x with %d bytes", varID, size);
81  int sub, idx;
82  if (!(varID & VID_WRITABLE)) return errSet(ERROR_CTX(E_NOTSUPPORTED));
83  if (xsLockConfig && (varID & VID_CONFIG)) return errSet(ERROR_CTX(E_INVSTATE));
84  if (vidVarSize(varID) > size) return errSet(ERROR_CTX(E_INVARGUMENT));
85  xsSubAndIdx(varID, &sub, &idx);
86  void * target = subsys_info[sub].ptrs[idx];
87  if (varID & VID_VIRTUAL) {
88  if (!xsWriteVirtual(varID, target, source)) return false;
89  } else {
90  memcpy(target, source, size);
91  }
92 
93  memcpy(target, source, size);
94  return true;
95 }
96 
97 #define XS_READ_DB_FUNC(SUFFIX, TYPE, DBWRFUNC) \
98 static inline void xsReadDb ## SUFFIX(int varID, DataBuffer * target, void * src) { \
99  int i; \
100  TYPE * s = (TYPE *)src; \
101  for (i = 0; i < vidArrSize(varID); ++i) DBWRFUNC(target, s[i]); \
102 }
103 
104 // so, yet this is somewhat weird, but read is in respect of the process variables
105 // i.e. reading a process variable will cause it to be written to the data buffer
106 // therefore write functions are used
107 XS_READ_DB_FUNC(U8, uint8_t, dbWriteU8)
108 XS_READ_DB_FUNC(U16, uint16_t, dbWriteU16)
109 XS_READ_DB_FUNC(U32, uint32_t, dbWriteU32)
110 XS_READ_DB_FUNC(U64, uint64_t, dbWriteI64)
111 XS_READ_DB_FUNC(I8, int8_t, dbWriteI8)
112 XS_READ_DB_FUNC(I16, int16_t, dbWriteI16)
113 XS_READ_DB_FUNC(I32, int32_t, dbWriteI32)
114 XS_READ_DB_FUNC(I64, int64_t, dbWriteI64)
115 XS_READ_DB_FUNC(F32, f32_t, dbWriteF32)
116 XS_READ_DB_FUNC(F64, f64_t, dbWriteF64)
117 XS_READ_DB_FUNC(BOOL, bool, dbWriteBool)
118 
119 
120 static void xsReadDBSrc(int varID, DataBuffer * target, void * source)
121 {
122  switch (( varID & VID_SCLTYP_MASK ) >> VID_SCLTYP_SHIFT)
123  {
124  case VID_SCLTYP_U8: xsReadDbU8(varID, target, source); break;
125  case VID_SCLTYP_U16: xsReadDbU16(varID, target, source); break;
126  case VID_SCLTYP_U32: xsReadDbU32(varID, target, source); break;
127  case VID_SCLTYP_U64: xsReadDbU64(varID, target, source); break;
128  case VID_SCLTYP_I8: xsReadDbI8(varID, target, source); break;
129  case VID_SCLTYP_I16: xsReadDbI16(varID, target, source); break;
130  case VID_SCLTYP_I32: xsReadDbI32(varID, target, source); break;
131  case VID_SCLTYP_I64: xsReadDbI64(varID, target, source); break;
132  case VID_SCLTYP_F32: xsReadDbF32(varID, target, source); break;
133  case VID_SCLTYP_F64: xsReadDbF64(varID, target, source); break;
134  case VID_SCLTYP_BOOL: xsReadDbBOOL(varID, target, source); break;
135 
136  }
137 }
138 
139 bool xsVarExists(int varID) {
140  int sub, idx;
141 
142  xsSubAndIdx(varID, &sub, &idx);
143  if (sub < 0 || sub >= CLB_SUB_MAX) return false;
144  if (idx >= subsys_info[sub].count) return false;
145 
146  return subsys_info[sub].ptrs[idx] != NULL;
147 }
148 
149 bool xsReadDB(int varID, DataBuffer * target)
150 {
151  int sub, idx;
152 
153  if (!(varID & VID_READABLE)) return errSet(ERROR_CTX(E_NOTSUPPORTED));
154  xsSubAndIdx(varID, &sub, &idx);
155  if (sub < 0 || sub >= CLB_SUB_MAX) return errSet(ERROR_CTX(E_INVARGUMENT));
156  if (idx >= subsys_info[sub].count) return errSet(ERROR_CTX(E_NOTFOUND));
157 
158  void * source = subsys_info[sub].ptrs[idx];
159 
160  if (source == 0) return errSet(ERROR_CTX(E_NOTFOUND));
161 
162  if (idx & VID_VIRTUAL)
163  {
164  if (vidVarSize(idx) > _MAX_VIRTUAL_BUF) return errSet(ERROR_CTX(E_OUTOFMEMORY));
165 
166  uint8_t swap[_MAX_VIRTUAL_BUF];
167  xsReadVirtual(varID, swap, source);
168  xsReadDBSrc(varID, target, swap);
169  } else {
170  xsReadDBSrc(varID, target, source);
171  }
172 
173  if (target->error != DB_ERR_NONE) return errSet(ERROR_CTX(E_OUTOFMEMORY));;
174 
175  return true;
176 }
177 
178 #define XS_WRITE_DB_FUNC(SUFFIX, TYPE, DBWRFUNC) \
179 static inline void xsWriteDb ## SUFFIX(int varID, void * target, DataBuffer * src) { \
180  int i; \
181  TYPE * t = (TYPE *)target; \
182  for (i = 0; i < vidArrSize(varID); ++i) DBWRFUNC(src, &(t[i])); \
183 }
184 
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)
193 XS_WRITE_DB_FUNC(F32, f32_t, dbReadF32)
194 XS_WRITE_DB_FUNC(F64, f64_t, dbReadF64)
195 XS_WRITE_DB_FUNC(BOOL, bool, dbReadBool)
196 
197 
198 static void xsWriteDBSrc(int varID, void * target, DataBuffer * source)
199 {
200  switch (( varID & VID_SCLTYP_MASK ) >> VID_SCLTYP_SHIFT)
201  {
202  case VID_SCLTYP_U8: xsWriteDbU8(varID, target, source); break;
203  case VID_SCLTYP_U16: xsWriteDbU16(varID, target, source); break;
204  case VID_SCLTYP_U32: xsWriteDbU32(varID, target, source); break;
205  case VID_SCLTYP_U64: xsWriteDbU64(varID, target, source); break;
206  case VID_SCLTYP_I8: xsWriteDbI8(varID, target, source); break;
207  case VID_SCLTYP_I16: xsWriteDbI16(varID, target, source); break;
208  case VID_SCLTYP_I32: xsWriteDbI32(varID, target, source); break;
209  case VID_SCLTYP_I64: xsWriteDbI64(varID, target, source); break;
210  case VID_SCLTYP_F32: xsWriteDbF32(varID, target, source); break;
211  case VID_SCLTYP_F64: xsWriteDbF64(varID, target, source); break;
212  case VID_SCLTYP_BOOL: xsWriteDbBOOL(varID, target, source); break;
213  }
214 }
215 
216 
217 
218 bool xsWriteDB(int varID, DataBuffer * source)
219 {
220  int sub, idx;
221  logTrace("Writing varID %08x from DB", varID);
222  if (!(varID & VID_WRITABLE)) return errSet(ERROR_CTX(E_NOTSUPPORTED));
223  if (xsLockConfig && (varID & VID_CONFIG)) return errSet(ERROR_CTX(E_INVSTATE));
224  xsSubAndIdx(varID, &sub, &idx);
225  if (sub < 0 || sub >= CLB_SUB_MAX) return errSet(ERROR_CTX(E_INVARGUMENT));
226  if (idx >= subsys_info[sub].count) return errSet(ERROR_CTX(E_INVARGUMENT));
227 
228  void * target = subsys_info[sub].ptrs[idx];
229  if (target == 0) return errSet(ERROR_CTX(E_INVARGUMENT));
230 
231  if (idx & VID_VIRTUAL)
232  {
233  if (vidVarSize(idx) > _MAX_VIRTUAL_BUF) return errSet(ERROR_CTX(E_OUTOFMEMORY));
234 
235  uint8_t swap[_MAX_VIRTUAL_BUF];
236  xsWriteDBSrc(varID, swap, source);
237  xsWriteVirtual(varID, target, swap);
238  } else {
239  xsWriteDBSrc(varID, target, source);
240  }
241  if (source->error != DB_ERR_NONE) return errSet(ERROR_CTX(E_OUTOFMEMORY));;
242  return true;
243 }
#define VID_SCLTYP_I8
Signed 8 bit integer.
Definition: varid.h:71
bool dbReadF64(DataBuffer *buf, f64_t *flt)
Reads an 64-bit floating point.
Definition: databuffer.c:345
#define VID_VIRTUAL
Indicates variable is virtual, does not really exist.
Definition: varid.h:80
bool dbReadU8(DataBuffer *buf, uint8_t *byte)
Reads an unsigned byte.
Definition: databuffer.c:153
bool xsWrite(int varID, void *source, int size)
Writes variable from target buffer into variable structure.
Definition: access.c:78
#define VID_SCLTYP_U16
Unsigned 16 bit integer.
Definition: varid.h:68
Application specific error codes.
bool xsWriteDB(int varID, DataBuffer *source)
Writes variable from target data buffer into variable structure.
Definition: access.c:218
Provides access to all variables of the various subsystems.
bool dbWriteI16(DataBuffer *buf, int16_t i)
Writes a short (16 bits signed) integer.
Definition: databuffer.c:173
static bool dbWriteBool(DataBuffer *buf, bool boolean)
Writes a boolean.
Definition: databuffer.h:249
bool dbReadU16(DataBuffer *buf, uint16_t *u)
Reads a unsigned short (16 bits unsigned) integer.
Definition: databuffer.c:186
bool dbWriteI32(DataBuffer *buf, int32_t i)
Writes an 32 bits signed integer.
Definition: databuffer.c:213
#define VID_SCLTYP_F32
32 bit IEEE floating point
Definition: varid.h:77
bool dbWriteI8(DataBuffer *buf, int8_t byte)
Writes a byte.
Definition: databuffer.c:129
#define E_NOTFOUND
Generic error: not found (ID or resource.
Definition: errorcode.h:121
bool dbReadF32(DataBuffer *buf, f32_t *flt)
Reads an 32-bit floating point.
Definition: databuffer.c:340
#define DB_ERR_NONE
Indicates no error.
Definition: databuffer.h:34
#define VID_SCLTYP_I64
Signed 64 bit integer.
Definition: varid.h:74
static int vidVarSize(int varID)
Returns the total size of the variable.
Definition: varid.h:132
bool xsVarExists(int varID)
Returns whether or not the specified variable exists.
Definition: access.c:139
#define VID_SCLTYP_I16
Signed 16 bit integer.
Definition: varid.h:72
#define E_INVSTATE
Generic error: Module is in a state in which.
Definition: errorcode.h:103
Defines a DataBuffer structure.
Definition: databuffer.h:45
#define VID_SCLTYP_BOOL
Boolean, encoded as a byte (0 - false, 1 - true)
Definition: varid.h:76
#define E_INVARGUMENT
Generic error: invalid argument.
Definition: errorcode.h:112
static bool dbReadBool(DataBuffer *buf, bool *boolean)
Reads a boolean.
Definition: databuffer.h:263
#define VID_SCLTYP_U64
Unsigned 64 bit integer.
Definition: varid.h:70
bool dbReadI64(DataBuffer *buf, int64_t *i)
Reads an 64 bits signed integer.
Definition: databuffer.c:284
int error
Last error.
Definition: databuffer.h:50
#define VID_WRITABLE
Variable is readable.
Definition: varid.h:82
Manages the global system error.
const subsys_info_t subsys_info[6]
array of subsystem meta objects
Definition: vars.c:373
#define VID_CONFIG
Config variables may not be writable in some states.
Definition: varid.h:83
bool xsLockConfig
Variable to lock or unlock writing of configuration variables.
bool dbWriteF64(DataBuffer *buf, f64_t flt)
Writes a 64-bit floating point.
Definition: databuffer.c:332
uint32_t f32_t
32 bit representation for float.
Definition: float.h:30
bool dbWriteF32(DataBuffer *buf, f32_t flt)
Writes a 32-bit floating point.
Definition: databuffer.c:318
bool xsReadDB(int varID, DataBuffer *target)
Reads variable into target data buffer from variable structure.
Definition: access.c:149
uint64_t f64_t
642 bit representation for float
Definition: float.h:33
#define E_OUTOFMEMORY
Generic error: There is no more memory.
Definition: errorcode.h:107
bool dbWriteU8(DataBuffer *buf, uint8_t byte)
Writes a unsigned byte.
Definition: databuffer.c:146
bool dbReadI8(DataBuffer *buf, int8_t *byte)
Reads an byte.
Definition: databuffer.c:136
bool dbReadU32(DataBuffer *buf, uint32_t *u)
Reads an 32 bits unsigned integer.
Definition: databuffer.c:219
#define LOG_DEF(NAME,...)
Define a logger for a module.
Definition: log.h:129
bool dbWriteI64(DataBuffer *buf, int64_t i)
Writes an 64 bits signed integer.
Definition: databuffer.c:269
#define VID_SCLTYP_U8
Unsigned 8 bit integer.
Definition: varid.h:67
bool xsRead(int varID, void *target, int size)
Reads variable into target buffer from variable structure.
Definition: access.c:60
#define VID_SCLTYP_U32
Unsigned 32 bit integer.
Definition: varid.h:69
#define VID_READABLE
Variable is writable.
Definition: varid.h:81
bool dbReadI32(DataBuffer *buf, int32_t *i)
Reads an 32 bits signed integer.
Definition: databuffer.c:262
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.
Definition: databuffer.c:194
#define VID_SCLTYP_I32
Signed 32 bit integer.
Definition: varid.h:73
Implements a generic logger facility.
Access provides &#39;introspective&#39; access to process variables.
#define VID_SCLTYP_F64
64 bit IEEE double precision floating point
Definition: varid.h:78
#define E_NOTSUPPORTED
Generic error: not supported.
Definition: errorcode.h:115
bool dbWriteU32(DataBuffer *buf, uint32_t u)
Writes an 32 bits unsigned integer.
Definition: databuffer.c:200
bool dbWriteU16(DataBuffer *buf, uint16_t u)
Writes a unsigned short (16 bits unsigned) integer.
Definition: databuffer.c:162
bool dbReadU64(DataBuffer *buf, uint64_t *i)
Reads an 64 bits unsigned integer.
Definition: databuffer.c:230