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_HWCAP_LOGIC_ANALYZER,
90 SR_HWCAP_PATTERN_MODE,
91 SR_HWCAP_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] = {
125 static uint8_t pattern_sigrok[] = {
126 0x4c, 0x92, 0x92, 0x92, 0x64, 0x00, 0x00, 0x00,
127 0x82, 0xfe, 0xfe, 0x82, 0x00, 0x00, 0x00, 0x00,
128 0x7c, 0x82, 0x82, 0x92, 0x74, 0x00, 0x00, 0x00,
129 0xfe, 0x12, 0x12, 0x32, 0xcc, 0x00, 0x00, 0x00,
130 0x7c, 0x82, 0x82, 0x82, 0x7c, 0x00, 0x00, 0x00,
131 0xfe, 0x10, 0x28, 0x44, 0x82, 0x00, 0x00, 0x00,
132 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
133 0xbe, 0xbe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
136 /* Private, per-device-instance driver context. */
137 /* TODO: struct context as with the other drivers. */
139 /* List of struct sr_dev_inst, maintained by dev_open()/dev_close(). */
140 SR_PRIV struct sr_dev_driver demo_driver_info;
141 static struct sr_dev_driver *di = &demo_driver_info;
142 static uint64_t cur_samplerate = SR_KHZ(200);
143 static uint64_t limit_samples = 0;
144 static uint64_t limit_msec = 0;
145 static int default_pattern = PATTERN_SIGROK;
147 static int hw_dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data);
149 static int clear_instances(void)
151 /* Nothing needed so far. */
156 static int hw_init(struct sr_context *sr_ctx)
158 struct drv_context *drvc;
160 if (!(drvc = g_try_malloc0(sizeof(struct drv_context)))) {
161 sr_err("Driver context malloc failed.");
162 return SR_ERR_MALLOC;
164 drvc->sr_ctx = sr_ctx;
170 static GSList *hw_scan(GSList *options)
172 struct sr_dev_inst *sdi;
173 struct sr_probe *probe;
174 struct drv_context *drvc;
183 sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, DEMONAME, NULL, NULL);
185 sr_err("%s: sr_dev_inst_new failed", __func__);
190 for (i = 0; probe_names[i]; i++) {
191 if (!(probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE,
194 sdi->probes = g_slist_append(sdi->probes, probe);
197 devices = g_slist_append(devices, sdi);
198 drvc->instances = g_slist_append(drvc->instances, sdi);
203 static GSList *hw_dev_list(void)
205 struct drv_context *drvc;
209 return drvc->instances;
212 static int hw_dev_open(struct sr_dev_inst *sdi)
216 /* Nothing needed so far. */
221 static int hw_dev_close(struct sr_dev_inst *sdi)
225 /* Nothing needed so far. */
230 static int hw_cleanup(void)
232 /* Nothing needed so far. */
236 static int hw_info_get(int info_id, const void **data,
237 const struct sr_dev_inst *sdi)
245 case SR_DI_NUM_PROBES:
246 *data = GINT_TO_POINTER(NUM_PROBES);
248 case SR_DI_PROBE_NAMES:
251 case SR_DI_SAMPLERATES:
252 *data = &samplerates;
254 case SR_DI_CUR_SAMPLERATE:
255 *data = &cur_samplerate;
258 *data = &pattern_strings;
267 static int hw_dev_config_set(const struct sr_dev_inst *sdi, int hwcap,
275 if (hwcap == SR_HWCAP_SAMPLERATE) {
276 cur_samplerate = *(const uint64_t *)value;
277 sr_dbg("%s: setting samplerate to %" PRIu64, __func__,
280 } else if (hwcap == SR_HWCAP_LIMIT_SAMPLES) {
282 limit_samples = *(const uint64_t *)value;
283 sr_dbg("%s: setting limit_samples to %" PRIu64, __func__,
286 } else if (hwcap == SR_HWCAP_LIMIT_MSEC) {
287 limit_msec = *(const uint64_t *)value;
289 sr_dbg("%s: setting limit_msec to %" PRIu64, __func__,
292 } else if (hwcap == SR_HWCAP_PATTERN_MODE) {
295 if (!strcmp(stropt, "sigrok")) {
296 default_pattern = PATTERN_SIGROK;
297 } else if (!strcmp(stropt, "random")) {
298 default_pattern = PATTERN_RANDOM;
299 } else if (!strcmp(stropt, "incremental")) {
300 default_pattern = PATTERN_INC;
301 } else if (!strcmp(stropt, "all-low")) {
302 default_pattern = PATTERN_ALL_LOW;
303 } else if (!strcmp(stropt, "all-high")) {
304 default_pattern = PATTERN_ALL_HIGH;
308 sr_dbg("%s: setting pattern to %d", __func__, default_pattern);
316 static void samples_generator(uint8_t *buf, uint64_t size,
317 struct dev_context *devc)
319 static uint64_t p = 0;
323 memset(buf, 0, size);
325 switch (devc->sample_generator) {
326 case PATTERN_SIGROK: /* sigrok pattern */
327 for (i = 0; i < size; i++) {
328 *(buf + i) = ~(pattern_sigrok[p] >> 1);
333 case PATTERN_RANDOM: /* Random */
334 for (i = 0; i < size; i++)
335 *(buf + i) = (uint8_t)(rand() & 0xff);
337 case PATTERN_INC: /* Simple increment */
338 for (i = 0; i < size; i++)
341 case PATTERN_ALL_LOW: /* All probes are low */
342 memset(buf, 0x00, size);
344 case PATTERN_ALL_HIGH: /* All probes are high */
345 memset(buf, 0xff, size);
348 sr_err("Unknown pattern: %d.", devc->sample_generator);
353 /* Callback handling data */
354 static int receive_data(int fd, int revents, void *cb_data)
356 struct dev_context *devc = cb_data;
357 struct sr_datafeed_packet packet;
358 struct sr_datafeed_logic logic;
359 uint8_t buf[BUFSIZE];
360 static uint64_t samples_to_send, expected_samplenum, sending_now;
361 int64_t time, elapsed;
366 /* How many "virtual" samples should we have collected by now? */
367 time = g_get_monotonic_time();
368 elapsed = time - devc->starttime;
369 expected_samplenum = elapsed * cur_samplerate / 1000000;
370 /* Of those, how many do we still have to send? */
371 samples_to_send = expected_samplenum - devc->samples_counter;
374 samples_to_send = MIN(samples_to_send,
375 limit_samples - devc->samples_counter);
378 while (samples_to_send > 0) {
379 sending_now = MIN(samples_to_send, sizeof(buf));
380 samples_to_send -= sending_now;
381 samples_generator(buf, sending_now, devc);
383 packet.type = SR_DF_LOGIC;
384 packet.payload = &logic;
385 logic.length = sending_now;
388 sr_session_send(devc->session_dev_id, &packet);
389 devc->samples_counter += sending_now;
393 if (devc->samples_counter >= limit_samples) {
394 sr_spew("We sent a total of %" PRIu64 " samples.",
395 devc->samples_counter);
396 /* Make sure we don't receive more packets. */
397 hw_dev_acquisition_stop(NULL, cb_data);
404 static int hw_dev_acquisition_start(const struct sr_dev_inst *sdi,
407 struct sr_datafeed_packet *packet;
408 struct sr_datafeed_header *header;
409 struct sr_datafeed_meta_logic meta;
410 struct dev_context *devc;
414 sr_dbg("Starting acquisition.");
416 /* TODO: 'devc' is never g_free()'d? */
417 if (!(devc = g_try_malloc(sizeof(struct dev_context)))) {
418 sr_err("%s: devc malloc failed", __func__);
419 return SR_ERR_MALLOC;
422 devc->sample_generator = default_pattern;
423 devc->session_dev_id = cb_data;
424 devc->samples_counter = 0;
427 * Setting two channels connected by a pipe is a remnant from when the
428 * demo driver generated data in a thread, and collected and sent the
429 * data in the main program loop.
430 * They are kept here because it provides a convenient way of setting
431 * up a timeout-based polling mechanism.
433 if (pipe(devc->pipe_fds)) {
434 /* TODO: Better error message. */
435 sr_err("%s: pipe() failed", __func__);
439 devc->channels[0] = g_io_channel_unix_new(devc->pipe_fds[0]);
440 devc->channels[1] = g_io_channel_unix_new(devc->pipe_fds[1]);
442 g_io_channel_set_flags(devc->channels[0], G_IO_FLAG_NONBLOCK, NULL);
444 /* Set channel encoding to binary (default is UTF-8). */
445 g_io_channel_set_encoding(devc->channels[0], NULL, NULL);
446 g_io_channel_set_encoding(devc->channels[1], NULL, NULL);
448 /* Make channels to unbuffered. */
449 g_io_channel_set_buffered(devc->channels[0], FALSE);
450 g_io_channel_set_buffered(devc->channels[1], FALSE);
452 sr_session_source_add_channel(devc->channels[0], G_IO_IN | G_IO_ERR,
453 40, receive_data, devc);
455 if (!(packet = g_try_malloc(sizeof(struct sr_datafeed_packet)))) {
456 sr_err("%s: packet malloc failed", __func__);
457 return SR_ERR_MALLOC;
460 if (!(header = g_try_malloc(sizeof(struct sr_datafeed_header)))) {
461 sr_err("%s: header malloc failed", __func__);
462 return SR_ERR_MALLOC;
465 packet->type = SR_DF_HEADER;
466 packet->payload = header;
467 header->feed_version = 1;
468 gettimeofday(&header->starttime, NULL);
469 sr_session_send(devc->session_dev_id, packet);
471 /* Send metadata about the SR_DF_LOGIC packets to come. */
472 packet->type = SR_DF_META_LOGIC;
473 packet->payload = &meta;
474 meta.samplerate = cur_samplerate;
475 meta.num_probes = NUM_PROBES;
476 sr_session_send(devc->session_dev_id, packet);
478 /* We use this timestamp to decide how many more samples to send. */
479 devc->starttime = g_get_monotonic_time();
487 static int hw_dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
489 struct dev_context *devc;
490 struct sr_datafeed_packet packet;
496 sr_dbg("Stopping aquisition.");
498 sr_session_source_remove_channel(devc->channels[0]);
499 g_io_channel_shutdown(devc->channels[0], FALSE, NULL);
501 /* Send last packet. */
502 packet.type = SR_DF_END;
503 sr_session_send(devc->session_dev_id, &packet);
508 SR_PRIV struct sr_dev_driver demo_driver_info = {
510 .longname = "Demo driver and pattern generator",
513 .cleanup = hw_cleanup,
515 .dev_list = hw_dev_list,
516 .dev_clear = clear_instances,
517 .dev_open = hw_dev_open,
518 .dev_close = hw_dev_close,
519 .info_get = hw_info_get,
520 .dev_config_set = hw_dev_config_set,
521 .dev_acquisition_start = hw_dev_acquisition_start,
522 .dev_acquisition_stop = hw_dev_acquisition_stop,