hardware/demo/demo.c

   1 /*
   2  * This file is part of the sigrok project.
   3  *
   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>
   7  *
   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.
  12  *
  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.
  17  *
  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
  21  */
  22
  23 #include <stdlib.h>
  24 #include <unistd.h>
  25 #include <string.h>
  26 #ifdef _WIN32
  27 #include <io.h>
  28 #include <fcntl.h>
  29 #define pipe(fds) _pipe(fds, 4096, _O_BINARY)
  30 #endif
  31 #include "libsigrok.h"
  32 #include "libsigrok-internal.h"
  33
  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)
  42
  43 /* TODO: Number of probes should be configurable. */
  44 #define NUM_PROBES             8
  45
  46 #define DEMONAME               "Demo device"
  47
  48 /* The size of chunks to send through the session bus. */
  49 /* TODO: Should be configurable. */
  50 #define BUFSIZE                4096
  51
  52 /* Supported patterns which we can generate */
  53 enum {
  54         /**
  55          * Pattern which spells "sigrok" using '0's (with '1's as "background")
  56          * when displayed using the 'bits' output format.
  57          */
  58         PATTERN_SIGROK,
  59
  60         /** Pattern which consists of (pseudo-)random values on all probes. */
  61         PATTERN_RANDOM,
  62
  63         /**
  64          * Pattern which consists of incrementing numbers.
  65          * TODO: Better description.
  66          */
  67         PATTERN_INC,
  68
  69         /** Pattern where all probes have a low logic state. */
  70         PATTERN_ALL_LOW,
  71
  72         /** Pattern where all probes have a high logic state. */
  73         PATTERN_ALL_HIGH,
  74 };
  75
  76 /* Private, per-device-instance driver context. */
  77 struct dev_context {
  78         int pipe_fds[2];
  79         GIOChannel *channels[2];
  80         uint8_t sample_generator;
  81         uint64_t samples_counter;
  82         void *session_dev_id;
  83         int64_t starttime;
  84 };
  85
  86 static const int hwcaps[] = {
  87         SR_CONF_LOGIC_ANALYZER,
  88         SR_CONF_DEMO_DEV,
  89         SR_CONF_SAMPLERATE,
  90         SR_CONF_PATTERN_MODE,
  91         SR_CONF_LIMIT_SAMPLES,
  92         SR_CONF_LIMIT_MSEC,
  93         SR_CONF_CONTINUOUS,
  94 };
  95
  96 static const struct sr_samplerates samplerates = {
  97         SR_HZ(1),
  98         SR_GHZ(1),
  99         SR_HZ(1),
 100         NULL,
 101 };
 102
 103 static const char *pattern_strings[] = {
 104         "sigrok",
 105         "random",
 106         "incremental",
 107         "all-low",
 108         "all-high",
 109         NULL,
 110 };
 111
 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",
 115         NULL,
 116 };
 117
 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,
 127 };
 128
 129 /* Private, per-device-instance driver context. */
 130 /* TODO: struct context as with the other drivers. */
 131
 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;
 139
 140 static int hw_dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data);
 141
 142 static int clear_instances(void)
 143 {
 144         /* Nothing needed so far. */
 145
 146         return SR_OK;
 147 }
 148
 149 static int hw_init(struct sr_context *sr_ctx)
 150 {
 151         struct drv_context *drvc;
 152
 153         if (!(drvc = g_try_malloc0(sizeof(struct drv_context)))) {
 154                 sr_err("Driver context malloc failed.");
 155                 return SR_ERR_MALLOC;
 156         }
 157         drvc->sr_ctx = sr_ctx;
 158         di->priv = drvc;
 159
 160         return SR_OK;
 161 }
 162
 163 static GSList *hw_scan(GSList *options)
 164 {
 165         struct sr_dev_inst *sdi;
 166         struct sr_probe *probe;
 167         struct drv_context *drvc;
 168         GSList *devices;
 169         int i;
 170
 171         (void)options;
 172
 173         drvc = di->priv;
 174         devices = NULL;
 175
 176         sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, DEMONAME, NULL, NULL);
 177         if (!sdi) {
 178                 sr_err("%s: sr_dev_inst_new failed", __func__);
 179                 return 0;
 180         }
 181         sdi->driver = di;
 182
 183         for (i = 0; probe_names[i]; i++) {
 184                 if (!(probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE,
 185                                 probe_names[i])))
 186                         return NULL;
 187                 sdi->probes = g_slist_append(sdi->probes, probe);
 188         }
 189
 190         devices = g_slist_append(devices, sdi);
 191         drvc->instances = g_slist_append(drvc->instances, sdi);
 192
 193         return devices;
 194 }
 195
 196 static GSList *hw_dev_list(void)
 197 {
 198         struct drv_context *drvc;
 199
 200         drvc = di->priv;
 201
 202         return drvc->instances;
 203 }
 204
 205 static int hw_dev_open(struct sr_dev_inst *sdi)
 206 {
 207         (void)sdi;
 208
 209         /* Nothing needed so far. */
 210
 211         return SR_OK;
 212 }
 213
 214 static int hw_dev_close(struct sr_dev_inst *sdi)
 215 {
 216         (void)sdi;
 217
 218         /* Nothing needed so far. */
 219
 220         return SR_OK;
 221 }
 222
 223 static int hw_cleanup(void)
 224 {
 225         /* Nothing needed so far. */
 226         return SR_OK;
 227 }
 228
 229 static int config_get(int id, const void **data, const struct sr_dev_inst *sdi)
 230 {
 231         (void)sdi;
 232
 233         switch (id) {
 234         case SR_DI_HWCAPS:
 235                 *data = hwcaps;
 236                 break;
 237         case SR_DI_SAMPLERATES:
 238                 *data = &samplerates;
 239                 break;
 240         case SR_DI_CUR_SAMPLERATE:
 241                 *data = &cur_samplerate;
 242                 break;
 243         case SR_DI_PATTERNS:
 244                 *data = &pattern_strings;
 245                 break;
 246         default:
 247                 return SR_ERR_ARG;
 248         }
 249
 250         return SR_OK;
 251 }
 252
 253 static int config_set(int id, const void *value, const struct sr_dev_inst *sdi)
 254 {
 255         int ret;
 256         const char *stropt;
 257
 258         (void)sdi;
 259
 260         if (id == SR_CONF_SAMPLERATE) {
 261                 cur_samplerate = *(const uint64_t *)value;
 262                 sr_dbg("%s: setting samplerate to %" PRIu64, __func__,
 263                        cur_samplerate);
 264                 ret = SR_OK;
 265         } else if (id == SR_CONF_LIMIT_SAMPLES) {
 266                 limit_msec = 0;
 267                 limit_samples = *(const uint64_t *)value;
 268                 sr_dbg("%s: setting limit_samples to %" PRIu64, __func__,
 269                        limit_samples);
 270                 ret = SR_OK;
 271         } else if (id == SR_CONF_LIMIT_MSEC) {
 272                 limit_msec = *(const uint64_t *)value;
 273                 limit_samples = 0;
 274                 sr_dbg("%s: setting limit_msec to %" PRIu64, __func__,
 275                        limit_msec);
 276                 ret = SR_OK;
 277         } else if (id == SR_CONF_PATTERN_MODE) {
 278                 stropt = value;
 279                 ret = SR_OK;
 280                 if (!strcmp(stropt, "sigrok")) {
 281                         default_pattern = PATTERN_SIGROK;
 282                 } else if (!strcmp(stropt, "random")) {
 283                         default_pattern = PATTERN_RANDOM;
 284                 } else if (!strcmp(stropt, "incremental")) {
 285                         default_pattern = PATTERN_INC;
 286                 } else if (!strcmp(stropt, "all-low")) {
 287                         default_pattern = PATTERN_ALL_LOW;
 288                 } else if (!strcmp(stropt, "all-high")) {
 289                         default_pattern = PATTERN_ALL_HIGH;
 290                 } else {
 291                         ret = SR_ERR;
 292                 }
 293                 sr_dbg("%s: setting pattern to %d", __func__, default_pattern);
 294         } else {
 295                 ret = SR_ERR;
 296         }
 297
 298         return ret;
 299 }
 300
 301 static void samples_generator(uint8_t *buf, uint64_t size,
 302                               struct dev_context *devc)
 303 {
 304         static uint64_t p = 0;
 305         uint64_t i;
 306
 307         /* TODO: Needed? */
 308         memset(buf, 0, size);
 309
 310         switch (devc->sample_generator) {
 311         case PATTERN_SIGROK: /* sigrok pattern */
 312                 for (i = 0; i < size; i++) {
 313                         *(buf + i) = ~(pattern_sigrok[p] >> 1);
 314                         if (++p == 64)
 315                                 p = 0;
 316                 }
 317                 break;
 318         case PATTERN_RANDOM: /* Random */
 319                 for (i = 0; i < size; i++)
 320                         *(buf + i) = (uint8_t)(rand() & 0xff);
 321                 break;
 322         case PATTERN_INC: /* Simple increment */
 323                 for (i = 0; i < size; i++)
 324                         *(buf + i) = i;
 325                 break;
 326         case PATTERN_ALL_LOW: /* All probes are low */
 327                 memset(buf, 0x00, size);
 328                 break;
 329         case PATTERN_ALL_HIGH: /* All probes are high */
 330                 memset(buf, 0xff, size);
 331                 break;
 332         default:
 333                 sr_err("Unknown pattern: %d.", devc->sample_generator);
 334                 break;
 335         }
 336 }
 337
 338 /* Callback handling data */
 339 static int receive_data(int fd, int revents, void *cb_data)
 340 {
 341         struct dev_context *devc = cb_data;
 342         struct sr_datafeed_packet packet;
 343         struct sr_datafeed_logic logic;
 344         uint8_t buf[BUFSIZE];
 345         static uint64_t samples_to_send, expected_samplenum, sending_now;
 346         int64_t time, elapsed;
 347
 348         (void)fd;
 349         (void)revents;
 350
 351         /* How many "virtual" samples should we have collected by now? */
 352         time = g_get_monotonic_time();
 353         elapsed = time - devc->starttime;
 354         expected_samplenum = elapsed * cur_samplerate / 1000000;
 355         /* Of those, how many do we still have to send? */
 356         samples_to_send = expected_samplenum - devc->samples_counter;
 357
 358         if (limit_samples) {
 359                 samples_to_send = MIN(samples_to_send,
 360                                  limit_samples - devc->samples_counter);
 361         }
 362
 363         while (samples_to_send > 0) {
 364                 sending_now = MIN(samples_to_send, sizeof(buf));
 365                 samples_to_send -= sending_now;
 366                 samples_generator(buf, sending_now, devc);
 367
 368                 packet.type = SR_DF_LOGIC;
 369                 packet.payload = &logic;
 370                 logic.length = sending_now;
 371                 logic.unitsize = 1;
 372                 logic.data = buf;
 373                 sr_session_send(devc->session_dev_id, &packet);
 374                 devc->samples_counter += sending_now;
 375         }
 376
 377         if (limit_samples && devc->samples_counter >= limit_samples) {
 378                 sr_info("Requested number of samples reached.");
 379                 hw_dev_acquisition_stop(NULL, cb_data);
 380                 return TRUE;
 381         }
 382
 383         return TRUE;
 384 }
 385
 386 static int hw_dev_acquisition_start(const struct sr_dev_inst *sdi,
 387                 void *cb_data)
 388 {
 389         struct sr_datafeed_packet *packet;
 390         struct sr_datafeed_header *header;
 391         struct dev_context *devc;
 392
 393         (void)sdi;
 394
 395         sr_dbg("Starting acquisition.");
 396
 397         /* TODO: 'devc' is never g_free()'d? */
 398         if (!(devc = g_try_malloc(sizeof(struct dev_context)))) {
 399                 sr_err("%s: devc malloc failed", __func__);
 400                 return SR_ERR_MALLOC;
 401         }
 402
 403         devc->sample_generator = default_pattern;
 404         devc->session_dev_id = cb_data;
 405         devc->samples_counter = 0;
 406
 407         /*
 408          * Setting two channels connected by a pipe is a remnant from when the
 409          * demo driver generated data in a thread, and collected and sent the
 410          * data in the main program loop.
 411          * They are kept here because it provides a convenient way of setting
 412          * up a timeout-based polling mechanism.
 413          */
 414         if (pipe(devc->pipe_fds)) {
 415                 /* TODO: Better error message. */
 416                 sr_err("%s: pipe() failed", __func__);
 417                 return SR_ERR;
 418         }
 419
 420         devc->channels[0] = g_io_channel_unix_new(devc->pipe_fds[0]);
 421         devc->channels[1] = g_io_channel_unix_new(devc->pipe_fds[1]);
 422
 423         g_io_channel_set_flags(devc->channels[0], G_IO_FLAG_NONBLOCK, NULL);
 424
 425         /* Set channel encoding to binary (default is UTF-8). */
 426         g_io_channel_set_encoding(devc->channels[0], NULL, NULL);
 427         g_io_channel_set_encoding(devc->channels[1], NULL, NULL);
 428
 429         /* Make channels to unbuffered. */
 430         g_io_channel_set_buffered(devc->channels[0], FALSE);
 431         g_io_channel_set_buffered(devc->channels[1], FALSE);
 432
 433         sr_session_source_add_channel(devc->channels[0], G_IO_IN | G_IO_ERR,
 434                     40, receive_data, devc);
 435
 436         if (!(packet = g_try_malloc(sizeof(struct sr_datafeed_packet)))) {
 437                 sr_err("%s: packet malloc failed", __func__);
 438                 return SR_ERR_MALLOC;
 439         }
 440
 441         if (!(header = g_try_malloc(sizeof(struct sr_datafeed_header)))) {
 442                 sr_err("%s: header malloc failed", __func__);
 443                 return SR_ERR_MALLOC;
 444         }
 445
 446         packet->type = SR_DF_HEADER;
 447         packet->payload = header;
 448         header->feed_version = 1;
 449         gettimeofday(&header->starttime, NULL);
 450         sr_session_send(devc->session_dev_id, packet);
 451
 452         /* We use this timestamp to decide how many more samples to send. */
 453         devc->starttime = g_get_monotonic_time();
 454
 455         g_free(header);
 456         g_free(packet);
 457
 458         return SR_OK;
 459 }
 460
 461 static int hw_dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
 462 {
 463         struct dev_context *devc;
 464         struct sr_datafeed_packet packet;
 465
 466         (void)sdi;
 467
 468         devc = cb_data;
 469
 470         sr_dbg("Stopping aquisition.");
 471
 472         sr_session_source_remove_channel(devc->channels[0]);
 473         g_io_channel_shutdown(devc->channels[0], FALSE, NULL);
 474
 475         /* Send last packet. */
 476         packet.type = SR_DF_END;
 477         sr_session_send(devc->session_dev_id, &packet);
 478
 479         return SR_OK;
 480 }
 481
 482 SR_PRIV struct sr_dev_driver demo_driver_info = {
 483         .name = "demo",
 484         .longname = "Demo driver and pattern generator",
 485         .api_version = 1,
 486         .init = hw_init,
 487         .cleanup = hw_cleanup,
 488         .scan = hw_scan,
 489         .dev_list = hw_dev_list,
 490         .dev_clear = clear_instances,
 491         .config_get = config_get,
 492         .config_set = config_set,
 493         .dev_open = hw_dev_open,
 494         .dev_close = hw_dev_close,
 495         .dev_acquisition_start = hw_dev_acquisition_start,
 496         .dev_acquisition_stop = hw_dev_acquisition_stop,
 497         .priv = NULL,
 498 };