src/hardware/demo/demo.c

   1 /*
   2  * This file is part of the libsigrok 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  * Copyright (C) 2015 Bartosz Golaszewski <bgolaszewski@baylibre.com>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  22  */
  23
  24 #include <stdlib.h>
  25 #include <unistd.h>
  26 #include <string.h>
  27 #include <math.h>
  28 #ifdef _WIN32
  29 #include <io.h>
  30 #include <fcntl.h>
  31 #define pipe(fds) _pipe(fds, 4096, _O_BINARY)
  32 #endif
  33 #include "libsigrok.h"
  34 #include "libsigrok-internal.h"
  35
  36 #define LOG_PREFIX "demo"
  37
  38 #define DEFAULT_NUM_LOGIC_CHANNELS     8
  39 #define DEFAULT_NUM_ANALOG_CHANNELS    4
  40
  41 /* The size in bytes of chunks to send through the session bus. */
  42 #define LOGIC_BUFSIZE        4096
  43 /* Size of the analog pattern space per channel. */
  44 #define ANALOG_BUFSIZE       4096
  45
  46 #define DEFAULT_ANALOG_AMPLITUDE 25
  47 #define ANALOG_SAMPLES_PER_PERIOD 20
  48
  49 /* Logic patterns we can generate. */
  50 enum {
  51         /**
  52          * Spells "sigrok" across 8 channels using '0's (with '1's as
  53          * "background") when displayed using the 'bits' output format.
  54          * The pattern is repeated every 8 channels, shifted to the right
  55          * in time by one bit.
  56          */
  57         PATTERN_SIGROK,
  58
  59         /** Pseudo-random values on all channels. */
  60         PATTERN_RANDOM,
  61
  62         /**
  63          * Incrementing number across 8 channels. The pattern is repeated
  64          * every 8 channels, shifted to the right in time by one bit.
  65          */
  66         PATTERN_INC,
  67
  68         /** All channels have a low logic state. */
  69         PATTERN_ALL_LOW,
  70
  71         /** All channels have a high logic state. */
  72         PATTERN_ALL_HIGH,
  73 };
  74
  75 /* Analog patterns we can generate. */
  76 enum {
  77         /**
  78          * Square wave.
  79          */
  80         PATTERN_SQUARE,
  81         PATTERN_SINE,
  82         PATTERN_TRIANGLE,
  83         PATTERN_SAWTOOTH,
  84 };
  85
  86 static const char *logic_pattern_str[] = {
  87         "sigrok",
  88         "random",
  89         "incremental",
  90         "all-low",
  91         "all-high",
  92 };
  93
  94 static const char *analog_pattern_str[] = {
  95         "square",
  96         "sine",
  97         "triangle",
  98         "sawtooth",
  99 };
 100
 101 struct analog_gen {
 102         int pattern;
 103         float amplitude;
 104         float pattern_data[ANALOG_BUFSIZE];
 105         unsigned int num_samples;
 106         struct sr_datafeed_analog packet;
 107         float avg_val; /* Average value */
 108         unsigned num_avgs; /* Number of samples averaged */
 109 };
 110
 111 /* Private, per-device-instance driver context. */
 112 struct dev_context {
 113         int pipe_fds[2];
 114         GIOChannel *channel;
 115         uint64_t cur_samplerate;
 116         gboolean continuous;
 117         uint64_t limit_samples;
 118         uint64_t limit_msec;
 119         uint64_t logic_counter;
 120         uint64_t analog_counter;
 121         int64_t starttime;
 122         uint64_t step;
 123         /* Logic */
 124         int32_t num_logic_channels;
 125         unsigned int logic_unitsize;
 126         /* There is only ever one logic channel group, so its pattern goes here. */
 127         uint8_t logic_pattern;
 128         unsigned char logic_data[LOGIC_BUFSIZE];
 129         /* Analog */
 130         int32_t num_analog_channels;
 131         GHashTable *ch_ag;
 132         gboolean avg; /* True if averaging is enabled */
 133         uint64_t avg_samples;
 134 };
 135
 136 static const uint32_t drvopts[] = {
 137         SR_CONF_DEMO_DEV,
 138         SR_CONF_LOGIC_ANALYZER,
 139         SR_CONF_OSCILLOSCOPE,
 140 };
 141
 142 static const uint32_t scanopts[] = {
 143         SR_CONF_NUM_LOGIC_CHANNELS,
 144         SR_CONF_NUM_ANALOG_CHANNELS,
 145 };
 146
 147 static const uint32_t devopts[] = {
 148         SR_CONF_CONTINUOUS | SR_CONF_SET,
 149         SR_CONF_LIMIT_SAMPLES | SR_CONF_GET | SR_CONF_SET,
 150         SR_CONF_LIMIT_MSEC | SR_CONF_GET | SR_CONF_SET,
 151         SR_CONF_SAMPLERATE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
 152         SR_CONF_AVERAGING | SR_CONF_GET | SR_CONF_SET,
 153         SR_CONF_AVG_SAMPLES | SR_CONF_GET | SR_CONF_SET,
 154 };
 155
 156 static const uint32_t devopts_cg_logic[] = {
 157         SR_CONF_PATTERN_MODE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
 158 };
 159
 160 static const uint32_t devopts_cg_analog[] = {
 161         SR_CONF_PATTERN_MODE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
 162         SR_CONF_AMPLITUDE | SR_CONF_GET | SR_CONF_SET,
 163 };
 164
 165 static const uint64_t samplerates[] = {
 166         SR_HZ(1),
 167         SR_GHZ(1),
 168         SR_HZ(1),
 169 };
 170
 171 static uint8_t pattern_sigrok[] = {
 172         0x4c, 0x92, 0x92, 0x92, 0x64, 0x00, 0x00, 0x00,
 173         0x82, 0xfe, 0xfe, 0x82, 0x00, 0x00, 0x00, 0x00,
 174         0x7c, 0x82, 0x82, 0x92, 0x74, 0x00, 0x00, 0x00,
 175         0xfe, 0x12, 0x12, 0x32, 0xcc, 0x00, 0x00, 0x00,
 176         0x7c, 0x82, 0x82, 0x82, 0x7c, 0x00, 0x00, 0x00,
 177         0xfe, 0x10, 0x28, 0x44, 0x82, 0x00, 0x00, 0x00,
 178         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 179         0xbe, 0xbe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 180 };
 181
 182 SR_PRIV struct sr_dev_driver demo_driver_info;
 183
 184 static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data);
 185
 186 static int init(struct sr_dev_driver *di, struct sr_context *sr_ctx)
 187 {
 188         return std_init(sr_ctx, di, LOG_PREFIX);
 189 }
 190
 191 static void generate_analog_pattern(struct analog_gen *ag, uint64_t sample_rate)
 192 {
 193         double t, frequency;
 194         float value;
 195         unsigned int num_samples, i;
 196         int last_end;
 197
 198         sr_dbg("Generating %s pattern.", analog_pattern_str[ag->pattern]);
 199
 200         num_samples = ANALOG_BUFSIZE / sizeof(float);
 201
 202         switch (ag->pattern) {
 203         case PATTERN_SQUARE:
 204                 value = ag->amplitude;
 205                 last_end = 0;
 206                 for (i = 0; i < num_samples; i++) {
 207                         if (i % 5 == 0)
 208                                 value = -value;
 209                         if (i % 10 == 0)
 210                                 last_end = i;
 211                         ag->pattern_data[i] = value;
 212                 }
 213                 ag->num_samples = last_end;
 214                 break;
 215
 216         case PATTERN_SINE:
 217                 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
 218
 219                 /* Make sure the number of samples we put out is an integer
 220                  * multiple of our period size */
 221                 /* FIXME we actually need only one period. A ringbuffer would be
 222                  * usefull here.*/
 223                 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
 224                         num_samples--;
 225
 226                 for (i = 0; i < num_samples; i++) {
 227                         t = (double) i / (double) sample_rate;
 228                         ag->pattern_data[i] = ag->amplitude *
 229                                                 sin(2 * M_PI * frequency * t);
 230                 }
 231
 232                 ag->num_samples = num_samples;
 233                 break;
 234
 235         case PATTERN_TRIANGLE:
 236                 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
 237
 238                 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
 239                         num_samples--;
 240
 241                 for (i = 0; i < num_samples; i++) {
 242                         t = (double) i / (double) sample_rate;
 243                         ag->pattern_data[i] = (2 * ag->amplitude / M_PI) *
 244                                                 asin(sin(2 * M_PI * frequency * t));
 245                 }
 246
 247                 ag->num_samples = num_samples;
 248                 break;
 249
 250         case PATTERN_SAWTOOTH:
 251                 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
 252
 253                 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
 254                         num_samples--;
 255
 256                 for (i = 0; i < num_samples; i++) {
 257                         t = (double) i / (double) sample_rate;
 258                         ag->pattern_data[i] = 2 * ag->amplitude *
 259                                                 ((t * frequency) - floor(0.5f + t * frequency));
 260                 }
 261
 262                 ag->num_samples = num_samples;
 263                 break;
 264         }
 265 }
 266
 267 static GSList *scan(struct sr_dev_driver *di, GSList *options)
 268 {
 269         struct drv_context *drvc;
 270         struct dev_context *devc;
 271         struct sr_dev_inst *sdi;
 272         struct sr_channel *ch;
 273         struct sr_channel_group *cg, *acg;
 274         struct sr_config *src;
 275         struct analog_gen *ag;
 276         GSList *devices, *l;
 277         int num_logic_channels, num_analog_channels, pattern, i;
 278         char channel_name[16];
 279
 280         drvc = di->priv;
 281
 282         num_logic_channels = DEFAULT_NUM_LOGIC_CHANNELS;
 283         num_analog_channels = DEFAULT_NUM_ANALOG_CHANNELS;
 284         for (l = options; l; l = l->next) {
 285                 src = l->data;
 286                 switch (src->key) {
 287                 case SR_CONF_NUM_LOGIC_CHANNELS:
 288                         num_logic_channels = g_variant_get_int32(src->data);
 289                         break;
 290                 case SR_CONF_NUM_ANALOG_CHANNELS:
 291                         num_analog_channels = g_variant_get_int32(src->data);
 292                         break;
 293                 }
 294         }
 295
 296         devices = NULL;
 297
 298         sdi = g_malloc0(sizeof(struct sr_dev_inst));
 299         sdi->status = SR_ST_ACTIVE;
 300         sdi->model = g_strdup("Demo device");
 301         sdi->driver = di;
 302
 303         devc = g_malloc(sizeof(struct dev_context));
 304         devc->cur_samplerate = SR_KHZ(200);
 305         devc->limit_samples = 0;
 306         devc->limit_msec = 0;
 307         devc->step = 0;
 308         devc->continuous = FALSE;
 309         devc->num_logic_channels = num_logic_channels;
 310         devc->logic_unitsize = (devc->num_logic_channels + 7) / 8;
 311         devc->logic_pattern = PATTERN_SIGROK;
 312         devc->num_analog_channels = num_analog_channels;
 313         devc->avg = FALSE;
 314         devc->avg_samples = 0;
 315
 316         /* Logic channels, all in one channel group. */
 317         cg = g_malloc0(sizeof(struct sr_channel_group));
 318         cg->name = g_strdup("Logic");
 319         for (i = 0; i < num_logic_channels; i++) {
 320                 sprintf(channel_name, "D%d", i);
 321                 ch = sr_channel_new(sdi, i, SR_CHANNEL_LOGIC, TRUE, channel_name);
 322                 cg->channels = g_slist_append(cg->channels, ch);
 323         }
 324         sdi->channel_groups = g_slist_append(NULL, cg);
 325
 326         /* Analog channels, channel groups and pattern generators. */
 327         pattern = 0;
 328         /* An "Analog" channel group with all analog channels in it. */
 329         acg = g_malloc0(sizeof(struct sr_channel_group));
 330         acg->name = g_strdup("Analog");
 331         sdi->channel_groups = g_slist_append(sdi->channel_groups, acg);
 332
 333         devc->ch_ag = g_hash_table_new(g_direct_hash, g_direct_equal);
 334         for (i = 0; i < num_analog_channels; i++) {
 335                 snprintf(channel_name, 16, "A%d", i);
 336                 ch = sr_channel_new(sdi, i + num_logic_channels, SR_CHANNEL_ANALOG,
 337                                 TRUE, channel_name);
 338                 acg->channels = g_slist_append(acg->channels, ch);
 339
 340                 /* Every analog channel gets its own channel group as well. */
 341                 cg = g_malloc0(sizeof(struct sr_channel_group));
 342                 cg->name = g_strdup(channel_name);
 343                 cg->channels = g_slist_append(NULL, ch);
 344                 sdi->channel_groups = g_slist_append(sdi->channel_groups, cg);
 345
 346                 /* Every channel gets a generator struct. */
 347                 ag = g_malloc(sizeof(struct analog_gen));
 348                 ag->amplitude = DEFAULT_ANALOG_AMPLITUDE;
 349                 ag->packet.channels = cg->channels;
 350                 ag->packet.mq = 0;
 351                 ag->packet.mqflags = 0;
 352                 ag->packet.unit = SR_UNIT_VOLT;
 353                 ag->packet.data = ag->pattern_data;
 354                 ag->pattern = pattern;
 355                 ag->avg_val = 0.0f;
 356                 ag->num_avgs = 0;
 357                 g_hash_table_insert(devc->ch_ag, ch, ag);
 358
 359                 if (++pattern == ARRAY_SIZE(analog_pattern_str))
 360                         pattern = 0;
 361         }
 362
 363         sdi->priv = devc;
 364         devices = g_slist_append(devices, sdi);
 365         drvc->instances = g_slist_append(drvc->instances, sdi);
 366
 367         return devices;
 368 }
 369
 370 static GSList *dev_list(const struct sr_dev_driver *di)
 371 {
 372         return ((struct drv_context *)(di->priv))->instances;
 373 }
 374
 375 static int dev_open(struct sr_dev_inst *sdi)
 376 {
 377         sdi->status = SR_ST_ACTIVE;
 378
 379         return SR_OK;
 380 }
 381
 382 static int dev_close(struct sr_dev_inst *sdi)
 383 {
 384         sdi->status = SR_ST_INACTIVE;
 385
 386         return SR_OK;
 387 }
 388
 389 static void clear_helper(void *priv)
 390 {
 391         struct dev_context *devc;
 392         GHashTableIter iter;
 393         void *value;
 394
 395         devc = priv;
 396
 397         /* Analog generators. */
 398         g_hash_table_iter_init(&iter, devc->ch_ag);
 399         while (g_hash_table_iter_next(&iter, NULL, &value))
 400                 g_free(value);
 401         g_hash_table_unref(devc->ch_ag);
 402         g_free(devc);
 403 }
 404
 405 static int cleanup(const struct sr_dev_driver *di)
 406 {
 407         return std_dev_clear(di, clear_helper);
 408 }
 409
 410 static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
 411                 const struct sr_channel_group *cg)
 412 {
 413         struct dev_context *devc;
 414         struct sr_channel *ch;
 415         struct analog_gen *ag;
 416         int pattern;
 417
 418         if (!sdi)
 419                 return SR_ERR_ARG;
 420
 421         devc = sdi->priv;
 422         switch (key) {
 423         case SR_CONF_SAMPLERATE:
 424                 *data = g_variant_new_uint64(devc->cur_samplerate);
 425                 break;
 426         case SR_CONF_LIMIT_SAMPLES:
 427                 *data = g_variant_new_uint64(devc->limit_samples);
 428                 break;
 429         case SR_CONF_LIMIT_MSEC:
 430                 *data = g_variant_new_uint64(devc->limit_msec);
 431                 break;
 432         case SR_CONF_AVERAGING:
 433                 *data = g_variant_new_boolean(devc->avg);
 434                 break;
 435         case SR_CONF_AVG_SAMPLES:
 436                 *data = g_variant_new_uint64(devc->avg_samples);
 437                 break;
 438         case SR_CONF_PATTERN_MODE:
 439                 if (!cg)
 440                         return SR_ERR_CHANNEL_GROUP;
 441                 /* Any channel in the group will do. */
 442                 ch = cg->channels->data;
 443                 if (ch->type == SR_CHANNEL_LOGIC) {
 444                         pattern = devc->logic_pattern;
 445                         *data = g_variant_new_string(logic_pattern_str[pattern]);
 446                 } else if (ch->type == SR_CHANNEL_ANALOG) {
 447                         ag = g_hash_table_lookup(devc->ch_ag, ch);
 448                         pattern = ag->pattern;
 449                         *data = g_variant_new_string(analog_pattern_str[pattern]);
 450                 } else
 451                         return SR_ERR_BUG;
 452                 break;
 453         case SR_CONF_AMPLITUDE:
 454                 if (!cg)
 455                         return SR_ERR_CHANNEL_GROUP;
 456                 /* Any channel in the group will do. */
 457                 ch = cg->channels->data;
 458                 if (ch->type != SR_CHANNEL_ANALOG)
 459                         return SR_ERR_ARG;
 460                 ag = g_hash_table_lookup(devc->ch_ag, ch);
 461                 *data = g_variant_new_double(ag->amplitude);
 462                 break;
 463         default:
 464                 return SR_ERR_NA;
 465         }
 466
 467         return SR_OK;
 468 }
 469
 470 static int config_set(uint32_t key, GVariant *data, const struct sr_dev_inst *sdi,
 471                 const struct sr_channel_group *cg)
 472 {
 473         struct dev_context *devc;
 474         struct analog_gen *ag;
 475         struct sr_channel *ch;
 476         GSList *l;
 477         int logic_pattern, analog_pattern, ret;
 478         unsigned int i;
 479         const char *stropt;
 480
 481         devc = sdi->priv;
 482
 483         if (sdi->status != SR_ST_ACTIVE)
 484                 return SR_ERR_DEV_CLOSED;
 485
 486         ret = SR_OK;
 487         switch (key) {
 488         case SR_CONF_SAMPLERATE:
 489                 devc->cur_samplerate = g_variant_get_uint64(data);
 490                 sr_dbg("Setting samplerate to %" PRIu64, devc->cur_samplerate);
 491                 break;
 492         case SR_CONF_LIMIT_SAMPLES:
 493                 devc->limit_msec = 0;
 494                 devc->limit_samples = g_variant_get_uint64(data);
 495                 sr_dbg("Setting sample limit to %" PRIu64, devc->limit_samples);
 496                 break;
 497         case SR_CONF_LIMIT_MSEC:
 498                 devc->limit_msec = g_variant_get_uint64(data);
 499                 devc->limit_samples = 0;
 500                 sr_dbg("Setting time limit to %" PRIu64"ms", devc->limit_msec);
 501                 break;
 502         case SR_CONF_AVERAGING:
 503                 devc->avg = g_variant_get_boolean(data);
 504                 sr_dbg("%s averaging", devc->avg ? "Enabling" : "Disabling");
 505                 break;
 506         case SR_CONF_AVG_SAMPLES:
 507                 devc->avg_samples = g_variant_get_uint64(data);
 508                 sr_dbg("Setting averaging rate to %" PRIu64, devc->avg_samples);
 509                 break;
 510         case SR_CONF_PATTERN_MODE:
 511                 if (!cg)
 512                         return SR_ERR_CHANNEL_GROUP;
 513                 stropt = g_variant_get_string(data, NULL);
 514                 logic_pattern = analog_pattern = -1;
 515                 for (i = 0; i < ARRAY_SIZE(logic_pattern_str); i++) {
 516                         if (!strcmp(stropt, logic_pattern_str[i])) {
 517                                 logic_pattern = i;
 518                                 break;
 519                         }
 520                 }
 521                 for (i = 0; i < ARRAY_SIZE(analog_pattern_str); i++) {
 522                         if (!strcmp(stropt, analog_pattern_str[i])) {
 523                                 analog_pattern = i;
 524                                 break;
 525                         }
 526                 }
 527                 if (logic_pattern == -1 && analog_pattern == -1)
 528                         return SR_ERR_ARG;
 529                 for (l = cg->channels; l; l = l->next) {
 530                         ch = l->data;
 531                         if (ch->type == SR_CHANNEL_LOGIC) {
 532                                 if (logic_pattern == -1)
 533                                         return SR_ERR_ARG;
 534                                 sr_dbg("Setting logic pattern to %s",
 535                                                 logic_pattern_str[logic_pattern]);
 536                                 devc->logic_pattern = logic_pattern;
 537                                 /* Might as well do this now, these are static. */
 538                                 if (logic_pattern == PATTERN_ALL_LOW)
 539                                         memset(devc->logic_data, 0x00, LOGIC_BUFSIZE);
 540                                 else if (logic_pattern == PATTERN_ALL_HIGH)
 541                                         memset(devc->logic_data, 0xff, LOGIC_BUFSIZE);
 542                         } else if (ch->type == SR_CHANNEL_ANALOG) {
 543                                 if (analog_pattern == -1)
 544                                         return SR_ERR_ARG;
 545                                 sr_dbg("Setting analog pattern for channel %s to %s",
 546                                                 ch->name, analog_pattern_str[analog_pattern]);
 547                                 ag = g_hash_table_lookup(devc->ch_ag, ch);
 548                                 ag->pattern = analog_pattern;
 549                         } else
 550                                 return SR_ERR_BUG;
 551                 }
 552                 break;
 553         case SR_CONF_AMPLITUDE:
 554                 if (!cg)
 555                         return SR_ERR_CHANNEL_GROUP;
 556                 for (l = cg->channels; l; l = l->next) {
 557                         ch = l->data;
 558                         if (ch->type != SR_CHANNEL_ANALOG)
 559                                 return SR_ERR_ARG;
 560                         ag = g_hash_table_lookup(devc->ch_ag, ch);
 561                         ag->amplitude = g_variant_get_double(data);
 562                 }
 563                 break;
 564         default:
 565                 ret = SR_ERR_NA;
 566         }
 567
 568         return ret;
 569 }
 570
 571 static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
 572                 const struct sr_channel_group *cg)
 573 {
 574         struct sr_channel *ch;
 575         GVariant *gvar;
 576         GVariantBuilder gvb;
 577
 578         (void)sdi;
 579
 580         if (key == SR_CONF_SCAN_OPTIONS) {
 581                 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
 582                                 scanopts, ARRAY_SIZE(scanopts), sizeof(uint32_t));
 583                 return SR_OK;
 584         }
 585
 586         if (key == SR_CONF_DEVICE_OPTIONS && !sdi) {
 587                 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
 588                                 drvopts, ARRAY_SIZE(drvopts), sizeof(uint32_t));
 589                 return SR_OK;
 590         }
 591
 592         if (!sdi)
 593                 return SR_ERR_ARG;
 594
 595         if (!cg) {
 596                 switch (key) {
 597                 case SR_CONF_DEVICE_OPTIONS:
 598                         *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
 599                                         devopts, ARRAY_SIZE(devopts), sizeof(uint32_t));
 600                         break;
 601                 case SR_CONF_SAMPLERATE:
 602                         g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
 603                         gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates,
 604                                         ARRAY_SIZE(samplerates), sizeof(uint64_t));
 605                         g_variant_builder_add(&gvb, "{sv}", "samplerate-steps", gvar);
 606                         *data = g_variant_builder_end(&gvb);
 607                         break;
 608                 default:
 609                         return SR_ERR_NA;
 610                 }
 611         } else {
 612                 /* Any channel in the group will do. */
 613                 ch = cg->channels->data;
 614                 switch (key) {
 615                 case SR_CONF_DEVICE_OPTIONS:
 616                         if (ch->type == SR_CHANNEL_LOGIC)
 617                                 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
 618                                                 devopts_cg_logic, ARRAY_SIZE(devopts_cg_logic),
 619                                                 sizeof(uint32_t));
 620                         else if (ch->type == SR_CHANNEL_ANALOG)
 621                                 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
 622                                                 devopts_cg_analog, ARRAY_SIZE(devopts_cg_analog),
 623                                                 sizeof(uint32_t));
 624                         else
 625                                 return SR_ERR_BUG;
 626                         break;
 627                 case SR_CONF_PATTERN_MODE:
 628                         if (ch->type == SR_CHANNEL_LOGIC)
 629                                 *data = g_variant_new_strv(logic_pattern_str,
 630                                                 ARRAY_SIZE(logic_pattern_str));
 631                         else if (ch->type == SR_CHANNEL_ANALOG)
 632                                 *data = g_variant_new_strv(analog_pattern_str,
 633                                                 ARRAY_SIZE(analog_pattern_str));
 634                         else
 635                                 return SR_ERR_BUG;
 636                         break;
 637                 default:
 638                         return SR_ERR_NA;
 639                 }
 640         }
 641
 642         return SR_OK;
 643 }
 644
 645 static void logic_generator(struct sr_dev_inst *sdi, uint64_t size)
 646 {
 647         struct dev_context *devc;
 648         uint64_t i, j;
 649         uint8_t pat;
 650
 651         devc = sdi->priv;
 652
 653         switch (devc->logic_pattern) {
 654         case PATTERN_SIGROK:
 655                 memset(devc->logic_data, 0x00, size);
 656                 for (i = 0; i < size; i += devc->logic_unitsize) {
 657                         for (j = 0; j < devc->logic_unitsize; j++) {
 658                                 pat = pattern_sigrok[(devc->step + j) % sizeof(pattern_sigrok)] >> 1;
 659                                 devc->logic_data[i + j] = ~pat;
 660                         }
 661                         devc->step++;
 662                 }
 663                 break;
 664         case PATTERN_RANDOM:
 665                 for (i = 0; i < size; i++)
 666                         devc->logic_data[i] = (uint8_t)(rand() & 0xff);
 667                 break;
 668         case PATTERN_INC:
 669                 for (i = 0; i < size; i++) {
 670                         for (j = 0; j < devc->logic_unitsize; j++) {
 671                                 devc->logic_data[i + j] = devc->step;
 672                         }
 673                         devc->step++;
 674                 }
 675                 break;
 676         case PATTERN_ALL_LOW:
 677         case PATTERN_ALL_HIGH:
 678                 /* These were set when the pattern mode was selected. */
 679                 break;
 680         default:
 681                 sr_err("Unknown pattern: %d.", devc->logic_pattern);
 682                 break;
 683         }
 684 }
 685
 686 static void send_analog_packet(struct analog_gen *ag,
 687                                struct sr_dev_inst *sdi,
 688                                uint64_t *analog_sent,
 689                                uint64_t analog_todo)
 690 {
 691         struct sr_datafeed_packet packet;
 692         struct dev_context *devc;
 693         uint64_t sending_now, to_avg;
 694         int ag_pattern_pos;
 695         unsigned int i;
 696
 697         devc = sdi->priv;
 698         packet.type = SR_DF_ANALOG;
 699         packet.payload = &ag->packet;
 700
 701         if (!devc->avg) {
 702                 ag_pattern_pos = devc->analog_counter % ag->num_samples;
 703                 sending_now = MIN(analog_todo, ag->num_samples-ag_pattern_pos);
 704                 ag->packet.data = ag->pattern_data + ag_pattern_pos;
 705                 ag->packet.num_samples = sending_now;
 706                 sr_session_send(sdi, &packet);
 707
 708                 /* Whichever channel group gets there first. */
 709                 *analog_sent = MAX(*analog_sent, sending_now);
 710         } else {
 711                 ag_pattern_pos = devc->analog_counter % ag->num_samples;
 712                 to_avg = MIN(analog_todo, ag->num_samples-ag_pattern_pos);
 713
 714                 for (i = 0; i < to_avg; i++) {
 715                         ag->avg_val = (ag->avg_val +
 716                                         *(ag->pattern_data +
 717                                           ag_pattern_pos + i)) / 2;
 718                         ag->num_avgs++;
 719                         /* Time to send averaged data? */
 720                         if (devc->avg_samples > 0 &&
 721                             ag->num_avgs >= devc->avg_samples)
 722                                 goto do_send;
 723                 }
 724
 725                 if (devc->avg_samples == 0) {
 726                         /* We're averaging all the samples, so wait with
 727                          * sending until the very end.
 728                          */
 729                         *analog_sent = ag->num_avgs;
 730                         return;
 731                 }
 732
 733 do_send:
 734                 ag->packet.data = &ag->avg_val;
 735                 ag->packet.num_samples = 1;
 736
 737                 sr_session_send(sdi, &packet);
 738                 *analog_sent = ag->num_avgs;
 739
 740                 ag->num_avgs = 0;
 741                 ag->avg_val = 0.0f;
 742         }
 743 }
 744
 745 /* Callback handling data */
 746 static int prepare_data(int fd, int revents, void *cb_data)
 747 {
 748         struct sr_dev_inst *sdi;
 749         struct dev_context *devc;
 750         struct sr_datafeed_packet packet;
 751         struct sr_datafeed_logic logic;
 752         struct analog_gen *ag;
 753         GHashTableIter iter;
 754         void *value;
 755         uint64_t logic_todo, analog_todo, expected_samplenum, analog_sent, sending_now;
 756         int64_t time, elapsed;
 757
 758         (void)fd;
 759         (void)revents;
 760
 761         sdi = cb_data;
 762         devc = sdi->priv;
 763         logic_todo = analog_todo = 0;
 764
 765         /* How many samples should we have sent by now? */
 766         time = g_get_monotonic_time();
 767         elapsed = time - devc->starttime;
 768         expected_samplenum = elapsed * devc->cur_samplerate / 1000000;
 769
 770         /* But never more than the limit, if there is one. */
 771         if (!devc->continuous)
 772                 expected_samplenum = MIN(expected_samplenum, devc->limit_samples);
 773
 774         /* Of those, how many do we still have to send? */
 775         if (devc->num_logic_channels)
 776                 logic_todo = expected_samplenum - devc->logic_counter;
 777         if (devc->num_analog_channels)
 778                 analog_todo = expected_samplenum - devc->analog_counter;
 779
 780         while (logic_todo || analog_todo) {
 781                 /* Logic */
 782                 if (logic_todo > 0) {
 783                         sending_now = MIN(logic_todo, LOGIC_BUFSIZE / devc->logic_unitsize);
 784                         logic_generator(sdi, sending_now * devc->logic_unitsize);
 785                         packet.type = SR_DF_LOGIC;
 786                         packet.payload = &logic;
 787                         logic.length = sending_now * devc->logic_unitsize;
 788                         logic.unitsize = devc->logic_unitsize;
 789                         logic.data = devc->logic_data;
 790                         sr_session_send(sdi, &packet);
 791                         logic_todo -= sending_now;
 792                         devc->logic_counter += sending_now;
 793                 }
 794
 795                 /* Analog, one channel at a time */
 796                 if (analog_todo > 0) {
 797                         analog_sent = 0;
 798
 799                         g_hash_table_iter_init(&iter, devc->ch_ag);
 800                         while (g_hash_table_iter_next(&iter, NULL, &value)) {
 801                                 send_analog_packet(value, sdi,
 802                                                    &analog_sent, analog_todo);
 803                         }
 804                         analog_todo -= analog_sent;
 805                         devc->analog_counter += analog_sent;
 806                 }
 807         }
 808
 809         if (!devc->continuous
 810                         && (!devc->num_logic_channels || devc->logic_counter >= devc->limit_samples)
 811                         && (!devc->num_analog_channels || devc->analog_counter >= devc->limit_samples)) {
 812                 /* If we're averaging everything - now is the time to send data */
 813                 if (devc->avg_samples == 0) {
 814                         g_hash_table_iter_init(&iter, devc->ch_ag);
 815                         while (g_hash_table_iter_next(&iter, NULL, &value)) {
 816                                 ag = value;
 817                                 packet.type = SR_DF_ANALOG;
 818                                 packet.payload = &ag->packet;
 819                                 ag->packet.data = &ag->avg_val;
 820                                 ag->packet.num_samples = 1;
 821                                 sr_session_send(sdi, &packet);
 822                         }
 823                 }
 824
 825                 sr_dbg("Requested number of samples reached.");
 826                 dev_acquisition_stop(sdi, cb_data);
 827                 return TRUE;
 828         }
 829
 830         return TRUE;
 831 }
 832
 833 static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
 834 {
 835         struct dev_context *devc;
 836         GHashTableIter iter;
 837         void *value;
 838
 839         (void)cb_data;
 840
 841         if (sdi->status != SR_ST_ACTIVE)
 842                 return SR_ERR_DEV_CLOSED;
 843
 844         devc = sdi->priv;
 845         devc->continuous = !devc->limit_samples;
 846         devc->logic_counter = devc->analog_counter = 0;
 847
 848         /*
 849          * Setting two channels connected by a pipe is a remnant from when the
 850          * demo driver generated data in a thread, and collected and sent the
 851          * data in the main program loop.
 852          * They are kept here because it provides a convenient way of setting
 853          * up a timeout-based polling mechanism.
 854          */
 855         if (pipe(devc->pipe_fds)) {
 856                 sr_err("%s: pipe() failed", __func__);
 857                 return SR_ERR;
 858         }
 859
 860         g_hash_table_iter_init(&iter, devc->ch_ag);
 861         while (g_hash_table_iter_next(&iter, NULL, &value))
 862                 generate_analog_pattern(value, devc->cur_samplerate);
 863
 864         devc->channel = g_io_channel_unix_new(devc->pipe_fds[0]);
 865         g_io_channel_set_flags(devc->channel, G_IO_FLAG_NONBLOCK, NULL);
 866
 867         /* Set channel encoding to binary (default is UTF-8). */
 868         g_io_channel_set_encoding(devc->channel, NULL, NULL);
 869
 870         /* Make channels unbuffered. */
 871         g_io_channel_set_buffered(devc->channel, FALSE);
 872
 873         sr_session_source_add_channel(sdi->session, devc->channel,
 874                         G_IO_IN | G_IO_ERR, 40, prepare_data, (void *)sdi);
 875
 876         /* Send header packet to the session bus. */
 877         std_session_send_df_header(sdi, LOG_PREFIX);
 878
 879         /* We use this timestamp to decide how many more samples to send. */
 880         devc->starttime = g_get_monotonic_time();
 881
 882         return SR_OK;
 883 }
 884
 885 static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
 886 {
 887         struct dev_context *devc;
 888         struct sr_datafeed_packet packet;
 889
 890         (void)cb_data;
 891
 892         devc = sdi->priv;
 893         sr_dbg("Stopping acquisition.");
 894
 895         sr_session_source_remove_channel(sdi->session, devc->channel);
 896         g_io_channel_shutdown(devc->channel, FALSE, NULL);
 897         g_io_channel_unref(devc->channel);
 898         devc->channel = NULL;
 899
 900         /* Send last packet. */
 901         packet.type = SR_DF_END;
 902         sr_session_send(sdi, &packet);
 903
 904         return SR_OK;
 905 }
 906
 907 SR_PRIV struct sr_dev_driver demo_driver_info = {
 908         .name = "demo",
 909         .longname = "Demo driver and pattern generator",
 910         .api_version = 1,
 911         .init = init,
 912         .cleanup = cleanup,
 913         .scan = scan,
 914         .dev_list = dev_list,
 915         .dev_clear = NULL,
 916         .config_get = config_get,
 917         .config_set = config_set,
 918         .config_list = config_list,
 919         .dev_open = dev_open,
 920         .dev_close = dev_close,
 921         .dev_acquisition_start = dev_acquisition_start,
 922         .dev_acquisition_stop = dev_acquisition_stop,
 923         .priv = NULL,
 924 };