scpi-pps: Add a missing "break" in config_get().
[libsigrok.git] / src / hardware / baylibre-acme / api.c
1 /*
2  * This file is part of the libsigrok project.
3  *
4  * Copyright (C) 2015 Bartosz Golaszewski <bgolaszewski@baylibre.com>
5  *
6  * This program is free software: you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation, either version 3 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
18  */
19
20 #include <config.h>
21 #include "protocol.h"
22 #include <time.h>
23 #include <sys/timerfd.h>
24
25 static const uint32_t drvopts[] = {
26         SR_CONF_THERMOMETER,
27         SR_CONF_POWERMETER,
28 };
29
30 static const uint32_t devopts[] = {
31         SR_CONF_CONTINUOUS,
32         SR_CONF_LIMIT_SAMPLES | SR_CONF_GET | SR_CONF_SET,
33         SR_CONF_LIMIT_MSEC | SR_CONF_GET | SR_CONF_SET,
34         SR_CONF_SAMPLERATE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
35 };
36
37 /*
38  * Currently there are two channel-group/probe options for ACME:
39  *   - SR_CONF_PROBE_FACTOR - allows to modify current shunt resistance
40  *     calibration
41  *   - SR_CONF_POWER_OFF - allows to remotely cut-off/restore power to
42  *     measured devices
43  *
44  * They are not static - we have to check each probe's capabilities in
45  * config_list().
46  */
47 #define MAX_DEVOPTS_CG          2
48 #define HAS_PROBE_FACTOR        (SR_CONF_PROBE_FACTOR | SR_CONF_GET | SR_CONF_SET)
49 #define HAS_POWER_OFF           (SR_CONF_POWER_OFF | SR_CONF_GET | SR_CONF_SET)
50
51 #define MAX_SAMPLE_RATE 500 /* In Hz */
52
53 static const uint64_t samplerates[] = {
54         SR_HZ(1),
55         SR_HZ(MAX_SAMPLE_RATE),
56         SR_HZ(1),
57 };
58
59 static GSList *scan(struct sr_dev_driver *di, GSList *options)
60 {
61         struct dev_context *devc;
62         struct sr_dev_inst *sdi;
63         gboolean status;
64         int i;
65
66         (void)options;
67
68         devc = g_malloc0(sizeof(struct dev_context));
69         devc->samplerate = SR_HZ(10);
70
71         sdi = g_malloc0(sizeof(struct sr_dev_inst));
72         sdi->status = SR_ST_INACTIVE;
73         sdi->vendor = g_strdup("BayLibre");
74         sdi->model = g_strdup("ACME");
75         sdi->priv = devc;
76
77         status = bl_acme_is_sane();
78         if (!status)
79                 goto err_out;
80
81         /*
82          * Iterate over all ACME connectors and check if any probes
83          * are present.
84          */
85         for (i = 0; i < MAX_PROBES; i++) {
86                 /*
87                  * First check if there's an energy probe on this connector. If
88                  * not, and we're already at the fifth probe - see if we can
89                  * detect a temperature probe.
90                  */
91                 status = bl_acme_detect_probe(bl_acme_get_enrg_addr(i),
92                                               PROBE_NUM(i), ENRG_PROBE_NAME);
93                 if (status) {
94                         /* Energy probe detected. */
95                         status = bl_acme_register_probe(sdi, PROBE_ENRG,
96                                         bl_acme_get_enrg_addr(i), PROBE_NUM(i));
97                         if (!status) {
98                                 sr_err("Error registering power probe %d",
99                                        PROBE_NUM(i));
100                                 continue;
101                         }
102                 } else if (i >= TEMP_PRB_START_INDEX) {
103                         status = bl_acme_detect_probe(bl_acme_get_temp_addr(i),
104                                               PROBE_NUM(i), TEMP_PROBE_NAME);
105                         if (status) {
106                                 /* Temperature probe detected. */
107                                 status = bl_acme_register_probe(sdi,PROBE_TEMP,
108                                         bl_acme_get_temp_addr(i), PROBE_NUM(i));
109                                 if (!status) {
110                                         sr_err("Error registering temp "
111                                                "probe %d", PROBE_NUM(i));
112                                         continue;
113                                 }
114                         }
115                 }
116         }
117
118         /*
119          * Let's assume there's no ACME device present if no probe
120          * has been registered.
121          */
122         if (!sdi->channel_groups)
123                 goto err_out;
124
125         return std_scan_complete(di, g_slist_append(NULL, sdi));
126
127 err_out:
128         g_free(devc);
129         sr_dev_inst_free(sdi);
130
131         return NULL;
132 }
133
134 static int config_get(uint32_t key, GVariant **data,
135         const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
136 {
137         struct dev_context *devc;
138         int ret;
139         uint64_t shunt;
140         gboolean power_off;
141
142         devc = sdi->priv;
143
144         ret = SR_OK;
145
146         switch (key) {
147         case SR_CONF_LIMIT_SAMPLES:
148         case SR_CONF_LIMIT_MSEC:
149                 return sr_sw_limits_config_get(&devc->limits, key, data);
150         case SR_CONF_SAMPLERATE:
151                 *data = g_variant_new_uint64(devc->samplerate);
152                 break;
153         case SR_CONF_PROBE_FACTOR:
154                 if (!cg)
155                         return SR_ERR_CHANNEL_GROUP;
156                 ret = bl_acme_get_shunt(cg, &shunt);
157                 if (ret == SR_OK)
158                         *data = g_variant_new_uint64(shunt);
159                 break;
160         case SR_CONF_POWER_OFF:
161                 if (!cg)
162                         return SR_ERR_CHANNEL_GROUP;
163                 ret = bl_acme_read_power_state(cg, &power_off);
164                 if (ret == SR_OK)
165                         *data = g_variant_new_boolean(power_off);
166                 break;
167         default:
168                 return SR_ERR_NA;
169         }
170
171         return ret;
172 }
173
174 static int config_set(uint32_t key, GVariant *data,
175         const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
176 {
177         struct dev_context *devc;
178         uint64_t samplerate;
179
180         devc = sdi->priv;
181
182         switch (key) {
183         case SR_CONF_LIMIT_SAMPLES:
184         case SR_CONF_LIMIT_MSEC:
185                 return sr_sw_limits_config_set(&devc->limits, key, data);
186         case SR_CONF_SAMPLERATE:
187                 samplerate = g_variant_get_uint64(data);
188                 if (samplerate > MAX_SAMPLE_RATE) {
189                         sr_err("Maximum sample rate is %d", MAX_SAMPLE_RATE);
190                         return SR_ERR_SAMPLERATE;
191                 }
192                 devc->samplerate = samplerate;
193                 bl_acme_maybe_set_update_interval(sdi, samplerate);
194                 break;
195         case SR_CONF_PROBE_FACTOR:
196                 if (!cg)
197                         return SR_ERR_CHANNEL_GROUP;
198                 return bl_acme_set_shunt(cg, g_variant_get_uint64(data));
199         case SR_CONF_POWER_OFF:
200                 if (!cg)
201                         return SR_ERR_CHANNEL_GROUP;
202                 return bl_acme_set_power_off(cg, g_variant_get_boolean(data));
203         default:
204                 return SR_ERR_NA;
205         }
206
207         return SR_OK;
208 }
209
210 static int config_list(uint32_t key, GVariant **data,
211         const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
212 {
213         uint32_t devopts_cg[MAX_DEVOPTS_CG];
214         int num_devopts_cg = 0;
215
216         if (!cg) {
217                 switch (key) {
218                 case SR_CONF_DEVICE_OPTIONS:
219                         return STD_CONFIG_LIST(key, data, sdi, cg, NULL, drvopts, devopts);
220                 case SR_CONF_SAMPLERATE:
221                         *data = std_gvar_samplerates_steps(ARRAY_AND_SIZE(samplerates));
222                         break;
223                 default:
224                         return SR_ERR_NA;
225                 }
226         } else {
227                 switch (key) {
228                 case SR_CONF_DEVICE_OPTIONS:
229                         if (bl_acme_get_probe_type(cg) == PROBE_ENRG)
230                                 devopts_cg[num_devopts_cg++] = HAS_PROBE_FACTOR;
231                         if (bl_acme_probe_has_pws(cg))
232                                 devopts_cg[num_devopts_cg++] = HAS_POWER_OFF;
233
234                         *data = std_gvar_array_u32(devopts_cg, num_devopts_cg);
235                         break;
236                 default:
237                         return SR_ERR_NA;
238                 }
239         }
240
241         return SR_OK;
242 }
243
244 static void dev_acquisition_close(const struct sr_dev_inst *sdi)
245 {
246         GSList *chl;
247         struct sr_channel *ch;
248
249         for (chl = sdi->channels; chl; chl = chl->next) {
250                 ch = chl->data;
251                 bl_acme_close_channel(ch);
252         }
253 }
254
255 static int dev_acquisition_open(const struct sr_dev_inst *sdi)
256 {
257         GSList *chl;
258         struct sr_channel *ch;
259
260         for (chl = sdi->channels; chl; chl = chl->next) {
261                 ch = chl->data;
262                 if (bl_acme_open_channel(ch)) {
263                         sr_err("Error opening channel %s", ch->name);
264                         dev_acquisition_close(sdi);
265                         return SR_ERR;
266                 }
267         }
268
269         return 0;
270 }
271
272 static int dev_acquisition_start(const struct sr_dev_inst *sdi)
273 {
274         struct dev_context *devc;
275         struct itimerspec tspec = {
276                 .it_interval = { 0, 0 },
277                 .it_value = { 0, 0 }
278         };
279
280         if (dev_acquisition_open(sdi))
281                 return SR_ERR;
282
283         devc = sdi->priv;
284         devc->samples_missed = 0;
285         devc->timer_fd = timerfd_create(CLOCK_MONOTONIC, 0);
286         if (devc->timer_fd < 0) {
287                 sr_err("Error creating timer fd");
288                 return SR_ERR;
289         }
290
291         tspec.it_interval.tv_sec = 0;
292         tspec.it_interval.tv_nsec = SR_HZ_TO_NS(devc->samplerate);
293         tspec.it_value = tspec.it_interval;
294
295         if (timerfd_settime(devc->timer_fd, 0, &tspec, NULL)) {
296                 sr_err("Failed to set timer");
297                 close(devc->timer_fd);
298                 return SR_ERR;
299         }
300
301         devc->channel = g_io_channel_unix_new(devc->timer_fd);
302         g_io_channel_set_flags(devc->channel, G_IO_FLAG_NONBLOCK, NULL);
303         g_io_channel_set_encoding(devc->channel, NULL, NULL);
304         g_io_channel_set_buffered(devc->channel, FALSE);
305
306         sr_session_source_add_channel(sdi->session, devc->channel,
307                 G_IO_IN | G_IO_ERR, 1000, bl_acme_receive_data, (void *)sdi);
308
309         std_session_send_df_header(sdi);
310         sr_sw_limits_acquisition_start(&devc->limits);
311
312         return SR_OK;
313 }
314
315 static int dev_acquisition_stop(struct sr_dev_inst *sdi)
316 {
317         struct dev_context *devc;
318
319         devc = sdi->priv;
320
321         dev_acquisition_close(sdi);
322         sr_session_source_remove_channel(sdi->session, devc->channel);
323         g_io_channel_shutdown(devc->channel, FALSE, NULL);
324         g_io_channel_unref(devc->channel);
325         devc->channel = NULL;
326
327         std_session_send_df_end(sdi);
328
329         if (devc->samples_missed > 0)
330                 sr_warn("%" PRIu64 " samples missed", devc->samples_missed);
331
332         return SR_OK;
333 }
334
335 static struct sr_dev_driver baylibre_acme_driver_info = {
336         .name = "baylibre-acme",
337         .longname = "BayLibre ACME (Another Cute Measurement Equipment)",
338         .api_version = 1,
339         .init = std_init,
340         .cleanup = std_cleanup,
341         .scan = scan,
342         .dev_list = std_dev_list,
343         .dev_clear = std_dev_clear,
344         .config_get = config_get,
345         .config_set = config_set,
346         .config_list = config_list,
347         .dev_open = std_dummy_dev_open,
348         .dev_close = std_dummy_dev_close,
349         .dev_acquisition_start = dev_acquisition_start,
350         .dev_acquisition_stop = dev_acquisition_stop,
351         .context = NULL,
352 };
353 SR_REGISTER_DEV_DRIVER(baylibre_acme_driver_info);