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