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 struct sr_samplerates samplerates = {
109 static const char *pattern_strings[] = {
118 /* We name the probes 0-7 on our demo driver. */
119 static const char *probe_names[NUM_PROBES + 1] = {
120 "0", "1", "2", "3", "4", "5", "6", "7",
124 static uint8_t pattern_sigrok[] = {
125 0x4c, 0x92, 0x92, 0x92, 0x64, 0x00, 0x00, 0x00,
126 0x82, 0xfe, 0xfe, 0x82, 0x00, 0x00, 0x00, 0x00,
127 0x7c, 0x82, 0x82, 0x92, 0x74, 0x00, 0x00, 0x00,
128 0xfe, 0x12, 0x12, 0x32, 0xcc, 0x00, 0x00, 0x00,
129 0x7c, 0x82, 0x82, 0x82, 0x7c, 0x00, 0x00, 0x00,
130 0xfe, 0x10, 0x28, 0x44, 0x82, 0x00, 0x00, 0x00,
131 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
132 0xbe, 0xbe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
135 /* Private, per-device-instance driver context. */
136 /* TODO: struct context as with the other drivers. */
138 /* List of struct sr_dev_inst, maintained by dev_open()/dev_close(). */
139 SR_PRIV struct sr_dev_driver demo_driver_info;
140 static struct sr_dev_driver *di = &demo_driver_info;
141 static uint64_t cur_samplerate = SR_KHZ(200);
142 static uint64_t limit_samples = 0;
143 static uint64_t limit_msec = 0;
144 static int default_pattern = PATTERN_SIGROK;
146 static int hw_dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data);
148 static int clear_instances(void)
150 /* Nothing needed so far. */
155 static int hw_init(struct sr_context *sr_ctx)
157 return std_hw_init(sr_ctx, di, DRIVER_LOG_DOMAIN);
160 static GSList *hw_scan(GSList *options)
162 struct sr_dev_inst *sdi;
163 struct sr_probe *probe;
164 struct drv_context *drvc;
174 sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, DEMONAME, NULL, NULL);
176 sr_err("%s: sr_dev_inst_new failed", __func__);
181 for (i = 0; probe_names[i]; i++) {
182 if (!(probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE,
185 sdi->probes = g_slist_append(sdi->probes, probe);
188 devices = g_slist_append(devices, sdi);
189 drvc->instances = g_slist_append(drvc->instances, sdi);
194 static GSList *hw_dev_list(void)
196 return ((struct drv_context *)(di->priv))->instances;
199 static int hw_dev_open(struct sr_dev_inst *sdi)
203 /* Nothing needed so far. */
208 static int hw_dev_close(struct sr_dev_inst *sdi)
212 /* Nothing needed so far. */
217 static int hw_cleanup(void)
219 /* Nothing needed so far. */
223 static int config_get(int id, const void **data, const struct sr_dev_inst *sdi)
228 case SR_CONF_SAMPLERATE:
229 *data = &cur_samplerate;
231 case SR_CONF_LIMIT_SAMPLES:
232 *data = &limit_samples;
234 case SR_CONF_LIMIT_MSEC:
237 case SR_CONF_PATTERN_MODE:
238 switch (default_pattern) {
240 *data = STR_PATTERN_SIGROK;
243 *data = STR_PATTERN_RANDOM;
246 *data = STR_PATTERN_INC;
248 case PATTERN_ALL_LOW:
249 *data = STR_PATTERN_ALL_LOW;
251 case PATTERN_ALL_HIGH:
252 *data = STR_PATTERN_ALL_HIGH;
263 static int config_set(int id, const void *value, const struct sr_dev_inst *sdi)
270 if (id == SR_CONF_SAMPLERATE) {
271 cur_samplerate = *(const uint64_t *)value;
272 sr_dbg("%s: setting samplerate to %" PRIu64, __func__,
275 } else if (id == SR_CONF_LIMIT_SAMPLES) {
277 limit_samples = *(const uint64_t *)value;
278 sr_dbg("%s: setting limit_samples to %" PRIu64, __func__,
281 } else if (id == SR_CONF_LIMIT_MSEC) {
282 limit_msec = *(const uint64_t *)value;
284 sr_dbg("%s: setting limit_msec to %" PRIu64, __func__,
287 } else if (id == SR_CONF_PATTERN_MODE) {
290 if (!strcmp(stropt, STR_PATTERN_SIGROK)) {
291 default_pattern = PATTERN_SIGROK;
292 } else if (!strcmp(stropt, STR_PATTERN_RANDOM)) {
293 default_pattern = PATTERN_RANDOM;
294 } else if (!strcmp(stropt, STR_PATTERN_INC)) {
295 default_pattern = PATTERN_INC;
296 } else if (!strcmp(stropt, STR_PATTERN_ALL_LOW)) {
297 default_pattern = PATTERN_ALL_LOW;
298 } else if (!strcmp(stropt, STR_PATTERN_ALL_HIGH)) {
299 default_pattern = PATTERN_ALL_HIGH;
303 sr_dbg("%s: setting pattern to %d", __func__, default_pattern);
311 static int config_list(int key, const void **data, const struct sr_dev_inst *sdi)
317 case SR_CONF_DEVICE_OPTIONS:
320 case SR_CONF_SAMPLERATE:
321 *data = &samplerates;
323 case SR_CONF_PATTERN_MODE:
324 *data = &pattern_strings;
333 static void samples_generator(uint8_t *buf, uint64_t size,
334 struct dev_context *devc)
336 static uint64_t p = 0;
340 memset(buf, 0, size);
342 switch (devc->sample_generator) {
343 case PATTERN_SIGROK: /* sigrok pattern */
344 for (i = 0; i < size; i++) {
345 *(buf + i) = ~(pattern_sigrok[p] >> 1);
350 case PATTERN_RANDOM: /* Random */
351 for (i = 0; i < size; i++)
352 *(buf + i) = (uint8_t)(rand() & 0xff);
354 case PATTERN_INC: /* Simple increment */
355 for (i = 0; i < size; i++)
358 case PATTERN_ALL_LOW: /* All probes are low */
359 memset(buf, 0x00, size);
361 case PATTERN_ALL_HIGH: /* All probes are high */
362 memset(buf, 0xff, size);
365 sr_err("Unknown pattern: %d.", devc->sample_generator);
370 /* Callback handling data */
371 static int receive_data(int fd, int revents, void *cb_data)
373 struct dev_context *devc = cb_data;
374 struct sr_datafeed_packet packet;
375 struct sr_datafeed_logic logic;
376 uint8_t buf[BUFSIZE];
377 static uint64_t samples_to_send, expected_samplenum, sending_now;
378 int64_t time, elapsed;
383 /* How many "virtual" samples should we have collected by now? */
384 time = g_get_monotonic_time();
385 elapsed = time - devc->starttime;
386 expected_samplenum = elapsed * cur_samplerate / 1000000;
387 /* Of those, how many do we still have to send? */
388 samples_to_send = expected_samplenum - devc->samples_counter;
391 samples_to_send = MIN(samples_to_send,
392 limit_samples - devc->samples_counter);
395 while (samples_to_send > 0) {
396 sending_now = MIN(samples_to_send, sizeof(buf));
397 samples_to_send -= sending_now;
398 samples_generator(buf, sending_now, devc);
400 packet.type = SR_DF_LOGIC;
401 packet.payload = &logic;
402 logic.length = sending_now;
405 sr_session_send(devc->cb_data, &packet);
406 devc->samples_counter += sending_now;
409 if (limit_samples && devc->samples_counter >= limit_samples) {
410 sr_info("Requested number of samples reached.");
411 hw_dev_acquisition_stop(NULL, cb_data);
418 static int hw_dev_acquisition_start(const struct sr_dev_inst *sdi,
421 struct dev_context *devc;
425 /* TODO: 'devc' is never g_free()'d? */
426 if (!(devc = g_try_malloc(sizeof(struct dev_context)))) {
427 sr_err("%s: devc malloc failed", __func__);
428 return SR_ERR_MALLOC;
431 devc->sample_generator = default_pattern;
432 devc->cb_data = cb_data;
433 devc->samples_counter = 0;
436 * Setting two channels connected by a pipe is a remnant from when the
437 * demo driver generated data in a thread, and collected and sent the
438 * data in the main program loop.
439 * They are kept here because it provides a convenient way of setting
440 * up a timeout-based polling mechanism.
442 if (pipe(devc->pipe_fds)) {
443 /* TODO: Better error message. */
444 sr_err("%s: pipe() failed", __func__);
448 devc->channels[0] = g_io_channel_unix_new(devc->pipe_fds[0]);
449 devc->channels[1] = g_io_channel_unix_new(devc->pipe_fds[1]);
451 g_io_channel_set_flags(devc->channels[0], G_IO_FLAG_NONBLOCK, NULL);
453 /* Set channel encoding to binary (default is UTF-8). */
454 g_io_channel_set_encoding(devc->channels[0], NULL, NULL);
455 g_io_channel_set_encoding(devc->channels[1], NULL, NULL);
457 /* Make channels to unbuffered. */
458 g_io_channel_set_buffered(devc->channels[0], FALSE);
459 g_io_channel_set_buffered(devc->channels[1], FALSE);
461 sr_session_source_add_channel(devc->channels[0], G_IO_IN | G_IO_ERR,
462 40, receive_data, devc);
464 /* Send header packet to the session bus. */
465 std_session_send_df_header(cb_data, DRIVER_LOG_DOMAIN);
467 /* We use this timestamp to decide how many more samples to send. */
468 devc->starttime = g_get_monotonic_time();
473 static int hw_dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
475 struct dev_context *devc;
476 struct sr_datafeed_packet packet;
482 sr_dbg("Stopping aquisition.");
484 sr_session_source_remove_channel(devc->channels[0]);
485 g_io_channel_shutdown(devc->channels[0], FALSE, NULL);
487 /* Send last packet. */
488 packet.type = SR_DF_END;
489 sr_session_send(devc->cb_data, &packet);
494 SR_PRIV struct sr_dev_driver demo_driver_info = {
496 .longname = "Demo driver and pattern generator",
499 .cleanup = hw_cleanup,
501 .dev_list = hw_dev_list,
502 .dev_clear = clear_instances,
503 .config_get = config_get,
504 .config_set = config_set,
505 .config_list = config_list,
506 .dev_open = hw_dev_open,
507 .dev_close = hw_dev_close,
508 .dev_acquisition_start = hw_dev_acquisition_start,
509 .dev_acquisition_stop = hw_dev_acquisition_stop,