libiio
iio-private.h
1 /*
2  * libiio - Library for interfacing industrial I/O (IIO) devices
3  *
4  * Copyright (C) 2014 Analog Devices, Inc.
5  * Author: Paul Cercueil <paul.cercueil@analog.com>
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * */
18 
19 #ifndef __IIO_PRIVATE_H__
20 #define __IIO_PRIVATE_H__
21 
22 /* Include public interface */
23 #include "iio.h"
24 
25 #include "iio-config.h"
26 
27 #include <stdbool.h>
28 
29 #ifdef _MSC_BUILD
30 #define inline __inline
31 #define iio_snprintf sprintf_s
32 #else
33 #define iio_snprintf snprintf
34 #endif
35 
36 #ifdef _WIN32
37 # ifdef LIBIIO_EXPORTS
38 # define __api __declspec(dllexport)
39 # else
40 # define __api __declspec(dllimport)
41 # endif
42 #elif __GNUC__ >= 4
43 # define __api __attribute__((visibility ("default")))
44 #else
45 # define __api
46 #endif
47 
48 #ifdef WITH_MATLAB_BINDINGS_API
49 #include "bindings/matlab/iio-wrapper.h"
50 #endif
51 
52 #define ARRAY_SIZE(x) (sizeof(x) ? sizeof(x) / sizeof((x)[0]) : 0)
53 #define BIT(x) (1 << (x))
54 #define BIT_MASK(bit) BIT((bit) % 32)
55 #define BIT_WORD(bit) ((bit) / 32)
56 #define TEST_BIT(addr, bit) (!!(*(((uint32_t *) addr) + BIT_WORD(bit)) \
57  & BIT_MASK(bit)))
58 #define SET_BIT(addr, bit) \
59  *(((uint32_t *) addr) + BIT_WORD(bit)) |= BIT_MASK(bit)
60 #define CLEAR_BIT(addr, bit) \
61  *(((uint32_t *) addr) + BIT_WORD(bit)) &= ~BIT_MASK(bit)
62 
63 
64 /* ntohl/htonl are a nightmare to use in cross-platform applications,
65  * since they are defined in different headers on different platforms.
66  * iio_be32toh/iio_htobe32 are just clones of ntohl/htonl. */
67 static inline uint32_t iio_be32toh(uint32_t word)
68 {
69 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
70 #ifdef __GNUC__
71  return __builtin_bswap32(word);
72 #else
73  return ((word & 0xff) << 24) | ((word & 0xff00) << 8) |
74  ((word >> 8) & 0xff00) | ((word >> 24) & 0xff);
75 #endif
76 #else
77  return word;
78 #endif
79 }
80 
81 static inline uint32_t iio_htobe32(uint32_t word)
82 {
83  return iio_be32toh(word);
84 }
85 
86 /* Allocate zeroed out memory */
87 static inline void *zalloc(size_t size)
88 {
89  return calloc(1, size);
90 }
91 
92 enum iio_attr_type {
93  IIO_ATTR_TYPE_DEVICE = 0,
94  IIO_ATTR_TYPE_DEBUG,
95  IIO_ATTR_TYPE_BUFFER,
96 };
97 
99  struct iio_context * (*clone)(const struct iio_context *ctx);
100  ssize_t (*read)(const struct iio_device *dev, void *dst, size_t len,
101  uint32_t *mask, size_t words);
102  ssize_t (*write)(const struct iio_device *dev,
103  const void *src, size_t len);
104  int (*open)(const struct iio_device *dev,
105  size_t samples_count, bool cyclic);
106  int (*close)(const struct iio_device *dev);
107  int (*get_fd)(const struct iio_device *dev);
108  int (*set_blocking_mode)(const struct iio_device *dev, bool blocking);
109 
110  void (*cancel)(const struct iio_device *dev);
111 
112  int (*set_kernel_buffers_count)(const struct iio_device *dev,
113  unsigned int nb_blocks);
114  ssize_t (*get_buffer)(const struct iio_device *dev,
115  void **addr_ptr, size_t bytes_used,
116  uint32_t *mask, size_t words);
117 
118  ssize_t (*read_device_attr)(const struct iio_device *dev,
119  const char *attr, char *dst, size_t len, enum iio_attr_type);
120  ssize_t (*write_device_attr)(const struct iio_device *dev,
121  const char *attr, const char *src,
122  size_t len, enum iio_attr_type);
123  ssize_t (*read_channel_attr)(const struct iio_channel *chn,
124  const char *attr, char *dst, size_t len);
125  ssize_t (*write_channel_attr)(const struct iio_channel *chn,
126  const char *attr, const char *src, size_t len);
127 
128  int (*get_trigger)(const struct iio_device *dev,
129  const struct iio_device **trigger);
130  int (*set_trigger)(const struct iio_device *dev,
131  const struct iio_device *trigger);
132 
133  void (*shutdown)(struct iio_context *ctx);
134 
135  int (*get_version)(const struct iio_context *ctx, unsigned int *major,
136  unsigned int *minor, char git_tag[8]);
137 
138  int (*set_timeout)(struct iio_context *ctx, unsigned int timeout);
139 };
140 
141 /*
142  * If these structures are updated, the qsort functions defined in sort.c
143  * may need to be updated.
144  */
145 
146 struct iio_context_pdata;
147 struct iio_device_pdata;
148 struct iio_channel_pdata;
150 
152  char *name;
153  char *filename;
154 };
155 
156 struct iio_context {
157  struct iio_context_pdata *pdata;
158  const struct iio_backend_ops *ops;
159  const char *name;
160  char *description;
161 
162  struct iio_device **devices;
163  unsigned int nb_devices;
164 
165  char *xml;
166 
167  char **attrs;
168  char **values;
169  unsigned int nb_attrs;
170 };
171 
172 struct iio_channel {
173  struct iio_device *dev;
174  struct iio_channel_pdata *pdata;
175  void *userdata;
176 
177  bool is_output;
178  bool is_scan_element;
179  struct iio_data_format format;
180  char *name, *id;
181  long index;
182  enum iio_modifier modifier;
183  enum iio_chan_type type;
184 
185  struct iio_channel_attr *attrs;
186  unsigned int nb_attrs;
187 
188  unsigned int number;
189 };
190 
191 struct iio_device {
192  const struct iio_context *ctx;
193  struct iio_device_pdata *pdata;
194  void *userdata;
195 
196  char *name, *id;
197 
198  char **attrs;
199  unsigned int nb_attrs;
200 
201  char **buffer_attrs;
202  unsigned int nb_buffer_attrs;
203 
204  char **debug_attrs;
205  unsigned int nb_debug_attrs;
206 
207  struct iio_channel **channels;
208  unsigned int nb_channels;
209 
210  uint32_t *mask;
211  size_t words;
212 };
213 
214 struct iio_buffer {
215  const struct iio_device *dev;
216  void *buffer, *userdata;
217  size_t length, data_length;
218 
219  uint32_t *mask;
220  unsigned int dev_sample_size;
221  unsigned int sample_size;
222  bool is_output, dev_is_high_speed;
223 };
224 
226  char *description;
227  char *uri;
228 };
229 
231  size_t size;
232  struct iio_context_info **info;
233 };
234 
235 struct iio_context_info ** iio_scan_result_add(
236  struct iio_scan_result *scan_result, size_t num);
237 
238 void free_channel(struct iio_channel *chn);
239 void free_device(struct iio_device *dev);
240 
241 char *iio_channel_get_xml(const struct iio_channel *chn, size_t *len);
242 char *iio_device_get_xml(const struct iio_device *dev, size_t *len);
243 
244 char *iio_context_create_xml(const struct iio_context *ctx);
245 int iio_context_init(struct iio_context *ctx);
246 
247 bool iio_device_is_tx(const struct iio_device *dev);
248 int iio_device_open(const struct iio_device *dev,
249  size_t samples_count, bool cyclic);
250 int iio_device_close(const struct iio_device *dev);
251 int iio_device_set_blocking_mode(const struct iio_device *dev, bool blocking);
252 ssize_t iio_device_read_raw(const struct iio_device *dev,
253  void *dst, size_t len, uint32_t *mask, size_t words);
254 ssize_t iio_device_write_raw(const struct iio_device *dev,
255  const void *src, size_t len);
256 int iio_device_get_poll_fd(const struct iio_device *dev);
257 
258 int read_double(const char *str, double *val);
259 int write_double(char *buf, size_t len, double val);
260 
261 struct iio_context * local_create_context(void);
262 struct iio_context * network_create_context(const char *hostname);
263 struct iio_context * xml_create_context_mem(const char *xml, size_t len);
264 struct iio_context * xml_create_context(const char *xml_file);
265 struct iio_context * usb_create_context(unsigned int bus, unsigned int address,
266  unsigned int interface);
267 struct iio_context * usb_create_context_from_uri(const char *uri);
268 struct iio_context * serial_create_context_from_uri(const char *uri);
269 
270 int local_context_scan(struct iio_scan_result *scan_result);
271 
272 struct iio_scan_backend_context * usb_context_scan_init(void);
273 void usb_context_scan_free(struct iio_scan_backend_context *ctx);
274 
275 int usb_context_scan(struct iio_scan_backend_context *ctx,
276  struct iio_scan_result *scan_result);
277 
278 struct iio_scan_backend_context * dnssd_context_scan_init(void);
279 void dnssd_context_scan_free(struct iio_scan_backend_context *ctx);
280 
281 int dnssd_context_scan(struct iio_scan_backend_context *ctx,
282  struct iio_scan_result *scan_result);
283 
284 /* This function is not part of the API, but is used by the IIO daemon */
285 __api ssize_t iio_device_get_sample_size_mask(const struct iio_device *dev,
286  const uint32_t *mask, size_t words);
287 
288 void iio_channel_init_finalize(struct iio_channel *chn);
289 unsigned int find_channel_modifier(const char *s, size_t *len_p);
290 
291 char *iio_strdup(const char *str);
292 
293 int iio_context_add_attr(struct iio_context *ctx,
294  const char *key, const char *value);
295 
296 #undef __api
297 
298 #endif /* __IIO_PRIVATE_H__ */
Represents an input or output channel of a device.
Definition: iio-private.h:172
Definition: iio_stresstest.c:169
Definition: iio-private.h:151
Represents a device in the IIO context.
Definition: iio-private.h:191
iio_modifier
IIO channel modifier.
Definition: iio.h:147
Definition: local.c:89
Definition: local.c:85
iio_chan_type
IIO channel type.
Definition: iio.h:101
Public interface.
Definition: iio-private.h:230
An input or output buffer, used to read or write samples.
Definition: iio-private.h:214
The information related to a discovered context.
Definition: iio-private.h:225
Definition: local.c:104
Definition: dns_sd.c:66
Contains the format of a data sample.
Definition: iio.h:1504
Definition: iio-private.h:98
Contains the representation of an IIO context.
Definition: iio-private.h:156