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>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
28 #define pipe(fds) _pipe(fds, 4096, _O_BINARY)
30 #include "libsigrok.h"
31 #include "libsigrok-internal.h"
33 /* Message logging helpers with driver-specific prefix string. */
34 #define DRIVER_LOG_DOMAIN "demo: "
35 #define sr_log(l, s, args...) sr_log(l, DRIVER_LOG_DOMAIN s, ## args)
36 #define sr_spew(s, args...) sr_spew(DRIVER_LOG_DOMAIN s, ## args)
37 #define sr_dbg(s, args...) sr_dbg(DRIVER_LOG_DOMAIN s, ## args)
38 #define sr_info(s, args...) sr_info(DRIVER_LOG_DOMAIN s, ## args)
39 #define sr_warn(s, args...) sr_warn(DRIVER_LOG_DOMAIN s, ## args)
40 #define sr_err(s, args...) sr_err(DRIVER_LOG_DOMAIN s, ## args)
42 /* TODO: Number of probes should be configurable. */
45 #define DEMONAME "Demo device"
47 /* The size of chunks to send through the session bus. */
48 /* TODO: Should be configurable. */
51 /* Supported patterns which we can generate */
54 * Pattern which spells "sigrok" using '0's (with '1's as "background")
55 * when displayed using the 'bits' output format.
59 /** Pattern which consists of (pseudo-)random values on all probes. */
63 * Pattern which consists of incrementing numbers.
64 * TODO: Better description.
68 /** Pattern where all probes have a low logic state. */
71 /** Pattern where all probes have a high logic state. */
75 /* Private, per-device-instance driver context. */
78 GIOChannel *channels[2];
79 uint8_t sample_generator;
80 uint8_t thread_running;
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 *ddi = &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;
146 static GThread *my_thread;
147 static int thread_running;
149 static int hw_dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data);
151 static int hw_init(void)
153 struct drv_context *drvc;
155 if (!(drvc = g_try_malloc0(sizeof(struct drv_context)))) {
156 sr_err("Driver context malloc failed.");
157 return SR_ERR_MALLOC;
164 static GSList *hw_scan(GSList *options)
166 struct sr_dev_inst *sdi;
167 struct sr_probe *probe;
168 struct drv_context *drvc;
176 sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, DEMONAME, NULL, NULL);
178 sr_err("%s: sr_dev_inst_new failed", __func__);
183 for (i = 0; probe_names[i]; i++) {
184 if (!(probe = sr_probe_new(i, SR_PROBE_ANALOG, TRUE,
187 sdi->probes = g_slist_append(sdi->probes, probe);
190 devices = g_slist_append(devices, sdi);
191 drvc->instances = g_slist_append(drvc->instances, sdi);
196 static GSList *hw_dev_list(void)
198 struct drv_context *drvc;
202 return drvc->instances;
205 static int hw_dev_open(struct sr_dev_inst *sdi)
207 /* Avoid compiler warnings. */
210 /* Nothing needed so far. */
215 static int hw_dev_close(struct sr_dev_inst *sdi)
217 /* Avoid compiler warnings. */
220 /* Nothing needed so far. */
225 static int hw_cleanup(void)
227 /* Nothing needed so far. */
231 static int hw_info_get(int info_id, const void **data,
232 const struct sr_dev_inst *sdi)
241 case SR_DI_NUM_PROBES:
242 *data = GINT_TO_POINTER(NUM_PROBES);
244 case SR_DI_PROBE_NAMES:
247 case SR_DI_SAMPLERATES:
248 *data = &samplerates;
250 case SR_DI_CUR_SAMPLERATE:
251 *data = &cur_samplerate;
254 *data = &pattern_strings;
263 static int hw_dev_config_set(const struct sr_dev_inst *sdi, int hwcap,
271 if (hwcap == SR_HWCAP_SAMPLERATE) {
272 cur_samplerate = *(const uint64_t *)value;
273 sr_dbg("%s: setting samplerate to %" PRIu64, __func__,
276 } else if (hwcap == SR_HWCAP_LIMIT_SAMPLES) {
278 limit_samples = *(const uint64_t *)value;
279 sr_dbg("%s: setting limit_samples to %" PRIu64, __func__,
282 } else if (hwcap == SR_HWCAP_LIMIT_MSEC) {
283 limit_msec = *(const uint64_t *)value;
285 sr_dbg("%s: setting limit_msec to %" PRIu64, __func__,
288 } else if (hwcap == SR_HWCAP_PATTERN_MODE) {
291 if (!strcmp(stropt, "sigrok")) {
292 default_pattern = PATTERN_SIGROK;
293 } else if (!strcmp(stropt, "random")) {
294 default_pattern = PATTERN_RANDOM;
295 } else if (!strcmp(stropt, "incremental")) {
296 default_pattern = PATTERN_INC;
297 } else if (!strcmp(stropt, "all-low")) {
298 default_pattern = PATTERN_ALL_LOW;
299 } else if (!strcmp(stropt, "all-high")) {
300 default_pattern = PATTERN_ALL_HIGH;
304 sr_dbg("%s: setting pattern to %d", __func__, default_pattern);
312 static void samples_generator(uint8_t *buf, uint64_t size, void *data)
314 static uint64_t p = 0;
315 struct dev_context *devc = data;
319 memset(buf, 0, size);
321 switch (devc->sample_generator) {
322 case PATTERN_SIGROK: /* sigrok pattern */
323 for (i = 0; i < size; i++) {
324 *(buf + i) = ~(pattern_sigrok[p] >> 1);
329 case PATTERN_RANDOM: /* Random */
330 for (i = 0; i < size; i++)
331 *(buf + i) = (uint8_t)(rand() & 0xff);
333 case PATTERN_INC: /* Simple increment */
334 for (i = 0; i < size; i++)
337 case PATTERN_ALL_LOW: /* All probes are low */
338 memset(buf, 0x00, size);
340 case PATTERN_ALL_HIGH: /* All probes are high */
341 memset(buf, 0xff, size);
344 sr_err("Unknown pattern: %d.", devc->sample_generator);
349 /* Thread function */
350 static void thread_func(void *data)
352 struct dev_context *devc = data;
353 uint8_t buf[BUFSIZE];
354 uint64_t nb_to_send = 0;
356 double time_cur, time_last, time_diff;
358 time_last = g_timer_elapsed(devc->timer, NULL);
360 while (thread_running) {
362 time_cur = g_timer_elapsed(devc->timer, NULL);
364 time_diff = time_cur - time_last;
365 time_last = time_cur;
367 nb_to_send = cur_samplerate * time_diff;
370 nb_to_send = MIN(nb_to_send,
371 limit_samples - devc->samples_counter);
374 /* Make sure we don't overflow. */
375 nb_to_send = MIN(nb_to_send, BUFSIZE);
378 samples_generator(buf, nb_to_send, data);
379 devc->samples_counter += nb_to_send;
381 g_io_channel_write_chars(devc->channels[1], (gchar *)&buf,
382 nb_to_send, (gsize *)&bytes_written, NULL);
385 /* Check if we're done. */
386 if ((limit_msec && time_cur * 1000 > limit_msec) ||
387 (limit_samples && devc->samples_counter >= limit_samples))
389 close(devc->pipe_fds[1]);
397 /* Callback handling data */
398 static int receive_data(int fd, int revents, void *cb_data)
400 struct dev_context *devc = cb_data;
401 struct sr_datafeed_packet packet;
402 struct sr_datafeed_logic logic;
403 static uint64_t samples_received = 0;
404 unsigned char c[BUFSIZE];
407 /* Avoid compiler warnings. */
412 g_io_channel_read_chars(devc->channels[0],
413 (gchar *)&c, BUFSIZE, &z, NULL);
416 packet.type = SR_DF_LOGIC;
417 packet.payload = &logic;
421 sr_session_send(devc->session_dev_id, &packet);
422 samples_received += z;
426 if (!thread_running && z <= 0) {
427 /* Make sure we don't receive more packets. */
428 g_io_channel_shutdown(devc->channels[0], FALSE, NULL);
430 /* Send last packet. */
431 packet.type = SR_DF_END;
432 sr_session_send(devc->session_dev_id, &packet);
440 static int hw_dev_acquisition_start(const struct sr_dev_inst *sdi,
443 struct sr_datafeed_packet *packet;
444 struct sr_datafeed_header *header;
445 struct sr_datafeed_meta_logic meta;
446 struct dev_context *devc;
450 /* TODO: 'devc' is never g_free()'d? */
451 if (!(devc = g_try_malloc(sizeof(struct dev_context)))) {
452 sr_err("%s: devc malloc failed", __func__);
453 return SR_ERR_MALLOC;
456 devc->sample_generator = default_pattern;
457 devc->session_dev_id = cb_data;
458 devc->samples_counter = 0;
460 if (pipe(devc->pipe_fds)) {
461 /* TODO: Better error message. */
462 sr_err("%s: pipe() failed", __func__);
466 devc->channels[0] = g_io_channel_unix_new(devc->pipe_fds[0]);
467 devc->channels[1] = g_io_channel_unix_new(devc->pipe_fds[1]);
469 g_io_channel_set_flags(devc->channels[0], G_IO_FLAG_NONBLOCK, NULL);
471 /* Set channel encoding to binary (default is UTF-8). */
472 g_io_channel_set_encoding(devc->channels[0], NULL, NULL);
473 g_io_channel_set_encoding(devc->channels[1], NULL, NULL);
475 /* Make channels to unbuffered. */
476 g_io_channel_set_buffered(devc->channels[0], FALSE);
477 g_io_channel_set_buffered(devc->channels[1], FALSE);
479 sr_session_source_add_channel(devc->channels[0], G_IO_IN | G_IO_ERR,
480 40, receive_data, devc);
482 /* Run the demo thread. */
483 devc->timer = g_timer_new();
485 my_thread = g_thread_try_new("sigrok demo generator",
486 (GThreadFunc)thread_func, devc, NULL);
488 sr_err("%s: g_thread_try_new failed", __func__);
489 return SR_ERR; /* TODO */
492 if (!(packet = g_try_malloc(sizeof(struct sr_datafeed_packet)))) {
493 sr_err("%s: packet malloc failed", __func__);
494 return SR_ERR_MALLOC;
497 if (!(header = g_try_malloc(sizeof(struct sr_datafeed_header)))) {
498 sr_err("%s: header malloc failed", __func__);
499 return SR_ERR_MALLOC;
502 packet->type = SR_DF_HEADER;
503 packet->payload = header;
504 header->feed_version = 1;
505 gettimeofday(&header->starttime, NULL);
506 sr_session_send(devc->session_dev_id, packet);
508 /* Send metadata about the SR_DF_LOGIC packets to come. */
509 packet->type = SR_DF_META_LOGIC;
510 packet->payload = &meta;
511 meta.samplerate = cur_samplerate;
512 meta.num_probes = NUM_PROBES;
513 sr_session_send(devc->session_dev_id, packet);
521 static int hw_dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
523 struct dev_context *devc;
525 /* Avoid compiler warnings. */
530 /* Stop generate thread. */
533 sr_session_source_remove_channel(devc->channels[0]);
538 SR_PRIV struct sr_dev_driver demo_driver_info = {
540 .longname = "Demo driver and pattern generator",
543 .cleanup = hw_cleanup,
545 .dev_list = hw_dev_list,
546 .dev_open = hw_dev_open,
547 .dev_close = hw_dev_close,
548 .info_get = hw_info_get,
549 .dev_config_set = hw_dev_config_set,
550 .dev_acquisition_start = hw_dev_acquisition_start,
551 .dev_acquisition_stop = hw_dev_acquisition_stop,