2 * This file is part of the sigrok 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 driver-specific prefix string. */
35 #define DRIVER_LOG_DOMAIN "demo: "
36 #define sr_log(l, s, args...) sr_log(l, DRIVER_LOG_DOMAIN s, ## args)
37 #define sr_spew(s, args...) sr_spew(DRIVER_LOG_DOMAIN s, ## args)
38 #define sr_dbg(s, args...) sr_dbg(DRIVER_LOG_DOMAIN s, ## args)
39 #define sr_info(s, args...) sr_info(DRIVER_LOG_DOMAIN s, ## args)
40 #define sr_warn(s, args...) sr_warn(DRIVER_LOG_DOMAIN s, ## args)
41 #define sr_err(s, args...) sr_err(DRIVER_LOG_DOMAIN 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. */
85 GIOChannel *channels[2];
86 uint8_t sample_generator;
87 uint64_t samples_counter;
92 static const int hwcaps[] = {
93 SR_CONF_LOGIC_ANALYZER,
97 SR_CONF_LIMIT_SAMPLES,
102 static const uint64_t samplerates[] = {
108 static const char *pattern_strings[] = {
116 /* We name the probes 0-7 on our demo driver. */
117 static const char *probe_names[NUM_PROBES + 1] = {
118 "0", "1", "2", "3", "4", "5", "6", "7",
122 static uint8_t pattern_sigrok[] = {
123 0x4c, 0x92, 0x92, 0x92, 0x64, 0x00, 0x00, 0x00,
124 0x82, 0xfe, 0xfe, 0x82, 0x00, 0x00, 0x00, 0x00,
125 0x7c, 0x82, 0x82, 0x92, 0x74, 0x00, 0x00, 0x00,
126 0xfe, 0x12, 0x12, 0x32, 0xcc, 0x00, 0x00, 0x00,
127 0x7c, 0x82, 0x82, 0x82, 0x7c, 0x00, 0x00, 0x00,
128 0xfe, 0x10, 0x28, 0x44, 0x82, 0x00, 0x00, 0x00,
129 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
130 0xbe, 0xbe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
133 /* Private, per-device-instance driver context. */
134 /* TODO: struct context as with the other drivers. */
136 /* List of struct sr_dev_inst, maintained by dev_open()/dev_close(). */
137 SR_PRIV struct sr_dev_driver demo_driver_info;
138 static struct sr_dev_driver *di = &demo_driver_info;
139 static uint64_t cur_samplerate = SR_KHZ(200);
140 static uint64_t limit_samples = 0;
141 static uint64_t limit_msec = 0;
142 static int default_pattern = PATTERN_SIGROK;
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, DRIVER_LOG_DOMAIN);
158 static GSList *hw_scan(GSList *options)
160 struct sr_dev_inst *sdi;
161 struct sr_probe *probe;
162 struct drv_context *drvc;
172 sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, DEMONAME, NULL, NULL);
174 sr_err("%s: sr_dev_inst_new failed", __func__);
179 for (i = 0; probe_names[i]; i++) {
180 if (!(probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE,
183 sdi->probes = g_slist_append(sdi->probes, probe);
186 devices = g_slist_append(devices, sdi);
187 drvc->instances = g_slist_append(drvc->instances, sdi);
192 static GSList *hw_dev_list(void)
194 return ((struct drv_context *)(di->priv))->instances;
197 static int hw_dev_open(struct sr_dev_inst *sdi)
201 /* Nothing needed so far. */
206 static int hw_dev_close(struct sr_dev_inst *sdi)
210 /* Nothing needed so far. */
215 static int hw_cleanup(void)
217 /* Nothing needed so far. */
221 static int config_get(int id, GVariant **data, const struct sr_dev_inst *sdi)
226 case SR_CONF_SAMPLERATE:
227 *data = g_variant_new_uint64(cur_samplerate);
229 case SR_CONF_LIMIT_SAMPLES:
230 *data = g_variant_new_uint64(limit_samples);
232 case SR_CONF_LIMIT_MSEC:
233 *data = g_variant_new_uint64(limit_msec);
235 case SR_CONF_PATTERN_MODE:
236 switch (default_pattern) {
238 *data = g_variant_new_string(STR_PATTERN_SIGROK);
241 *data = g_variant_new_string(STR_PATTERN_RANDOM);
244 *data = g_variant_new_string(STR_PATTERN_INC);
246 case PATTERN_ALL_LOW:
247 *data = g_variant_new_string(STR_PATTERN_ALL_LOW);
249 case PATTERN_ALL_HIGH:
250 *data = g_variant_new_string(STR_PATTERN_ALL_HIGH);
261 static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi)
268 if (id == SR_CONF_SAMPLERATE) {
269 cur_samplerate = g_variant_get_uint64(data);
270 sr_dbg("%s: setting samplerate to %" PRIu64, __func__,
273 } else if (id == SR_CONF_LIMIT_SAMPLES) {
275 limit_samples = g_variant_get_uint64(data);
276 sr_dbg("%s: setting limit_samples to %" PRIu64, __func__,
279 } else if (id == SR_CONF_LIMIT_MSEC) {
280 limit_msec = g_variant_get_uint64(data);
282 sr_dbg("%s: setting limit_msec to %" PRIu64, __func__,
285 } else if (id == SR_CONF_PATTERN_MODE) {
286 stropt = g_variant_get_string(data, NULL);
288 if (!strcmp(stropt, STR_PATTERN_SIGROK)) {
289 default_pattern = PATTERN_SIGROK;
290 } else if (!strcmp(stropt, STR_PATTERN_RANDOM)) {
291 default_pattern = PATTERN_RANDOM;
292 } else if (!strcmp(stropt, STR_PATTERN_INC)) {
293 default_pattern = PATTERN_INC;
294 } else if (!strcmp(stropt, STR_PATTERN_ALL_LOW)) {
295 default_pattern = PATTERN_ALL_LOW;
296 } else if (!strcmp(stropt, STR_PATTERN_ALL_HIGH)) {
297 default_pattern = PATTERN_ALL_HIGH;
301 sr_dbg("%s: setting pattern to %d", __func__, default_pattern);
309 static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi)
317 case SR_CONF_DEVICE_OPTIONS:
318 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
319 hwcaps, ARRAY_SIZE(hwcaps), sizeof(int32_t));
321 case SR_CONF_SAMPLERATE:
322 g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
323 gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates,
324 ARRAY_SIZE(samplerates), sizeof(uint64_t));
325 g_variant_builder_add(&gvb, "{sv}", "samplerate-steps", gvar);
326 *data = g_variant_builder_end(&gvb);
328 case SR_CONF_PATTERN_MODE:
329 *data = g_variant_new_strv(pattern_strings, ARRAY_SIZE(pattern_strings));
338 static void samples_generator(uint8_t *buf, uint64_t size,
339 struct dev_context *devc)
341 static uint64_t p = 0;
345 memset(buf, 0, size);
347 switch (devc->sample_generator) {
348 case PATTERN_SIGROK: /* sigrok pattern */
349 for (i = 0; i < size; i++) {
350 *(buf + i) = ~(pattern_sigrok[p] >> 1);
355 case PATTERN_RANDOM: /* Random */
356 for (i = 0; i < size; i++)
357 *(buf + i) = (uint8_t)(rand() & 0xff);
359 case PATTERN_INC: /* Simple increment */
360 for (i = 0; i < size; i++)
363 case PATTERN_ALL_LOW: /* All probes are low */
364 memset(buf, 0x00, size);
366 case PATTERN_ALL_HIGH: /* All probes are high */
367 memset(buf, 0xff, size);
370 sr_err("Unknown pattern: %d.", devc->sample_generator);
375 /* Callback handling data */
376 static int receive_data(int fd, int revents, void *cb_data)
378 struct dev_context *devc = cb_data;
379 struct sr_datafeed_packet packet;
380 struct sr_datafeed_logic logic;
381 uint8_t buf[BUFSIZE];
382 static uint64_t samples_to_send, expected_samplenum, sending_now;
383 int64_t time, elapsed;
388 /* How many "virtual" samples should we have collected by now? */
389 time = g_get_monotonic_time();
390 elapsed = time - devc->starttime;
391 expected_samplenum = elapsed * cur_samplerate / 1000000;
392 /* Of those, how many do we still have to send? */
393 samples_to_send = expected_samplenum - devc->samples_counter;
396 samples_to_send = MIN(samples_to_send,
397 limit_samples - devc->samples_counter);
400 while (samples_to_send > 0) {
401 sending_now = MIN(samples_to_send, sizeof(buf));
402 samples_to_send -= sending_now;
403 samples_generator(buf, sending_now, devc);
405 packet.type = SR_DF_LOGIC;
406 packet.payload = &logic;
407 logic.length = sending_now;
410 sr_session_send(devc->cb_data, &packet);
411 devc->samples_counter += sending_now;
414 if (limit_samples && devc->samples_counter >= limit_samples) {
415 sr_info("Requested number of samples reached.");
416 hw_dev_acquisition_stop(NULL, cb_data);
423 static int hw_dev_acquisition_start(const struct sr_dev_inst *sdi,
426 struct dev_context *devc;
430 /* TODO: 'devc' is never g_free()'d? */
431 if (!(devc = g_try_malloc(sizeof(struct dev_context)))) {
432 sr_err("%s: devc malloc failed", __func__);
433 return SR_ERR_MALLOC;
436 devc->sample_generator = default_pattern;
437 devc->cb_data = cb_data;
438 devc->samples_counter = 0;
441 * Setting two channels connected by a pipe is a remnant from when the
442 * demo driver generated data in a thread, and collected and sent the
443 * data in the main program loop.
444 * They are kept here because it provides a convenient way of setting
445 * up a timeout-based polling mechanism.
447 if (pipe(devc->pipe_fds)) {
448 /* TODO: Better error message. */
449 sr_err("%s: pipe() failed", __func__);
453 devc->channels[0] = g_io_channel_unix_new(devc->pipe_fds[0]);
454 devc->channels[1] = g_io_channel_unix_new(devc->pipe_fds[1]);
456 g_io_channel_set_flags(devc->channels[0], G_IO_FLAG_NONBLOCK, NULL);
458 /* Set channel encoding to binary (default is UTF-8). */
459 g_io_channel_set_encoding(devc->channels[0], NULL, NULL);
460 g_io_channel_set_encoding(devc->channels[1], NULL, NULL);
462 /* Make channels to unbuffered. */
463 g_io_channel_set_buffered(devc->channels[0], FALSE);
464 g_io_channel_set_buffered(devc->channels[1], FALSE);
466 sr_session_source_add_channel(devc->channels[0], G_IO_IN | G_IO_ERR,
467 40, receive_data, devc);
469 /* Send header packet to the session bus. */
470 std_session_send_df_header(cb_data, DRIVER_LOG_DOMAIN);
472 /* We use this timestamp to decide how many more samples to send. */
473 devc->starttime = g_get_monotonic_time();
478 static int hw_dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
480 struct dev_context *devc;
481 struct sr_datafeed_packet packet;
487 sr_dbg("Stopping aquisition.");
489 sr_session_source_remove_channel(devc->channels[0]);
490 g_io_channel_shutdown(devc->channels[0], FALSE, NULL);
492 /* Send last packet. */
493 packet.type = SR_DF_END;
494 sr_session_send(devc->cb_data, &packet);
499 SR_PRIV struct sr_dev_driver demo_driver_info = {
501 .longname = "Demo driver and pattern generator",
504 .cleanup = hw_cleanup,
506 .dev_list = hw_dev_list,
507 .dev_clear = clear_instances,
508 .config_get = config_get,
509 .config_set = config_set,
510 .config_list = config_list,
511 .dev_open = hw_dev_open,
512 .dev_close = hw_dev_close,
513 .dev_acquisition_start = hw_dev_acquisition_start,
514 .dev_acquisition_stop = hw_dev_acquisition_stop,