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
30 #define pipe(fds) _pipe(fds, 4096, _O_BINARY)
32 #include "libsigrok.h"
33 #include "libsigrok-internal.h"
35 #define LOG_PREFIX "demo"
37 #define DEFAULT_NUM_LOGIC_CHANNELS 8
38 #define DEFAULT_NUM_ANALOG_CHANNELS 4
40 /* The size in bytes of chunks to send through the session bus. */
41 #define LOGIC_BUFSIZE 4096
42 /* Size of the analog pattern space per channel. */
43 #define ANALOG_BUFSIZE 4096
45 #define DEFAULT_ANALOG_AMPLITUDE 25
46 #define ANALOG_SAMPLES_PER_PERIOD 20
48 /* Logic patterns we can generate. */
51 * Spells "sigrok" across 8 channels using '0's (with '1's as
52 * "background") when displayed using the 'bits' output format.
53 * The pattern is repeated every 8 channels, shifted to the right
58 /** Pseudo-random values on all channels. */
62 * Incrementing number across 8 channels. The pattern is repeated
63 * every 8 channels, shifted to the right in time by one bit.
67 /** All channels have a low logic state. */
70 /** All channels have a high logic state. */
74 /* Analog patterns we can generate. */
85 static const char *logic_pattern_str[] = {
93 static const char *analog_pattern_str[] = {
103 float pattern_data[ANALOG_BUFSIZE];
104 unsigned int num_samples;
105 struct sr_datafeed_analog packet;
108 /* Private, per-device-instance driver context. */
112 uint64_t cur_samplerate;
114 uint64_t limit_samples;
116 uint64_t logic_counter;
117 uint64_t analog_counter;
121 int32_t num_logic_channels;
122 unsigned int logic_unitsize;
123 /* There is only ever one logic channel group, so its pattern goes here. */
124 uint8_t logic_pattern;
125 unsigned char logic_data[LOGIC_BUFSIZE];
127 int32_t num_analog_channels;
131 static const uint32_t drvopts[] = {
133 SR_CONF_LOGIC_ANALYZER,
134 SR_CONF_OSCILLOSCOPE,
137 static const uint32_t scanopts[] = {
138 SR_CONF_NUM_LOGIC_CHANNELS,
139 SR_CONF_NUM_ANALOG_CHANNELS,
142 static const uint32_t devopts[] = {
143 SR_CONF_CONTINUOUS | SR_CONF_SET,
144 SR_CONF_LIMIT_SAMPLES | SR_CONF_GET | SR_CONF_SET,
145 SR_CONF_LIMIT_MSEC | SR_CONF_GET | SR_CONF_SET,
146 SR_CONF_SAMPLERATE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
149 static const uint32_t devopts_cg_logic[] = {
150 SR_CONF_PATTERN_MODE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
153 static const uint32_t devopts_cg_analog[] = {
154 SR_CONF_PATTERN_MODE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
155 SR_CONF_AMPLITUDE | SR_CONF_GET | SR_CONF_SET,
158 static const uint64_t samplerates[] = {
164 static uint8_t pattern_sigrok[] = {
165 0x4c, 0x92, 0x92, 0x92, 0x64, 0x00, 0x00, 0x00,
166 0x82, 0xfe, 0xfe, 0x82, 0x00, 0x00, 0x00, 0x00,
167 0x7c, 0x82, 0x82, 0x92, 0x74, 0x00, 0x00, 0x00,
168 0xfe, 0x12, 0x12, 0x32, 0xcc, 0x00, 0x00, 0x00,
169 0x7c, 0x82, 0x82, 0x82, 0x7c, 0x00, 0x00, 0x00,
170 0xfe, 0x10, 0x28, 0x44, 0x82, 0x00, 0x00, 0x00,
171 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
172 0xbe, 0xbe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
175 SR_PRIV struct sr_dev_driver demo_driver_info;
176 static struct sr_dev_driver *di = &demo_driver_info;
178 static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data);
181 static int init(struct sr_context *sr_ctx)
183 return std_init(sr_ctx, di, LOG_PREFIX);
186 static void generate_analog_pattern(struct analog_gen *ag, uint64_t sample_rate)
190 unsigned int num_samples, i;
193 sr_dbg("Generating %s pattern.", analog_pattern_str[ag->pattern]);
195 num_samples = ANALOG_BUFSIZE / sizeof(float);
197 switch (ag->pattern) {
199 value = ag->amplitude;
201 for (i = 0; i < num_samples; i++) {
206 ag->pattern_data[i] = value;
208 ag->num_samples = last_end;
212 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
214 /* Make sure the number of samples we put out is an integer
215 * multiple of our period size */
216 /* FIXME we actually need only one period. A ringbuffer would be
218 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
221 for (i = 0; i < num_samples; i++) {
222 t = (double) i / (double) sample_rate;
223 ag->pattern_data[i] = ag->amplitude *
224 sin(2 * M_PI * frequency * t);
227 ag->num_samples = num_samples;
230 case PATTERN_TRIANGLE:
231 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
233 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
236 for (i = 0; i < num_samples; i++) {
237 t = (double) i / (double) sample_rate;
238 ag->pattern_data[i] = (2 * ag->amplitude / M_PI) *
239 asin(sin(2 * M_PI * frequency * t));
242 ag->num_samples = num_samples;
245 case PATTERN_SAWTOOTH:
246 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
248 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
251 for (i = 0; i < num_samples; i++) {
252 t = (double) i / (double) sample_rate;
253 ag->pattern_data[i] = 2 * ag->amplitude *
254 ((t * frequency) - floor(0.5f + t * frequency));
257 ag->num_samples = num_samples;
262 static GSList *scan(GSList *options)
264 struct drv_context *drvc;
265 struct dev_context *devc;
266 struct sr_dev_inst *sdi;
267 struct sr_channel *ch;
268 struct sr_channel_group *cg, *acg;
269 struct sr_config *src;
270 struct analog_gen *ag;
272 int num_logic_channels, num_analog_channels, pattern, i;
273 char channel_name[16];
277 num_logic_channels = DEFAULT_NUM_LOGIC_CHANNELS;
278 num_analog_channels = DEFAULT_NUM_ANALOG_CHANNELS;
279 for (l = options; l; l = l->next) {
282 case SR_CONF_NUM_LOGIC_CHANNELS:
283 num_logic_channels = g_variant_get_int32(src->data);
285 case SR_CONF_NUM_ANALOG_CHANNELS:
286 num_analog_channels = g_variant_get_int32(src->data);
293 sdi = g_malloc0(sizeof(struct sr_dev_inst));
294 sdi->status = SR_ST_ACTIVE;
295 sdi->model = g_strdup("Demo device");
298 devc = g_malloc(sizeof(struct dev_context));
299 devc->cur_samplerate = SR_KHZ(200);
300 devc->limit_samples = 0;
301 devc->limit_msec = 0;
303 devc->continuous = FALSE;
304 devc->num_logic_channels = num_logic_channels;
305 devc->logic_unitsize = (devc->num_logic_channels + 7) / 8;
306 devc->logic_pattern = PATTERN_SIGROK;
307 devc->num_analog_channels = num_analog_channels;
309 /* Logic channels, all in one channel group. */
310 cg = g_malloc0(sizeof(struct sr_channel_group));
311 cg->name = g_strdup("Logic");
312 for (i = 0; i < num_logic_channels; i++) {
313 sprintf(channel_name, "D%d", i);
314 ch = sr_channel_new(i, SR_CHANNEL_LOGIC, TRUE, channel_name);
315 sdi->channels = g_slist_append(sdi->channels, ch);
316 cg->channels = g_slist_append(cg->channels, ch);
318 sdi->channel_groups = g_slist_append(NULL, cg);
320 /* Analog channels, channel groups and pattern generators. */
322 /* An "Analog" channel group with all analog channels in it. */
323 acg = g_malloc0(sizeof(struct sr_channel_group));
324 acg->name = g_strdup("Analog");
325 sdi->channel_groups = g_slist_append(sdi->channel_groups, acg);
327 devc->ch_ag = g_hash_table_new(g_direct_hash, g_direct_equal);
328 for (i = 0; i < num_analog_channels; i++) {
329 snprintf(channel_name, 16, "A%d", i);
330 ch = sr_channel_new(i + num_logic_channels, SR_CHANNEL_ANALOG,
332 sdi->channels = g_slist_append(sdi->channels, ch);
333 acg->channels = g_slist_append(acg->channels, ch);
335 /* Every analog channel gets its own channel group as well. */
336 cg = g_malloc0(sizeof(struct sr_channel_group));
337 cg->name = g_strdup(channel_name);
338 cg->channels = g_slist_append(NULL, ch);
339 sdi->channel_groups = g_slist_append(sdi->channel_groups, cg);
341 /* Every channel gets a generator struct. */
342 ag = g_malloc(sizeof(struct analog_gen));
343 ag->amplitude = DEFAULT_ANALOG_AMPLITUDE;
344 ag->packet.channels = cg->channels;
346 ag->packet.mqflags = 0;
347 ag->packet.unit = SR_UNIT_VOLT;
348 ag->packet.data = ag->pattern_data;
349 ag->pattern = pattern;
350 g_hash_table_insert(devc->ch_ag, ch, ag);
352 if (++pattern == ARRAY_SIZE(analog_pattern_str))
357 devices = g_slist_append(devices, sdi);
358 drvc->instances = g_slist_append(drvc->instances, sdi);
363 static GSList *dev_list(void)
365 return ((struct drv_context *)(di->priv))->instances;
368 static int dev_open(struct sr_dev_inst *sdi)
370 sdi->status = SR_ST_ACTIVE;
375 static int dev_close(struct sr_dev_inst *sdi)
377 sdi->status = SR_ST_INACTIVE;
382 static void clear_helper(void *priv)
384 struct dev_context *devc;
390 /* Analog generators. */
391 g_hash_table_iter_init(&iter, devc->ch_ag);
392 while (g_hash_table_iter_next(&iter, NULL, &value))
394 g_hash_table_unref(devc->ch_ag);
398 static int cleanup(void)
400 return std_dev_clear(di, clear_helper);
403 static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
404 const struct sr_channel_group *cg)
406 struct dev_context *devc;
407 struct sr_channel *ch;
408 struct analog_gen *ag;
416 case SR_CONF_SAMPLERATE:
417 *data = g_variant_new_uint64(devc->cur_samplerate);
419 case SR_CONF_LIMIT_SAMPLES:
420 *data = g_variant_new_uint64(devc->limit_samples);
422 case SR_CONF_LIMIT_MSEC:
423 *data = g_variant_new_uint64(devc->limit_msec);
425 case SR_CONF_PATTERN_MODE:
427 return SR_ERR_CHANNEL_GROUP;
428 /* Any channel in the group will do. */
429 ch = cg->channels->data;
430 if (ch->type == SR_CHANNEL_LOGIC) {
431 pattern = devc->logic_pattern;
432 *data = g_variant_new_string(logic_pattern_str[pattern]);
433 } else if (ch->type == SR_CHANNEL_ANALOG) {
434 ag = g_hash_table_lookup(devc->ch_ag, ch);
435 pattern = ag->pattern;
436 *data = g_variant_new_string(analog_pattern_str[pattern]);
440 case SR_CONF_AMPLITUDE:
442 return SR_ERR_CHANNEL_GROUP;
443 /* Any channel in the group will do. */
444 ch = cg->channels->data;
445 if (ch->type != SR_CHANNEL_ANALOG)
447 ag = g_hash_table_lookup(devc->ch_ag, ch);
448 *data = g_variant_new_double(ag->amplitude);
457 static int config_set(uint32_t key, GVariant *data, const struct sr_dev_inst *sdi,
458 const struct sr_channel_group *cg)
460 struct dev_context *devc;
461 struct analog_gen *ag;
462 struct sr_channel *ch;
464 int logic_pattern, analog_pattern, ret;
470 if (sdi->status != SR_ST_ACTIVE)
471 return SR_ERR_DEV_CLOSED;
475 case SR_CONF_SAMPLERATE:
476 devc->cur_samplerate = g_variant_get_uint64(data);
477 sr_dbg("Setting samplerate to %" PRIu64, devc->cur_samplerate);
479 case SR_CONF_LIMIT_SAMPLES:
480 devc->limit_msec = 0;
481 devc->limit_samples = g_variant_get_uint64(data);
482 sr_dbg("Setting sample limit to %" PRIu64, devc->limit_samples);
484 case SR_CONF_LIMIT_MSEC:
485 devc->limit_msec = g_variant_get_uint64(data);
486 devc->limit_samples = 0;
487 sr_dbg("Setting time limit to %" PRIu64"ms", devc->limit_msec);
489 case SR_CONF_PATTERN_MODE:
491 return SR_ERR_CHANNEL_GROUP;
492 stropt = g_variant_get_string(data, NULL);
493 logic_pattern = analog_pattern = -1;
494 for (i = 0; i < ARRAY_SIZE(logic_pattern_str); i++) {
495 if (!strcmp(stropt, logic_pattern_str[i])) {
500 for (i = 0; i < ARRAY_SIZE(analog_pattern_str); i++) {
501 if (!strcmp(stropt, analog_pattern_str[i])) {
506 if (logic_pattern == -1 && analog_pattern == -1)
508 for (l = cg->channels; l; l = l->next) {
510 if (ch->type == SR_CHANNEL_LOGIC) {
511 if (logic_pattern == -1)
513 sr_dbg("Setting logic pattern to %s",
514 logic_pattern_str[logic_pattern]);
515 devc->logic_pattern = logic_pattern;
516 /* Might as well do this now, these are static. */
517 if (logic_pattern == PATTERN_ALL_LOW)
518 memset(devc->logic_data, 0x00, LOGIC_BUFSIZE);
519 else if (logic_pattern == PATTERN_ALL_HIGH)
520 memset(devc->logic_data, 0xff, LOGIC_BUFSIZE);
521 } else if (ch->type == SR_CHANNEL_ANALOG) {
522 if (analog_pattern == -1)
524 sr_dbg("Setting analog pattern for channel %s to %s",
525 ch->name, analog_pattern_str[analog_pattern]);
526 ag = g_hash_table_lookup(devc->ch_ag, ch);
527 ag->pattern = analog_pattern;
532 case SR_CONF_AMPLITUDE:
534 return SR_ERR_CHANNEL_GROUP;
535 for (l = cg->channels; l; l = l->next) {
537 if (ch->type != SR_CHANNEL_ANALOG)
539 ag = g_hash_table_lookup(devc->ch_ag, ch);
540 ag->amplitude = g_variant_get_double(data);
550 static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
551 const struct sr_channel_group *cg)
553 struct sr_channel *ch;
559 if (key == SR_CONF_SCAN_OPTIONS) {
560 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
561 scanopts, ARRAY_SIZE(scanopts), sizeof(uint32_t));
565 if (key == SR_CONF_DEVICE_OPTIONS && !sdi) {
566 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
567 drvopts, ARRAY_SIZE(drvopts), sizeof(uint32_t));
576 case SR_CONF_DEVICE_OPTIONS:
577 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
578 devopts, ARRAY_SIZE(devopts), sizeof(uint32_t));
580 case SR_CONF_SAMPLERATE:
581 g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
582 gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates,
583 ARRAY_SIZE(samplerates), sizeof(uint64_t));
584 g_variant_builder_add(&gvb, "{sv}", "samplerate-steps", gvar);
585 *data = g_variant_builder_end(&gvb);
591 /* Any channel in the group will do. */
592 ch = cg->channels->data;
594 case SR_CONF_DEVICE_OPTIONS:
595 if (ch->type == SR_CHANNEL_LOGIC)
596 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
597 devopts_cg_logic, ARRAY_SIZE(devopts_cg_logic),
599 else if (ch->type == SR_CHANNEL_ANALOG)
600 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
601 devopts_cg_analog, ARRAY_SIZE(devopts_cg_analog),
606 case SR_CONF_PATTERN_MODE:
607 if (ch->type == SR_CHANNEL_LOGIC)
608 *data = g_variant_new_strv(logic_pattern_str,
609 ARRAY_SIZE(logic_pattern_str));
610 else if (ch->type == SR_CHANNEL_ANALOG)
611 *data = g_variant_new_strv(analog_pattern_str,
612 ARRAY_SIZE(analog_pattern_str));
624 static void logic_generator(struct sr_dev_inst *sdi, uint64_t size)
626 struct dev_context *devc;
632 switch (devc->logic_pattern) {
634 memset(devc->logic_data, 0x00, size);
635 for (i = 0; i < size; i += devc->logic_unitsize) {
636 for (j = 0; j < devc->logic_unitsize; j++) {
637 pat = pattern_sigrok[(devc->step + j) % sizeof(pattern_sigrok)] >> 1;
638 devc->logic_data[i + j] = ~pat;
644 for (i = 0; i < size; i++)
645 devc->logic_data[i] = (uint8_t)(rand() & 0xff);
648 for (i = 0; i < size; i++) {
649 for (j = 0; j < devc->logic_unitsize; j++) {
650 devc->logic_data[i + j] = devc->step;
655 case PATTERN_ALL_LOW:
656 case PATTERN_ALL_HIGH:
657 /* These were set when the pattern mode was selected. */
660 sr_err("Unknown pattern: %d.", devc->logic_pattern);
665 /* Callback handling data */
666 static int prepare_data(int fd, int revents, void *cb_data)
668 struct sr_dev_inst *sdi;
669 struct dev_context *devc;
670 struct sr_datafeed_packet packet;
671 struct sr_datafeed_logic logic;
672 struct analog_gen *ag;
676 uint64_t logic_todo, analog_todo, expected_samplenum, analog_sent, sending_now;
677 int64_t time, elapsed;
684 logic_todo = analog_todo = 0;
686 /* How many samples should we have sent by now? */
687 time = g_get_monotonic_time();
688 elapsed = time - devc->starttime;
689 expected_samplenum = elapsed * devc->cur_samplerate / 1000000;
691 /* But never more than the limit, if there is one. */
692 if (!devc->continuous)
693 expected_samplenum = MIN(expected_samplenum, devc->limit_samples);
695 /* Of those, how many do we still have to send? */
696 if (devc->num_logic_channels)
697 logic_todo = expected_samplenum - devc->logic_counter;
698 if (devc->num_analog_channels)
699 analog_todo = expected_samplenum - devc->analog_counter;
701 while (logic_todo || analog_todo) {
703 if (logic_todo > 0) {
704 sending_now = MIN(logic_todo, LOGIC_BUFSIZE / devc->logic_unitsize);
705 logic_generator(sdi, sending_now * devc->logic_unitsize);
706 packet.type = SR_DF_LOGIC;
707 packet.payload = &logic;
708 logic.length = sending_now * devc->logic_unitsize;
709 logic.unitsize = devc->logic_unitsize;
710 logic.data = devc->logic_data;
711 sr_session_send(sdi, &packet);
712 logic_todo -= sending_now;
713 devc->logic_counter += sending_now;
716 /* Analog, one channel at a time */
717 if (analog_todo > 0) {
720 g_hash_table_iter_init(&iter, devc->ch_ag);
721 while (g_hash_table_iter_next(&iter, NULL, &value)) {
723 packet.type = SR_DF_ANALOG;
724 packet.payload = &ag->packet;
725 ag_pattern_pos = devc->analog_counter % ag->num_samples;
726 sending_now = MIN(analog_todo, ag->num_samples-ag_pattern_pos);
727 ag->packet.data = ag->pattern_data + ag_pattern_pos;
728 ag->packet.num_samples = sending_now;
729 sr_session_send(sdi, &packet);
731 /* Whichever channel group gets there first. */
732 analog_sent = MAX(analog_sent, sending_now);
734 analog_todo -= analog_sent;
735 devc->analog_counter += analog_sent;
739 if (!devc->continuous
740 && (!devc->num_logic_channels || devc->logic_counter >= devc->limit_samples)
741 && (!devc->num_analog_channels || devc->analog_counter >= devc->limit_samples)) {
742 sr_dbg("Requested number of samples reached.");
743 dev_acquisition_stop(sdi, cb_data);
750 static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
752 struct dev_context *devc;
758 if (sdi->status != SR_ST_ACTIVE)
759 return SR_ERR_DEV_CLOSED;
762 devc->continuous = !devc->limit_samples;
763 devc->logic_counter = devc->analog_counter = 0;
766 * Setting two channels connected by a pipe is a remnant from when the
767 * demo driver generated data in a thread, and collected and sent the
768 * data in the main program loop.
769 * They are kept here because it provides a convenient way of setting
770 * up a timeout-based polling mechanism.
772 if (pipe(devc->pipe_fds)) {
773 sr_err("%s: pipe() failed", __func__);
777 g_hash_table_iter_init(&iter, devc->ch_ag);
778 while (g_hash_table_iter_next(&iter, NULL, &value))
779 generate_analog_pattern(value, devc->cur_samplerate);
781 devc->channel = g_io_channel_unix_new(devc->pipe_fds[0]);
782 g_io_channel_set_flags(devc->channel, G_IO_FLAG_NONBLOCK, NULL);
784 /* Set channel encoding to binary (default is UTF-8). */
785 g_io_channel_set_encoding(devc->channel, NULL, NULL);
787 /* Make channels unbuffered. */
788 g_io_channel_set_buffered(devc->channel, FALSE);
790 sr_session_source_add_channel(sdi->session, devc->channel,
791 G_IO_IN | G_IO_ERR, 40, prepare_data, (void *)sdi);
793 /* Send header packet to the session bus. */
794 std_session_send_df_header(sdi, LOG_PREFIX);
796 /* We use this timestamp to decide how many more samples to send. */
797 devc->starttime = g_get_monotonic_time();
802 static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
804 struct dev_context *devc;
805 struct sr_datafeed_packet packet;
810 sr_dbg("Stopping acquisition.");
812 sr_session_source_remove_channel(sdi->session, devc->channel);
813 g_io_channel_shutdown(devc->channel, FALSE, NULL);
814 g_io_channel_unref(devc->channel);
815 devc->channel = NULL;
817 /* Send last packet. */
818 packet.type = SR_DF_END;
819 sr_session_send(sdi, &packet);
824 SR_PRIV struct sr_dev_driver demo_driver_info = {
826 .longname = "Demo driver and pattern generator",
831 .dev_list = dev_list,
833 .config_get = config_get,
834 .config_set = config_set,
835 .config_list = config_list,
836 .dev_open = dev_open,
837 .dev_close = dev_close,
838 .dev_acquisition_start = dev_acquisition_start,
839 .dev_acquisition_stop = dev_acquisition_stop,