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 /* Supported patterns which we can generate */
55 * Pattern which spells "sigrok" using '0's (with '1's as "background")
56 * when displayed using the 'bits' output format.
60 /** Pattern which consists of (pseudo-)random values on all probes. */
64 * Pattern which consists of incrementing numbers.
65 * TODO: Better description.
69 /** Pattern where all probes have a low logic state. */
72 /** Pattern where all probes have a high logic state. */
76 /* Private, per-device-instance driver context. */
79 GIOChannel *channels[2];
80 uint8_t sample_generator;
81 uint64_t samples_counter;
86 static const int hwcaps[] = {
87 SR_CONF_LOGIC_ANALYZER,
91 SR_CONF_LIMIT_SAMPLES,
96 static const struct sr_samplerates samplerates = {
103 static const char *pattern_strings[] = {
112 /* We name the probes 0-7 on our demo driver. */
113 static const char *probe_names[NUM_PROBES + 1] = {
114 "0", "1", "2", "3", "4", "5", "6", "7",
118 static uint8_t pattern_sigrok[] = {
119 0x4c, 0x92, 0x92, 0x92, 0x64, 0x00, 0x00, 0x00,
120 0x82, 0xfe, 0xfe, 0x82, 0x00, 0x00, 0x00, 0x00,
121 0x7c, 0x82, 0x82, 0x92, 0x74, 0x00, 0x00, 0x00,
122 0xfe, 0x12, 0x12, 0x32, 0xcc, 0x00, 0x00, 0x00,
123 0x7c, 0x82, 0x82, 0x82, 0x7c, 0x00, 0x00, 0x00,
124 0xfe, 0x10, 0x28, 0x44, 0x82, 0x00, 0x00, 0x00,
125 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
126 0xbe, 0xbe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
129 /* Private, per-device-instance driver context. */
130 /* TODO: struct context as with the other drivers. */
132 /* List of struct sr_dev_inst, maintained by dev_open()/dev_close(). */
133 SR_PRIV struct sr_dev_driver demo_driver_info;
134 static struct sr_dev_driver *di = &demo_driver_info;
135 static uint64_t cur_samplerate = SR_KHZ(200);
136 static uint64_t limit_samples = 0;
137 static uint64_t limit_msec = 0;
138 static int default_pattern = PATTERN_SIGROK;
140 static int hw_dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data);
142 static int clear_instances(void)
144 /* Nothing needed so far. */
149 static int hw_init(struct sr_context *sr_ctx)
151 return std_hw_init(sr_ctx, di, DRIVER_LOG_DOMAIN);
154 static GSList *hw_scan(GSList *options)
156 struct sr_dev_inst *sdi;
157 struct sr_probe *probe;
158 struct drv_context *drvc;
168 sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, DEMONAME, NULL, NULL);
170 sr_err("%s: sr_dev_inst_new failed", __func__);
175 for (i = 0; probe_names[i]; i++) {
176 if (!(probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE,
179 sdi->probes = g_slist_append(sdi->probes, probe);
182 devices = g_slist_append(devices, sdi);
183 drvc->instances = g_slist_append(drvc->instances, sdi);
188 static GSList *hw_dev_list(void)
190 return ((struct drv_context *)(di->priv))->instances;
193 static int hw_dev_open(struct sr_dev_inst *sdi)
197 /* Nothing needed so far. */
202 static int hw_dev_close(struct sr_dev_inst *sdi)
206 /* Nothing needed so far. */
211 static int hw_cleanup(void)
213 /* Nothing needed so far. */
217 static int config_get(int id, const void **data, const struct sr_dev_inst *sdi)
222 case SR_CONF_SAMPLERATE:
223 *data = &cur_samplerate;
232 static int config_set(int id, const void *value, const struct sr_dev_inst *sdi)
239 if (id == SR_CONF_SAMPLERATE) {
240 cur_samplerate = *(const uint64_t *)value;
241 sr_dbg("%s: setting samplerate to %" PRIu64, __func__,
244 } else if (id == SR_CONF_LIMIT_SAMPLES) {
246 limit_samples = *(const uint64_t *)value;
247 sr_dbg("%s: setting limit_samples to %" PRIu64, __func__,
250 } else if (id == SR_CONF_LIMIT_MSEC) {
251 limit_msec = *(const uint64_t *)value;
253 sr_dbg("%s: setting limit_msec to %" PRIu64, __func__,
256 } else if (id == SR_CONF_PATTERN_MODE) {
259 if (!strcmp(stropt, "sigrok")) {
260 default_pattern = PATTERN_SIGROK;
261 } else if (!strcmp(stropt, "random")) {
262 default_pattern = PATTERN_RANDOM;
263 } else if (!strcmp(stropt, "incremental")) {
264 default_pattern = PATTERN_INC;
265 } else if (!strcmp(stropt, "all-low")) {
266 default_pattern = PATTERN_ALL_LOW;
267 } else if (!strcmp(stropt, "all-high")) {
268 default_pattern = PATTERN_ALL_HIGH;
272 sr_dbg("%s: setting pattern to %d", __func__, default_pattern);
280 static int config_list(int key, const void **data, const struct sr_dev_inst *sdi)
286 case SR_CONF_DEVICE_OPTIONS:
289 case SR_CONF_SAMPLERATE:
290 *data = &samplerates;
292 case SR_CONF_PATTERN_MODE:
293 *data = &pattern_strings;
302 static void samples_generator(uint8_t *buf, uint64_t size,
303 struct dev_context *devc)
305 static uint64_t p = 0;
309 memset(buf, 0, size);
311 switch (devc->sample_generator) {
312 case PATTERN_SIGROK: /* sigrok pattern */
313 for (i = 0; i < size; i++) {
314 *(buf + i) = ~(pattern_sigrok[p] >> 1);
319 case PATTERN_RANDOM: /* Random */
320 for (i = 0; i < size; i++)
321 *(buf + i) = (uint8_t)(rand() & 0xff);
323 case PATTERN_INC: /* Simple increment */
324 for (i = 0; i < size; i++)
327 case PATTERN_ALL_LOW: /* All probes are low */
328 memset(buf, 0x00, size);
330 case PATTERN_ALL_HIGH: /* All probes are high */
331 memset(buf, 0xff, size);
334 sr_err("Unknown pattern: %d.", devc->sample_generator);
339 /* Callback handling data */
340 static int receive_data(int fd, int revents, void *cb_data)
342 struct dev_context *devc = cb_data;
343 struct sr_datafeed_packet packet;
344 struct sr_datafeed_logic logic;
345 uint8_t buf[BUFSIZE];
346 static uint64_t samples_to_send, expected_samplenum, sending_now;
347 int64_t time, elapsed;
352 /* How many "virtual" samples should we have collected by now? */
353 time = g_get_monotonic_time();
354 elapsed = time - devc->starttime;
355 expected_samplenum = elapsed * cur_samplerate / 1000000;
356 /* Of those, how many do we still have to send? */
357 samples_to_send = expected_samplenum - devc->samples_counter;
360 samples_to_send = MIN(samples_to_send,
361 limit_samples - devc->samples_counter);
364 while (samples_to_send > 0) {
365 sending_now = MIN(samples_to_send, sizeof(buf));
366 samples_to_send -= sending_now;
367 samples_generator(buf, sending_now, devc);
369 packet.type = SR_DF_LOGIC;
370 packet.payload = &logic;
371 logic.length = sending_now;
374 sr_session_send(devc->cb_data, &packet);
375 devc->samples_counter += sending_now;
378 if (limit_samples && devc->samples_counter >= limit_samples) {
379 sr_info("Requested number of samples reached.");
380 hw_dev_acquisition_stop(NULL, cb_data);
387 static int hw_dev_acquisition_start(const struct sr_dev_inst *sdi,
390 struct dev_context *devc;
394 /* TODO: 'devc' is never g_free()'d? */
395 if (!(devc = g_try_malloc(sizeof(struct dev_context)))) {
396 sr_err("%s: devc malloc failed", __func__);
397 return SR_ERR_MALLOC;
400 devc->sample_generator = default_pattern;
401 devc->cb_data = cb_data;
402 devc->samples_counter = 0;
405 * Setting two channels connected by a pipe is a remnant from when the
406 * demo driver generated data in a thread, and collected and sent the
407 * data in the main program loop.
408 * They are kept here because it provides a convenient way of setting
409 * up a timeout-based polling mechanism.
411 if (pipe(devc->pipe_fds)) {
412 /* TODO: Better error message. */
413 sr_err("%s: pipe() failed", __func__);
417 devc->channels[0] = g_io_channel_unix_new(devc->pipe_fds[0]);
418 devc->channels[1] = g_io_channel_unix_new(devc->pipe_fds[1]);
420 g_io_channel_set_flags(devc->channels[0], G_IO_FLAG_NONBLOCK, NULL);
422 /* Set channel encoding to binary (default is UTF-8). */
423 g_io_channel_set_encoding(devc->channels[0], NULL, NULL);
424 g_io_channel_set_encoding(devc->channels[1], NULL, NULL);
426 /* Make channels to unbuffered. */
427 g_io_channel_set_buffered(devc->channels[0], FALSE);
428 g_io_channel_set_buffered(devc->channels[1], FALSE);
430 sr_session_source_add_channel(devc->channels[0], G_IO_IN | G_IO_ERR,
431 40, receive_data, devc);
433 /* Send header packet to the session bus. */
434 std_session_send_df_header(cb_data, DRIVER_LOG_DOMAIN);
436 /* We use this timestamp to decide how many more samples to send. */
437 devc->starttime = g_get_monotonic_time();
442 static int hw_dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
444 struct dev_context *devc;
445 struct sr_datafeed_packet packet;
451 sr_dbg("Stopping aquisition.");
453 sr_session_source_remove_channel(devc->channels[0]);
454 g_io_channel_shutdown(devc->channels[0], FALSE, NULL);
456 /* Send last packet. */
457 packet.type = SR_DF_END;
458 sr_session_send(devc->cb_data, &packet);
463 SR_PRIV struct sr_dev_driver demo_driver_info = {
465 .longname = "Demo driver and pattern generator",
468 .cleanup = hw_cleanup,
470 .dev_list = hw_dev_list,
471 .dev_clear = clear_instances,
472 .config_get = config_get,
473 .config_set = config_set,
474 .config_list = config_list,
475 .dev_open = hw_dev_open,
476 .dev_close = hw_dev_close,
477 .dev_acquisition_start = hw_dev_acquisition_start,
478 .dev_acquisition_stop = hw_dev_acquisition_stop,