2 * This file is part of the libsigrok project.
4 * Copyright (C) 2010 Uwe Hermann <uwe@hermann-uwe.de>
5 * Copyright (C) 2011 Olivier Fauchon <olivier@aixmarseille.com>
6 * Copyright (C) 2012 Alexandru Gagniuc <mr.nuke.me@gmail.com>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
29 #define pipe(fds) _pipe(fds, 4096, _O_BINARY)
31 #include "libsigrok.h"
32 #include "libsigrok-internal.h"
34 /* Message logging helpers with subsystem-specific prefix string. */
35 #define LOG_PREFIX "demo: "
36 #define sr_log(l, s, args...) sr_log(l, LOG_PREFIX s, ## args)
37 #define sr_spew(s, args...) sr_spew(LOG_PREFIX s, ## args)
38 #define sr_dbg(s, args...) sr_dbg(LOG_PREFIX s, ## args)
39 #define sr_info(s, args...) sr_info(LOG_PREFIX s, ## args)
40 #define sr_warn(s, args...) sr_warn(LOG_PREFIX s, ## args)
41 #define sr_err(s, args...) sr_err(LOG_PREFIX s, ## args)
43 /* TODO: Number of probes should be configurable. */
46 #define DEMONAME "Demo device"
48 /* The size of chunks to send through the session bus. */
49 /* TODO: Should be configurable. */
52 #define STR_PATTERN_SIGROK "sigrok"
53 #define STR_PATTERN_RANDOM "random"
54 #define STR_PATTERN_INC "incremental"
55 #define STR_PATTERN_ALL_LOW "all-low"
56 #define STR_PATTERN_ALL_HIGH "all-high"
58 /* Supported patterns which we can generate */
61 * Pattern which spells "sigrok" using '0's (with '1's as "background")
62 * when displayed using the 'bits' output format.
66 /** Pattern which consists of (pseudo-)random values on all probes. */
70 * Pattern which consists of incrementing numbers.
71 * TODO: Better description.
75 /** Pattern where all probes have a low logic state. */
78 /** Pattern where all probes have a high logic state. */
82 /* Private, per-device-instance driver context. */
84 struct sr_dev_inst *sdi;
87 uint64_t cur_samplerate;
88 uint64_t limit_samples;
90 uint8_t sample_generator;
91 uint64_t samples_counter;
96 static const int hwcaps[] = {
97 SR_CONF_LOGIC_ANALYZER,
100 SR_CONF_PATTERN_MODE,
101 SR_CONF_LIMIT_SAMPLES,
106 static const uint64_t samplerates[] = {
112 static const char *pattern_strings[] = {
120 /* We name the probes 0-7 on our demo driver. */
121 static const char *probe_names[NUM_PROBES + 1] = {
122 "0", "1", "2", "3", "4", "5", "6", "7",
126 static uint8_t pattern_sigrok[] = {
127 0x4c, 0x92, 0x92, 0x92, 0x64, 0x00, 0x00, 0x00,
128 0x82, 0xfe, 0xfe, 0x82, 0x00, 0x00, 0x00, 0x00,
129 0x7c, 0x82, 0x82, 0x92, 0x74, 0x00, 0x00, 0x00,
130 0xfe, 0x12, 0x12, 0x32, 0xcc, 0x00, 0x00, 0x00,
131 0x7c, 0x82, 0x82, 0x82, 0x7c, 0x00, 0x00, 0x00,
132 0xfe, 0x10, 0x28, 0x44, 0x82, 0x00, 0x00, 0x00,
133 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
134 0xbe, 0xbe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
137 /* Private, per-device-instance driver context. */
138 /* TODO: struct context as with the other drivers. */
140 /* List of struct sr_dev_inst, maintained by dev_open()/dev_close(). */
141 SR_PRIV struct sr_dev_driver demo_driver_info;
142 static struct sr_dev_driver *di = &demo_driver_info;
144 static int hw_dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data);
146 static int clear_instances(void)
148 /* Nothing needed so far. */
153 static int hw_init(struct sr_context *sr_ctx)
155 return std_hw_init(sr_ctx, di, LOG_PREFIX);
158 static GSList *hw_scan(GSList *options)
160 struct sr_dev_inst *sdi;
161 struct sr_probe *probe;
162 struct drv_context *drvc;
163 struct dev_context *devc;
173 sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, DEMONAME, NULL, NULL);
175 sr_err("Device instance creation failed.");
180 for (i = 0; probe_names[i]; i++) {
181 if (!(probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE,
184 sdi->probes = g_slist_append(sdi->probes, probe);
187 devices = g_slist_append(devices, sdi);
188 drvc->instances = g_slist_append(drvc->instances, sdi);
190 if (!(devc = g_try_malloc(sizeof(struct dev_context)))) {
191 sr_err("Device context malloc failed.");
196 devc->cur_samplerate = SR_KHZ(200);
197 devc->limit_samples = 0;
198 devc->limit_msec = 0;
199 devc->sample_generator = PATTERN_SIGROK;
206 static GSList *hw_dev_list(void)
208 return ((struct drv_context *)(di->priv))->instances;
211 static int hw_dev_open(struct sr_dev_inst *sdi)
215 sdi->status = SR_ST_ACTIVE;
220 static int hw_dev_close(struct sr_dev_inst *sdi)
224 sdi->status = SR_ST_INACTIVE;
229 static int hw_cleanup(void)
232 struct sr_dev_inst *sdi;
233 struct drv_context *drvc;
236 if (!(drvc = di->priv))
239 /* Properly close and free all devices. */
240 for (l = drvc->instances; l; l = l->next) {
241 if (!(sdi = l->data)) {
242 /* Log error, but continue cleaning up the rest. */
243 sr_err("%s: sdi was NULL, continuing", __func__);
247 sr_dev_inst_free(sdi);
249 g_slist_free(drvc->instances);
250 drvc->instances = NULL;
255 static int config_get(int id, GVariant **data, const struct sr_dev_inst *sdi)
257 struct dev_context *const devc = sdi->priv;
260 case SR_CONF_SAMPLERATE:
261 *data = g_variant_new_uint64(devc->cur_samplerate);
263 case SR_CONF_LIMIT_SAMPLES:
264 *data = g_variant_new_uint64(devc->limit_samples);
266 case SR_CONF_LIMIT_MSEC:
267 *data = g_variant_new_uint64(devc->limit_msec);
269 case SR_CONF_PATTERN_MODE:
270 switch (devc->sample_generator) {
272 *data = g_variant_new_string(STR_PATTERN_SIGROK);
275 *data = g_variant_new_string(STR_PATTERN_RANDOM);
278 *data = g_variant_new_string(STR_PATTERN_INC);
280 case PATTERN_ALL_LOW:
281 *data = g_variant_new_string(STR_PATTERN_ALL_LOW);
283 case PATTERN_ALL_HIGH:
284 *data = g_variant_new_string(STR_PATTERN_ALL_HIGH);
295 static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi)
300 struct dev_context *const devc = sdi->priv;
302 if (sdi->status != SR_ST_ACTIVE)
303 return SR_ERR_DEV_CLOSED;
305 if (id == SR_CONF_SAMPLERATE) {
306 devc->cur_samplerate = g_variant_get_uint64(data);
307 sr_dbg("%s: setting samplerate to %" PRIu64, __func__,
308 devc->cur_samplerate);
310 } else if (id == SR_CONF_LIMIT_SAMPLES) {
311 devc->limit_msec = 0;
312 devc->limit_samples = g_variant_get_uint64(data);
313 sr_dbg("%s: setting limit_samples to %" PRIu64, __func__,
314 devc->limit_samples);
316 } else if (id == SR_CONF_LIMIT_MSEC) {
317 devc->limit_msec = g_variant_get_uint64(data);
318 devc->limit_samples = 0;
319 sr_dbg("%s: setting limit_msec to %" PRIu64, __func__,
322 } else if (id == SR_CONF_PATTERN_MODE) {
323 stropt = g_variant_get_string(data, NULL);
325 if (!strcmp(stropt, STR_PATTERN_SIGROK)) {
326 devc->sample_generator = PATTERN_SIGROK;
327 } else if (!strcmp(stropt, STR_PATTERN_RANDOM)) {
328 devc->sample_generator = PATTERN_RANDOM;
329 } else if (!strcmp(stropt, STR_PATTERN_INC)) {
330 devc->sample_generator = PATTERN_INC;
331 } else if (!strcmp(stropt, STR_PATTERN_ALL_LOW)) {
332 devc->sample_generator = PATTERN_ALL_LOW;
333 } else if (!strcmp(stropt, STR_PATTERN_ALL_HIGH)) {
334 devc->sample_generator = PATTERN_ALL_HIGH;
338 sr_dbg("%s: setting pattern to %d",
339 __func__, devc->sample_generator);
347 static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi)
355 case SR_CONF_DEVICE_OPTIONS:
356 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
357 hwcaps, ARRAY_SIZE(hwcaps), sizeof(int32_t));
359 case SR_CONF_SAMPLERATE:
360 g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
361 gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates,
362 ARRAY_SIZE(samplerates), sizeof(uint64_t));
363 g_variant_builder_add(&gvb, "{sv}", "samplerate-steps", gvar);
364 *data = g_variant_builder_end(&gvb);
366 case SR_CONF_PATTERN_MODE:
367 *data = g_variant_new_strv(pattern_strings, ARRAY_SIZE(pattern_strings));
376 static void samples_generator(uint8_t *buf, uint64_t size,
377 struct dev_context *devc)
379 static uint64_t p = 0;
383 memset(buf, 0, size);
385 switch (devc->sample_generator) {
386 case PATTERN_SIGROK: /* sigrok pattern */
387 for (i = 0; i < size; i++) {
388 *(buf + i) = ~(pattern_sigrok[
389 p++ % sizeof(pattern_sigrok)] >> 1);
392 case PATTERN_RANDOM: /* Random */
393 for (i = 0; i < size; i++)
394 *(buf + i) = (uint8_t)(rand() & 0xff);
396 case PATTERN_INC: /* Simple increment */
397 for (i = 0; i < size; i++)
400 case PATTERN_ALL_LOW: /* All probes are low */
401 memset(buf, 0x00, size);
403 case PATTERN_ALL_HIGH: /* All probes are high */
404 memset(buf, 0xff, size);
407 sr_err("Unknown pattern: %d.", devc->sample_generator);
412 /* Callback handling data */
413 static int receive_data(int fd, int revents, void *cb_data)
415 struct dev_context *devc = cb_data;
416 struct sr_datafeed_packet packet;
417 struct sr_datafeed_logic logic;
418 uint8_t buf[BUFSIZE];
419 static uint64_t samples_to_send, expected_samplenum, sending_now;
420 int64_t time, elapsed;
425 /* How many "virtual" samples should we have collected by now? */
426 time = g_get_monotonic_time();
427 elapsed = time - devc->starttime;
428 expected_samplenum = elapsed * devc->cur_samplerate / 1000000;
429 /* Of those, how many do we still have to send? */
430 samples_to_send = expected_samplenum - devc->samples_counter;
432 if (devc->limit_samples) {
433 samples_to_send = MIN(samples_to_send,
434 devc->limit_samples - devc->samples_counter);
437 while (samples_to_send > 0) {
438 sending_now = MIN(samples_to_send, sizeof(buf));
439 samples_to_send -= sending_now;
440 samples_generator(buf, sending_now, devc);
442 packet.type = SR_DF_LOGIC;
443 packet.payload = &logic;
444 logic.length = sending_now;
447 sr_session_send(devc->cb_data, &packet);
448 devc->samples_counter += sending_now;
451 if (devc->limit_samples &&
452 devc->samples_counter >= devc->limit_samples) {
453 sr_info("Requested number of samples reached.");
454 hw_dev_acquisition_stop(devc->sdi, cb_data);
461 static int hw_dev_acquisition_start(const struct sr_dev_inst *sdi,
464 struct dev_context *const devc = sdi->priv;
466 if (sdi->status != SR_ST_ACTIVE)
467 return SR_ERR_DEV_CLOSED;
469 devc->cb_data = cb_data;
470 devc->samples_counter = 0;
473 * Setting two channels connected by a pipe is a remnant from when the
474 * demo driver generated data in a thread, and collected and sent the
475 * data in the main program loop.
476 * They are kept here because it provides a convenient way of setting
477 * up a timeout-based polling mechanism.
479 if (pipe(devc->pipe_fds)) {
480 /* TODO: Better error message. */
481 sr_err("%s: pipe() failed", __func__);
485 devc->channel = g_io_channel_unix_new(devc->pipe_fds[0]);
487 g_io_channel_set_flags(devc->channel, G_IO_FLAG_NONBLOCK, NULL);
489 /* Set channel encoding to binary (default is UTF-8). */
490 g_io_channel_set_encoding(devc->channel, NULL, NULL);
492 /* Make channels to unbuffered. */
493 g_io_channel_set_buffered(devc->channel, FALSE);
495 sr_session_source_add_channel(devc->channel, G_IO_IN | G_IO_ERR,
496 40, receive_data, devc);
498 /* Send header packet to the session bus. */
499 std_session_send_df_header(cb_data, LOG_PREFIX);
501 /* We use this timestamp to decide how many more samples to send. */
502 devc->starttime = g_get_monotonic_time();
507 static int hw_dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
509 struct dev_context *const devc = sdi->priv;
510 struct sr_datafeed_packet packet;
514 sr_dbg("Stopping aquisition.");
516 sr_session_source_remove_channel(devc->channel);
517 g_io_channel_shutdown(devc->channel, FALSE, NULL);
518 g_io_channel_unref(devc->channel);
519 devc->channel = NULL;
521 /* Send last packet. */
522 packet.type = SR_DF_END;
523 sr_session_send(devc->cb_data, &packet);
528 SR_PRIV struct sr_dev_driver demo_driver_info = {
530 .longname = "Demo driver and pattern generator",
533 .cleanup = hw_cleanup,
535 .dev_list = hw_dev_list,
536 .dev_clear = clear_instances,
537 .config_get = config_get,
538 .config_set = config_set,
539 .config_list = config_list,
540 .dev_open = hw_dev_open,
541 .dev_close = hw_dev_close,
542 .dev_acquisition_start = hw_dev_acquisition_start,
543 .dev_acquisition_stop = hw_dev_acquisition_stop,