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/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_group[] = {
 161         SR_CONF_AMPLITUDE | SR_CONF_GET | SR_CONF_SET,
 162 };
 163
 164 static const uint32_t devopts_cg_analog_channel[] = {
 165         SR_CONF_PATTERN_MODE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
 166         SR_CONF_AMPLITUDE | SR_CONF_GET | SR_CONF_SET,
 167 };
 168
 169 static const uint64_t samplerates[] = {
 170         SR_HZ(1),
 171         SR_GHZ(1),
 172         SR_HZ(1),
 173 };
 174
 175 static const uint8_t pattern_sigrok[] = {
 176         0x4c, 0x92, 0x92, 0x92, 0x64, 0x00, 0x00, 0x00,
 177         0x82, 0xfe, 0xfe, 0x82, 0x00, 0x00, 0x00, 0x00,
 178         0x7c, 0x82, 0x82, 0x92, 0x74, 0x00, 0x00, 0x00,
 179         0xfe, 0x12, 0x12, 0x32, 0xcc, 0x00, 0x00, 0x00,
 180         0x7c, 0x82, 0x82, 0x82, 0x7c, 0x00, 0x00, 0x00,
 181         0xfe, 0x10, 0x28, 0x44, 0x82, 0x00, 0x00, 0x00,
 182         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 183         0xbe, 0xbe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 184 };
 185
 186 SR_PRIV struct sr_dev_driver demo_driver_info;
 187
 188 static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data);
 189
 190 static int init(struct sr_dev_driver *di, struct sr_context *sr_ctx)
 191 {
 192         return std_init(sr_ctx, di, LOG_PREFIX);
 193 }
 194
 195 static void generate_analog_pattern(struct analog_gen *ag, uint64_t sample_rate)
 196 {
 197         double t, frequency;
 198         float value;
 199         unsigned int num_samples, i;
 200         int last_end;
 201
 202         sr_dbg("Generating %s pattern.", analog_pattern_str[ag->pattern]);
 203
 204         num_samples = ANALOG_BUFSIZE / sizeof(float);
 205
 206         switch (ag->pattern) {
 207         case PATTERN_SQUARE:
 208                 value = ag->amplitude;
 209                 last_end = 0;
 210                 for (i = 0; i < num_samples; i++) {
 211                         if (i % 5 == 0)
 212                                 value = -value;
 213                         if (i % 10 == 0)
 214                                 last_end = i;
 215                         ag->pattern_data[i] = value;
 216                 }
 217                 ag->num_samples = last_end;
 218                 break;
 219         case PATTERN_SINE:
 220                 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
 221
 222                 /* Make sure the number of samples we put out is an integer
 223                  * multiple of our period size */
 224                 /* FIXME we actually need only one period. A ringbuffer would be
 225                  * useful here. */
 226                 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
 227                         num_samples--;
 228
 229                 for (i = 0; i < num_samples; i++) {
 230                         t = (double) i / (double) sample_rate;
 231                         ag->pattern_data[i] = ag->amplitude *
 232                                                 sin(2 * G_PI * frequency * t);
 233                 }
 234
 235                 ag->num_samples = num_samples;
 236                 break;
 237         case PATTERN_TRIANGLE:
 238                 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
 239
 240                 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
 241                         num_samples--;
 242
 243                 for (i = 0; i < num_samples; i++) {
 244                         t = (double) i / (double) sample_rate;
 245                         ag->pattern_data[i] = (2 * ag->amplitude / G_PI) *
 246                                                 asin(sin(2 * G_PI * frequency * t));
 247                 }
 248
 249                 ag->num_samples = num_samples;
 250                 break;
 251         case PATTERN_SAWTOOTH:
 252                 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
 253
 254                 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
 255                         num_samples--;
 256
 257                 for (i = 0; i < num_samples; i++) {
 258                         t = (double) i / (double) sample_rate;
 259                         ag->pattern_data[i] = 2 * ag->amplitude *
 260                                                 ((t * frequency) - floor(0.5f + t * frequency));
 261                 }
 262
 263                 ag->num_samples = num_samples;
 264                 break;
 265         }
 266 }
 267
 268 static GSList *scan(struct sr_dev_driver *di, GSList *options)
 269 {
 270         struct drv_context *drvc;
 271         struct dev_context *devc;
 272         struct sr_dev_inst *sdi;
 273         struct sr_channel *ch;
 274         struct sr_channel_group *cg, *acg;
 275         struct sr_config *src;
 276         struct analog_gen *ag;
 277         GSList *devices, *l;
 278         int num_logic_channels, num_analog_channels, pattern, i;
 279         char channel_name[16];
 280
 281         drvc = di->context;
 282
 283         num_logic_channels = DEFAULT_NUM_LOGIC_CHANNELS;
 284         num_analog_channels = DEFAULT_NUM_ANALOG_CHANNELS;
 285         for (l = options; l; l = l->next) {
 286                 src = l->data;
 287                 switch (src->key) {
 288                 case SR_CONF_NUM_LOGIC_CHANNELS:
 289                         num_logic_channels = g_variant_get_int32(src->data);
 290                         break;
 291                 case SR_CONF_NUM_ANALOG_CHANNELS:
 292                         num_analog_channels = g_variant_get_int32(src->data);
 293                         break;
 294                 }
 295         }
 296
 297         devices = NULL;
 298
 299         sdi = g_malloc0(sizeof(struct sr_dev_inst));
 300         sdi->status = SR_ST_ACTIVE;
 301         sdi->model = g_strdup("Demo device");
 302         sdi->driver = di;
 303
 304         devc = g_malloc(sizeof(struct dev_context));
 305         devc->cur_samplerate = SR_KHZ(200);
 306         devc->limit_samples = 0;
 307         devc->limit_msec = 0;
 308         devc->step = 0;
 309         devc->continuous = FALSE;
 310         devc->num_logic_channels = num_logic_channels;
 311         devc->logic_unitsize = (devc->num_logic_channels + 7) / 8;
 312         devc->logic_pattern = PATTERN_SIGROK;
 313         devc->num_analog_channels = num_analog_channels;
 314         devc->avg = FALSE;
 315         devc->avg_samples = 0;
 316
 317         /* Logic channels, all in one channel group. */
 318         cg = g_malloc0(sizeof(struct sr_channel_group));
 319         cg->name = g_strdup("Logic");
 320         for (i = 0; i < num_logic_channels; i++) {
 321                 sprintf(channel_name, "D%d", i);
 322                 ch = sr_channel_new(sdi, i, SR_CHANNEL_LOGIC, TRUE, channel_name);
 323                 cg->channels = g_slist_append(cg->channels, ch);
 324         }
 325         sdi->channel_groups = g_slist_append(NULL, cg);
 326
 327         /* Analog channels, channel groups and pattern generators. */
 328         pattern = 0;
 329         /* An "Analog" channel group with all analog channels in it. */
 330         acg = g_malloc0(sizeof(struct sr_channel_group));
 331         acg->name = g_strdup("Analog");
 332         sdi->channel_groups = g_slist_append(sdi->channel_groups, acg);
 333
 334         devc->ch_ag = g_hash_table_new(g_direct_hash, g_direct_equal);
 335         for (i = 0; i < num_analog_channels; i++) {
 336                 snprintf(channel_name, 16, "A%d", i);
 337                 ch = sr_channel_new(sdi, i + num_logic_channels, SR_CHANNEL_ANALOG,
 338                                 TRUE, channel_name);
 339                 acg->channels = g_slist_append(acg->channels, ch);
 340
 341                 /* Every analog channel gets its own channel group as well. */
 342                 cg = g_malloc0(sizeof(struct sr_channel_group));
 343                 cg->name = g_strdup(channel_name);
 344                 cg->channels = g_slist_append(NULL, ch);
 345                 sdi->channel_groups = g_slist_append(sdi->channel_groups, cg);
 346
 347                 /* Every channel gets a generator struct. */
 348                 ag = g_malloc(sizeof(struct analog_gen));
 349                 ag->amplitude = DEFAULT_ANALOG_AMPLITUDE;
 350                 ag->packet.channels = cg->channels;
 351                 ag->packet.mq = 0;
 352                 ag->packet.mqflags = 0;
 353                 ag->packet.unit = SR_UNIT_VOLT;
 354                 ag->packet.data = ag->pattern_data;
 355                 ag->pattern = pattern;
 356                 ag->avg_val = 0.0f;
 357                 ag->num_avgs = 0;
 358                 g_hash_table_insert(devc->ch_ag, ch, ag);
 359
 360                 if (++pattern == ARRAY_SIZE(analog_pattern_str))
 361                         pattern = 0;
 362         }
 363
 364         sdi->priv = devc;
 365         devices = g_slist_append(devices, sdi);
 366         drvc->instances = g_slist_append(drvc->instances, sdi);
 367
 368         return devices;
 369 }
 370
 371 static GSList *dev_list(const struct sr_dev_driver *di)
 372 {
 373         return ((struct drv_context *)(di->context))->instances;
 374 }
 375
 376 static int dev_open(struct sr_dev_inst *sdi)
 377 {
 378         sdi->status = SR_ST_ACTIVE;
 379
 380         return SR_OK;
 381 }
 382
 383 static int dev_close(struct sr_dev_inst *sdi)
 384 {
 385         sdi->status = SR_ST_INACTIVE;
 386
 387         return SR_OK;
 388 }
 389
 390 static void clear_helper(void *priv)
 391 {
 392         struct dev_context *devc;
 393         GHashTableIter iter;
 394         void *value;
 395
 396         devc = priv;
 397
 398         /* Analog generators. */
 399         g_hash_table_iter_init(&iter, devc->ch_ag);
 400         while (g_hash_table_iter_next(&iter, NULL, &value))
 401                 g_free(value);
 402         g_hash_table_unref(devc->ch_ag);
 403         g_free(devc);
 404 }
 405
 406 static int cleanup(const struct sr_dev_driver *di)
 407 {
 408         return std_dev_clear(di, clear_helper);
 409 }
 410
 411 static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
 412                 const struct sr_channel_group *cg)
 413 {
 414         struct dev_context *devc;
 415         struct sr_channel *ch;
 416         struct analog_gen *ag;
 417         int pattern;
 418
 419         if (!sdi)
 420                 return SR_ERR_ARG;
 421
 422         devc = sdi->priv;
 423         switch (key) {
 424         case SR_CONF_SAMPLERATE:
 425                 *data = g_variant_new_uint64(devc->cur_samplerate);
 426                 break;
 427         case SR_CONF_LIMIT_SAMPLES:
 428                 *data = g_variant_new_uint64(devc->limit_samples);
 429                 break;
 430         case SR_CONF_LIMIT_MSEC:
 431                 *data = g_variant_new_uint64(devc->limit_msec);
 432                 break;
 433         case SR_CONF_AVERAGING:
 434                 *data = g_variant_new_boolean(devc->avg);
 435                 break;
 436         case SR_CONF_AVG_SAMPLES:
 437                 *data = g_variant_new_uint64(devc->avg_samples);
 438                 break;
 439         case SR_CONF_PATTERN_MODE:
 440                 if (!cg)
 441                         return SR_ERR_CHANNEL_GROUP;
 442                 /* Any channel in the group will do. */
 443                 ch = cg->channels->data;
 444                 if (ch->type == SR_CHANNEL_LOGIC) {
 445                         pattern = devc->logic_pattern;
 446                         *data = g_variant_new_string(logic_pattern_str[pattern]);
 447                 } else if (ch->type == SR_CHANNEL_ANALOG) {
 448                         ag = g_hash_table_lookup(devc->ch_ag, ch);
 449                         pattern = ag->pattern;
 450                         *data = g_variant_new_string(analog_pattern_str[pattern]);
 451                 } else
 452                         return SR_ERR_BUG;
 453                 break;
 454         case SR_CONF_AMPLITUDE:
 455                 if (!cg)
 456                         return SR_ERR_CHANNEL_GROUP;
 457                 /* Any channel in the group will do. */
 458                 ch = cg->channels->data;
 459                 if (ch->type != SR_CHANNEL_ANALOG)
 460                         return SR_ERR_ARG;
 461                 ag = g_hash_table_lookup(devc->ch_ag, ch);
 462                 *data = g_variant_new_double(ag->amplitude);
 463                 break;
 464         default:
 465                 return SR_ERR_NA;
 466         }
 467
 468         return SR_OK;
 469 }
 470
 471 static int config_set(uint32_t key, GVariant *data, const struct sr_dev_inst *sdi,
 472                 const struct sr_channel_group *cg)
 473 {
 474         struct dev_context *devc;
 475         struct analog_gen *ag;
 476         struct sr_channel *ch;
 477         GSList *l;
 478         int logic_pattern, analog_pattern, ret;
 479         unsigned int i;
 480         const char *stropt;
 481
 482         devc = sdi->priv;
 483
 484         if (sdi->status != SR_ST_ACTIVE)
 485                 return SR_ERR_DEV_CLOSED;
 486
 487         ret = SR_OK;
 488         switch (key) {
 489         case SR_CONF_SAMPLERATE:
 490                 devc->cur_samplerate = g_variant_get_uint64(data);
 491                 break;
 492         case SR_CONF_LIMIT_SAMPLES:
 493                 devc->limit_msec = 0;
 494                 devc->limit_samples = g_variant_get_uint64(data);
 495                 break;
 496         case SR_CONF_LIMIT_MSEC:
 497                 devc->limit_msec = g_variant_get_uint64(data);
 498                 devc->limit_samples = 0;
 499                 break;
 500         case SR_CONF_AVERAGING:
 501                 devc->avg = g_variant_get_boolean(data);
 502                 sr_dbg("%s averaging", devc->avg ? "Enabling" : "Disabling");
 503                 break;
 504         case SR_CONF_AVG_SAMPLES:
 505                 devc->avg_samples = g_variant_get_uint64(data);
 506                 sr_dbg("Setting averaging rate to %" PRIu64, devc->avg_samples);
 507                 break;
 508         case SR_CONF_PATTERN_MODE:
 509                 if (!cg)
 510                         return SR_ERR_CHANNEL_GROUP;
 511                 stropt = g_variant_get_string(data, NULL);
 512                 logic_pattern = analog_pattern = -1;
 513                 for (i = 0; i < ARRAY_SIZE(logic_pattern_str); i++) {
 514                         if (!strcmp(stropt, logic_pattern_str[i])) {
 515                                 logic_pattern = i;
 516                                 break;
 517                         }
 518                 }
 519                 for (i = 0; i < ARRAY_SIZE(analog_pattern_str); i++) {
 520                         if (!strcmp(stropt, analog_pattern_str[i])) {
 521                                 analog_pattern = i;
 522                                 break;
 523                         }
 524                 }
 525                 if (logic_pattern == -1 && analog_pattern == -1)
 526                         return SR_ERR_ARG;
 527                 for (l = cg->channels; l; l = l->next) {
 528                         ch = l->data;
 529                         if (ch->type == SR_CHANNEL_LOGIC) {
 530                                 if (logic_pattern == -1)
 531                                         return SR_ERR_ARG;
 532                                 sr_dbg("Setting logic pattern to %s",
 533                                                 logic_pattern_str[logic_pattern]);
 534                                 devc->logic_pattern = logic_pattern;
 535                                 /* Might as well do this now, these are static. */
 536                                 if (logic_pattern == PATTERN_ALL_LOW)
 537                                         memset(devc->logic_data, 0x00, LOGIC_BUFSIZE);
 538                                 else if (logic_pattern == PATTERN_ALL_HIGH)
 539                                         memset(devc->logic_data, 0xff, LOGIC_BUFSIZE);
 540                         } else if (ch->type == SR_CHANNEL_ANALOG) {
 541                                 if (analog_pattern == -1)
 542                                         return SR_ERR_ARG;
 543                                 sr_dbg("Setting analog pattern for channel %s to %s",
 544                                                 ch->name, analog_pattern_str[analog_pattern]);
 545                                 ag = g_hash_table_lookup(devc->ch_ag, ch);
 546                                 ag->pattern = analog_pattern;
 547                         } else
 548                                 return SR_ERR_BUG;
 549                 }
 550                 break;
 551         case SR_CONF_AMPLITUDE:
 552                 if (!cg)
 553                         return SR_ERR_CHANNEL_GROUP;
 554                 for (l = cg->channels; l; l = l->next) {
 555                         ch = l->data;
 556                         if (ch->type != SR_CHANNEL_ANALOG)
 557                                 return SR_ERR_ARG;
 558                         ag = g_hash_table_lookup(devc->ch_ag, ch);
 559                         ag->amplitude = g_variant_get_double(data);
 560                 }
 561                 break;
 562         default:
 563                 ret = SR_ERR_NA;
 564         }
 565
 566         return ret;
 567 }
 568
 569 static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
 570                 const struct sr_channel_group *cg)
 571 {
 572         struct sr_channel *ch;
 573         GVariant *gvar;
 574         GVariantBuilder gvb;
 575
 576         if (key == SR_CONF_SCAN_OPTIONS) {
 577                 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
 578                                 scanopts, ARRAY_SIZE(scanopts), sizeof(uint32_t));
 579                 return SR_OK;
 580         }
 581
 582         if (key == SR_CONF_DEVICE_OPTIONS && !sdi) {
 583                 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
 584                                 drvopts, ARRAY_SIZE(drvopts), sizeof(uint32_t));
 585                 return SR_OK;
 586         }
 587
 588         if (!sdi)
 589                 return SR_ERR_ARG;
 590
 591         if (!cg) {
 592                 switch (key) {
 593                 case SR_CONF_DEVICE_OPTIONS:
 594                         *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
 595                                         devopts, ARRAY_SIZE(devopts), sizeof(uint32_t));
 596                         break;
 597                 case SR_CONF_SAMPLERATE:
 598                         g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
 599                         gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates,
 600                                         ARRAY_SIZE(samplerates), sizeof(uint64_t));
 601                         g_variant_builder_add(&gvb, "{sv}", "samplerate-steps", gvar);
 602                         *data = g_variant_builder_end(&gvb);
 603                         break;
 604                 default:
 605                         return SR_ERR_NA;
 606                 }
 607         } else {
 608                 ch = cg->channels->data;
 609                 switch (key) {
 610                 case SR_CONF_DEVICE_OPTIONS:
 611                         if (ch->type == SR_CHANNEL_LOGIC)
 612                                 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
 613                                                 devopts_cg_logic, ARRAY_SIZE(devopts_cg_logic),
 614                                                 sizeof(uint32_t));
 615                         else if (ch->type == SR_CHANNEL_ANALOG) {
 616                                 if (strcmp(cg->name, "Analog") == 0)
 617                                         *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
 618                                                         devopts_cg_analog_group, ARRAY_SIZE(devopts_cg_analog_group),
 619                                                         sizeof(uint32_t));
 620                                 else
 621                                         *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
 622                                                         devopts_cg_analog_channel, ARRAY_SIZE(devopts_cg_analog_channel),
 623                                                         sizeof(uint32_t));
 624                         }
 625                         else
 626                                 return SR_ERR_BUG;
 627                         break;
 628                 case SR_CONF_PATTERN_MODE:
 629                         /* The analog group (with all 4 channels) shall not have a pattern property. */
 630                         if (strcmp(cg->name, "Analog") == 0)
 631                                 return SR_ERR_NA;
 632
 633                         if (ch->type == SR_CHANNEL_LOGIC)
 634                                 *data = g_variant_new_strv(logic_pattern_str,
 635                                                 ARRAY_SIZE(logic_pattern_str));
 636                         else if (ch->type == SR_CHANNEL_ANALOG)
 637                                 *data = g_variant_new_strv(analog_pattern_str,
 638                                                 ARRAY_SIZE(analog_pattern_str));
 639                         else
 640                                 return SR_ERR_BUG;
 641                         break;
 642                 default:
 643                         return SR_ERR_NA;
 644                 }
 645         }
 646
 647         return SR_OK;
 648 }
 649
 650 static void logic_generator(struct sr_dev_inst *sdi, uint64_t size)
 651 {
 652         struct dev_context *devc;
 653         uint64_t i, j;
 654         uint8_t pat;
 655
 656         devc = sdi->priv;
 657
 658         switch (devc->logic_pattern) {
 659         case PATTERN_SIGROK:
 660                 memset(devc->logic_data, 0x00, size);
 661                 for (i = 0; i < size; i += devc->logic_unitsize) {
 662                         for (j = 0; j < devc->logic_unitsize; j++) {
 663                                 pat = pattern_sigrok[(devc->step + j) % sizeof(pattern_sigrok)] >> 1;
 664                                 devc->logic_data[i + j] = ~pat;
 665                         }
 666                         devc->step++;
 667                 }
 668                 break;
 669         case PATTERN_RANDOM:
 670                 for (i = 0; i < size; i++)
 671                         devc->logic_data[i] = (uint8_t)(rand() & 0xff);
 672                 break;
 673         case PATTERN_INC:
 674                 for (i = 0; i < size; i++) {
 675                         for (j = 0; j < devc->logic_unitsize; j++) {
 676                                 devc->logic_data[i + j] = devc->step;
 677                         }
 678                         devc->step++;
 679                 }
 680                 break;
 681         case PATTERN_ALL_LOW:
 682         case PATTERN_ALL_HIGH:
 683                 /* These were set when the pattern mode was selected. */
 684                 break;
 685         default:
 686                 sr_err("Unknown pattern: %d.", devc->logic_pattern);
 687                 break;
 688         }
 689 }
 690
 691 static void send_analog_packet(struct analog_gen *ag,
 692                                struct sr_dev_inst *sdi,
 693                                uint64_t *analog_sent,
 694                                uint64_t analog_todo)
 695 {
 696         struct sr_datafeed_packet packet;
 697         struct dev_context *devc;
 698         uint64_t sending_now, to_avg;
 699         int ag_pattern_pos;
 700         unsigned int i;
 701
 702         devc = sdi->priv;
 703         packet.type = SR_DF_ANALOG;
 704         packet.payload = &ag->packet;
 705
 706         if (!devc->avg) {
 707                 ag_pattern_pos = devc->analog_counter % ag->num_samples;
 708                 sending_now = MIN(analog_todo, ag->num_samples-ag_pattern_pos);
 709                 ag->packet.data = ag->pattern_data + ag_pattern_pos;
 710                 ag->packet.num_samples = sending_now;
 711                 sr_session_send(sdi, &packet);
 712
 713                 /* Whichever channel group gets there first. */
 714                 *analog_sent = MAX(*analog_sent, sending_now);
 715         } else {
 716                 ag_pattern_pos = devc->analog_counter % ag->num_samples;
 717                 to_avg = MIN(analog_todo, ag->num_samples-ag_pattern_pos);
 718
 719                 for (i = 0; i < to_avg; i++) {
 720                         ag->avg_val = (ag->avg_val +
 721                                         *(ag->pattern_data +
 722                                           ag_pattern_pos + i)) / 2;
 723                         ag->num_avgs++;
 724                         /* Time to send averaged data? */
 725                         if (devc->avg_samples > 0 &&
 726                             ag->num_avgs >= devc->avg_samples)
 727                                 goto do_send;
 728                 }
 729
 730                 if (devc->avg_samples == 0) {
 731                         /* We're averaging all the samples, so wait with
 732                          * sending until the very end.
 733                          */
 734                         *analog_sent = ag->num_avgs;
 735                         return;
 736                 }
 737
 738 do_send:
 739                 ag->packet.data = &ag->avg_val;
 740                 ag->packet.num_samples = 1;
 741
 742                 sr_session_send(sdi, &packet);
 743                 *analog_sent = ag->num_avgs;
 744
 745                 ag->num_avgs = 0;
 746                 ag->avg_val = 0.0f;
 747         }
 748 }
 749
 750 /* Callback handling data */
 751 static int prepare_data(int fd, int revents, void *cb_data)
 752 {
 753         struct sr_dev_inst *sdi;
 754         struct dev_context *devc;
 755         struct sr_datafeed_packet packet;
 756         struct sr_datafeed_logic logic;
 757         struct analog_gen *ag;
 758         GHashTableIter iter;
 759         void *value;
 760         uint64_t logic_todo, analog_todo, expected_samplenum, analog_sent, sending_now;
 761         int64_t time, elapsed;
 762
 763         (void)fd;
 764         (void)revents;
 765
 766         sdi = cb_data;
 767         devc = sdi->priv;
 768         logic_todo = analog_todo = 0;
 769
 770         /* How many samples should we have sent by now? */
 771         time = g_get_monotonic_time();
 772         elapsed = time - devc->starttime;
 773         expected_samplenum = elapsed * devc->cur_samplerate / (1000 * 1000);
 774
 775         /* But never more than the limit, if there is one. */
 776         if (!devc->continuous)
 777                 expected_samplenum = MIN(expected_samplenum, devc->limit_samples);
 778
 779         /* Of those, how many do we still have to send? */
 780         if (devc->num_logic_channels && (devc->logic_counter < devc->limit_samples))
 781                 logic_todo = expected_samplenum - devc->logic_counter;
 782         if (devc->num_analog_channels && (devc->analog_counter < devc->limit_samples))
 783                 analog_todo = expected_samplenum - devc->analog_counter;
 784
 785         while (logic_todo || analog_todo) {
 786                 /* Logic */
 787                 if (logic_todo > 0) {
 788                         sending_now = MIN(logic_todo, LOGIC_BUFSIZE / devc->logic_unitsize);
 789                         logic_generator(sdi, sending_now * devc->logic_unitsize);
 790                         packet.type = SR_DF_LOGIC;
 791                         packet.payload = &logic;
 792                         logic.length = sending_now * devc->logic_unitsize;
 793                         logic.unitsize = devc->logic_unitsize;
 794                         logic.data = devc->logic_data;
 795                         sr_session_send(sdi, &packet);
 796                         logic_todo -= sending_now;
 797                         devc->logic_counter += sending_now;
 798                 }
 799
 800                 /* Analog, one channel at a time */
 801                 if (analog_todo > 0) {
 802                         analog_sent = 0;
 803
 804                         g_hash_table_iter_init(&iter, devc->ch_ag);
 805                         while (g_hash_table_iter_next(&iter, NULL, &value)) {
 806                                 send_analog_packet(value, sdi,
 807                                                    &analog_sent, analog_todo);
 808                         }
 809                         analog_todo -= analog_sent;
 810                         devc->analog_counter += analog_sent;
 811                 }
 812         }
 813
 814         if (!devc->continuous
 815                         && (!devc->num_logic_channels || devc->logic_counter >= devc->limit_samples)
 816                         && (!devc->num_analog_channels || devc->analog_counter >= devc->limit_samples)) {
 817                 /* If we're averaging everything - now is the time to send data */
 818                 if (devc->avg_samples == 0) {
 819                         g_hash_table_iter_init(&iter, devc->ch_ag);
 820                         while (g_hash_table_iter_next(&iter, NULL, &value)) {
 821                                 ag = value;
 822                                 packet.type = SR_DF_ANALOG;
 823                                 packet.payload = &ag->packet;
 824                                 ag->packet.data = &ag->avg_val;
 825                                 ag->packet.num_samples = 1;
 826                                 sr_session_send(sdi, &packet);
 827                         }
 828                 }
 829
 830                 sr_dbg("Requested number of samples reached.");
 831                 dev_acquisition_stop(sdi, cb_data);
 832                 return TRUE;
 833         }
 834
 835         return TRUE;
 836 }
 837
 838 static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
 839 {
 840         struct dev_context *devc;
 841         GHashTableIter iter;
 842         void *value;
 843
 844         (void)cb_data;
 845
 846         if (sdi->status != SR_ST_ACTIVE)
 847                 return SR_ERR_DEV_CLOSED;
 848
 849         devc = sdi->priv;
 850         devc->continuous = !devc->limit_samples;
 851         devc->logic_counter = devc->analog_counter = 0;
 852
 853         /*
 854          * Setting two channels connected by a pipe is a remnant from when the
 855          * demo driver generated data in a thread, and collected and sent the
 856          * data in the main program loop.
 857          * They are kept here because it provides a convenient way of setting
 858          * up a timeout-based polling mechanism.
 859          */
 860         if (pipe(devc->pipe_fds)) {
 861                 sr_err("%s: pipe() failed", __func__);
 862                 return SR_ERR;
 863         }
 864
 865         g_hash_table_iter_init(&iter, devc->ch_ag);
 866         while (g_hash_table_iter_next(&iter, NULL, &value))
 867                 generate_analog_pattern(value, devc->cur_samplerate);
 868
 869         devc->channel = g_io_channel_unix_new(devc->pipe_fds[0]);
 870         g_io_channel_set_flags(devc->channel, G_IO_FLAG_NONBLOCK, NULL);
 871
 872         /* Set channel encoding to binary (default is UTF-8). */
 873         g_io_channel_set_encoding(devc->channel, NULL, NULL);
 874
 875         /* Make channels unbuffered. */
 876         g_io_channel_set_buffered(devc->channel, FALSE);
 877
 878         sr_session_source_add_channel(sdi->session, devc->channel,
 879                         G_IO_IN | G_IO_ERR, 40, prepare_data, (void *)sdi);
 880
 881         /* Send header packet to the session bus. */
 882         std_session_send_df_header(sdi, LOG_PREFIX);
 883
 884         /* We use this timestamp to decide how many more samples to send. */
 885         devc->starttime = g_get_monotonic_time();
 886
 887         return SR_OK;
 888 }
 889
 890 static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
 891 {
 892         struct dev_context *devc;
 893         struct sr_datafeed_packet packet;
 894
 895         (void)cb_data;
 896
 897         devc = sdi->priv;
 898         sr_dbg("Stopping acquisition.");
 899
 900         sr_session_source_remove_channel(sdi->session, devc->channel);
 901         g_io_channel_shutdown(devc->channel, FALSE, NULL);
 902         g_io_channel_unref(devc->channel);
 903         devc->channel = NULL;
 904         close(devc->pipe_fds[0]);
 905         close(devc->pipe_fds[1]);
 906
 907         /* Send last packet. */
 908         packet.type = SR_DF_END;
 909         sr_session_send(sdi, &packet);
 910
 911         return SR_OK;
 912 }
 913
 914 SR_PRIV struct sr_dev_driver demo_driver_info = {
 915         .name = "demo",
 916         .longname = "Demo driver and pattern generator",
 917         .api_version = 1,
 918         .init = init,
 919         .cleanup = cleanup,
 920         .scan = scan,
 921         .dev_list = dev_list,
 922         .dev_clear = NULL,
 923         .config_get = config_get,
 924         .config_set = config_set,
 925         .config_list = config_list,
 926         .dev_open = dev_open,
 927         .dev_close = dev_close,
 928         .dev_acquisition_start = dev_acquisition_start,
 929         .dev_acquisition_stop = dev_acquisition_stop,
 930         .context = NULL,
 931 };