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
 187 static int init(struct sr_dev_driver *di, struct sr_context *sr_ctx)
 188 {
 189         return std_init(sr_ctx, di, LOG_PREFIX);
 190 }
 191
 192 static void generate_analog_pattern(struct analog_gen *ag, uint64_t sample_rate)
 193 {
 194         double t, frequency;
 195         float value;
 196         unsigned int num_samples, i;
 197         int last_end;
 198
 199         sr_dbg("Generating %s pattern.", analog_pattern_str[ag->pattern]);
 200
 201         num_samples = ANALOG_BUFSIZE / sizeof(float);
 202
 203         switch (ag->pattern) {
 204         case PATTERN_SQUARE:
 205                 value = ag->amplitude;
 206                 last_end = 0;
 207                 for (i = 0; i < num_samples; i++) {
 208                         if (i % 5 == 0)
 209                                 value = -value;
 210                         if (i % 10 == 0)
 211                                 last_end = i;
 212                         ag->pattern_data[i] = value;
 213                 }
 214                 ag->num_samples = last_end;
 215                 break;
 216
 217         case PATTERN_SINE:
 218                 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
 219
 220                 /* Make sure the number of samples we put out is an integer
 221                  * multiple of our period size */
 222                 /* FIXME we actually need only one period. A ringbuffer would be
 223                  * usefull here.*/
 224                 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
 225                         num_samples--;
 226
 227                 for (i = 0; i < num_samples; i++) {
 228                         t = (double) i / (double) sample_rate;
 229                         ag->pattern_data[i] = ag->amplitude *
 230                                                 sin(2 * M_PI * frequency * t);
 231                 }
 232
 233                 ag->num_samples = num_samples;
 234                 break;
 235
 236         case PATTERN_TRIANGLE:
 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 / M_PI) *
 245                                                 asin(sin(2 * M_PI * frequency * t));
 246                 }
 247
 248                 ag->num_samples = num_samples;
 249                 break;
 250
 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->priv;
 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->priv))->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                 sr_dbg("Setting samplerate to %" PRIu64, devc->cur_samplerate);
 492                 break;
 493         case SR_CONF_LIMIT_SAMPLES:
 494                 devc->limit_msec = 0;
 495                 devc->limit_samples = g_variant_get_uint64(data);
 496                 sr_dbg("Setting sample limit to %" PRIu64, devc->limit_samples);
 497                 break;
 498         case SR_CONF_LIMIT_MSEC:
 499                 devc->limit_msec = g_variant_get_uint64(data);
 500                 devc->limit_samples = 0;
 501                 sr_dbg("Setting time limit to %" PRIu64"ms", devc->limit_msec);
 502                 break;
 503         case SR_CONF_AVERAGING:
 504                 devc->avg = g_variant_get_boolean(data);
 505                 sr_dbg("%s averaging", devc->avg ? "Enabling" : "Disabling");
 506                 break;
 507         case SR_CONF_AVG_SAMPLES:
 508                 devc->avg_samples = g_variant_get_uint64(data);
 509                 sr_dbg("Setting averaging rate to %" PRIu64, devc->avg_samples);
 510                 break;
 511         case SR_CONF_PATTERN_MODE:
 512                 if (!cg)
 513                         return SR_ERR_CHANNEL_GROUP;
 514                 stropt = g_variant_get_string(data, NULL);
 515                 logic_pattern = analog_pattern = -1;
 516                 for (i = 0; i < ARRAY_SIZE(logic_pattern_str); i++) {
 517                         if (!strcmp(stropt, logic_pattern_str[i])) {
 518                                 logic_pattern = i;
 519                                 break;
 520                         }
 521                 }
 522                 for (i = 0; i < ARRAY_SIZE(analog_pattern_str); i++) {
 523                         if (!strcmp(stropt, analog_pattern_str[i])) {
 524                                 analog_pattern = i;
 525                                 break;
 526                         }
 527                 }
 528                 if (logic_pattern == -1 && analog_pattern == -1)
 529                         return SR_ERR_ARG;
 530                 for (l = cg->channels; l; l = l->next) {
 531                         ch = l->data;
 532                         if (ch->type == SR_CHANNEL_LOGIC) {
 533                                 if (logic_pattern == -1)
 534                                         return SR_ERR_ARG;
 535                                 sr_dbg("Setting logic pattern to %s",
 536                                                 logic_pattern_str[logic_pattern]);
 537                                 devc->logic_pattern = logic_pattern;
 538                                 /* Might as well do this now, these are static. */
 539                                 if (logic_pattern == PATTERN_ALL_LOW)
 540                                         memset(devc->logic_data, 0x00, LOGIC_BUFSIZE);
 541                                 else if (logic_pattern == PATTERN_ALL_HIGH)
 542                                         memset(devc->logic_data, 0xff, LOGIC_BUFSIZE);
 543                         } else if (ch->type == SR_CHANNEL_ANALOG) {
 544                                 if (analog_pattern == -1)
 545                                         return SR_ERR_ARG;
 546                                 sr_dbg("Setting analog pattern for channel %s to %s",
 547                                                 ch->name, analog_pattern_str[analog_pattern]);
 548                                 ag = g_hash_table_lookup(devc->ch_ag, ch);
 549                                 ag->pattern = analog_pattern;
 550                         } else
 551                                 return SR_ERR_BUG;
 552                 }
 553                 break;
 554         case SR_CONF_AMPLITUDE:
 555                 if (!cg)
 556                         return SR_ERR_CHANNEL_GROUP;
 557                 for (l = cg->channels; l; l = l->next) {
 558                         ch = l->data;
 559                         if (ch->type != SR_CHANNEL_ANALOG)
 560                                 return SR_ERR_ARG;
 561                         ag = g_hash_table_lookup(devc->ch_ag, ch);
 562                         ag->amplitude = g_variant_get_double(data);
 563                 }
 564                 break;
 565         default:
 566                 ret = SR_ERR_NA;
 567         }
 568
 569         return ret;
 570 }
 571
 572 static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
 573                 const struct sr_channel_group *cg)
 574 {
 575         struct sr_channel *ch;
 576         GVariant *gvar;
 577         GVariantBuilder gvb;
 578
 579         (void)sdi;
 580
 581         if (key == SR_CONF_SCAN_OPTIONS) {
 582                 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
 583                                 scanopts, ARRAY_SIZE(scanopts), sizeof(uint32_t));
 584                 return SR_OK;
 585         }
 586
 587         if (key == SR_CONF_DEVICE_OPTIONS && !sdi) {
 588                 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
 589                                 drvopts, ARRAY_SIZE(drvopts), sizeof(uint32_t));
 590                 return SR_OK;
 591         }
 592
 593         if (!sdi)
 594                 return SR_ERR_ARG;
 595
 596         if (!cg) {
 597                 switch (key) {
 598                 case SR_CONF_DEVICE_OPTIONS:
 599                         *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
 600                                         devopts, ARRAY_SIZE(devopts), sizeof(uint32_t));
 601                         break;
 602                 case SR_CONF_SAMPLERATE:
 603                         g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
 604                         gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates,
 605                                         ARRAY_SIZE(samplerates), sizeof(uint64_t));
 606                         g_variant_builder_add(&gvb, "{sv}", "samplerate-steps", gvar);
 607                         *data = g_variant_builder_end(&gvb);
 608                         break;
 609                 default:
 610                         return SR_ERR_NA;
 611                 }
 612         } else {
 613                 /* Any channel in the group will do. */
 614                 ch = cg->channels->data;
 615                 switch (key) {
 616                 case SR_CONF_DEVICE_OPTIONS:
 617                         if (ch->type == SR_CHANNEL_LOGIC)
 618                                 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
 619                                                 devopts_cg_logic, ARRAY_SIZE(devopts_cg_logic),
 620                                                 sizeof(uint32_t));
 621                         else if (ch->type == SR_CHANNEL_ANALOG)
 622                                 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
 623                                                 devopts_cg_analog, ARRAY_SIZE(devopts_cg_analog),
 624                                                 sizeof(uint32_t));
 625                         else
 626                                 return SR_ERR_BUG;
 627                         break;
 628                 case SR_CONF_PATTERN_MODE:
 629                         if (ch->type == SR_CHANNEL_LOGIC)
 630                                 *data = g_variant_new_strv(logic_pattern_str,
 631                                                 ARRAY_SIZE(logic_pattern_str));
 632                         else if (ch->type == SR_CHANNEL_ANALOG)
 633                                 *data = g_variant_new_strv(analog_pattern_str,
 634                                                 ARRAY_SIZE(analog_pattern_str));
 635                         else
 636                                 return SR_ERR_BUG;
 637                         break;
 638                 default:
 639                         return SR_ERR_NA;
 640                 }
 641         }
 642
 643         return SR_OK;
 644 }
 645
 646 static void logic_generator(struct sr_dev_inst *sdi, uint64_t size)
 647 {
 648         struct dev_context *devc;
 649         uint64_t i, j;
 650         uint8_t pat;
 651
 652         devc = sdi->priv;
 653
 654         switch (devc->logic_pattern) {
 655         case PATTERN_SIGROK:
 656                 memset(devc->logic_data, 0x00, size);
 657                 for (i = 0; i < size; i += devc->logic_unitsize) {
 658                         for (j = 0; j < devc->logic_unitsize; j++) {
 659                                 pat = pattern_sigrok[(devc->step + j) % sizeof(pattern_sigrok)] >> 1;
 660                                 devc->logic_data[i + j] = ~pat;
 661                         }
 662                         devc->step++;
 663                 }
 664                 break;
 665         case PATTERN_RANDOM:
 666                 for (i = 0; i < size; i++)
 667                         devc->logic_data[i] = (uint8_t)(rand() & 0xff);
 668                 break;
 669         case PATTERN_INC:
 670                 for (i = 0; i < size; i++) {
 671                         for (j = 0; j < devc->logic_unitsize; j++) {
 672                                 devc->logic_data[i + j] = devc->step;
 673                         }
 674                         devc->step++;
 675                 }
 676                 break;
 677         case PATTERN_ALL_LOW:
 678         case PATTERN_ALL_HIGH:
 679                 /* These were set when the pattern mode was selected. */
 680                 break;
 681         default:
 682                 sr_err("Unknown pattern: %d.", devc->logic_pattern);
 683                 break;
 684         }
 685 }
 686
 687 static void send_analog_packet(struct analog_gen *ag,
 688                                struct sr_dev_inst *sdi,
 689                                uint64_t *analog_sent,
 690                                uint64_t analog_todo)
 691 {
 692         struct sr_datafeed_packet packet;
 693         struct dev_context *devc;
 694         uint64_t sending_now, to_avg;
 695         int ag_pattern_pos;
 696         unsigned int i;
 697
 698         devc = sdi->priv;
 699         packet.type = SR_DF_ANALOG;
 700         packet.payload = &ag->packet;
 701
 702         if (!devc->avg) {
 703                 ag_pattern_pos = devc->analog_counter % ag->num_samples;
 704                 sending_now = MIN(analog_todo, ag->num_samples-ag_pattern_pos);
 705                 ag->packet.data = ag->pattern_data + ag_pattern_pos;
 706                 ag->packet.num_samples = sending_now;
 707                 sr_session_send(sdi, &packet);
 708
 709                 /* Whichever channel group gets there first. */
 710                 *analog_sent = MAX(*analog_sent, sending_now);
 711         } else {
 712                 ag_pattern_pos = devc->analog_counter % ag->num_samples;
 713                 to_avg = MIN(analog_todo, ag->num_samples-ag_pattern_pos);
 714
 715                 for (i = 0; i < to_avg; i++) {
 716                         ag->avg_val = (ag->avg_val +
 717                                         *(ag->pattern_data +
 718                                           ag_pattern_pos + i)) / 2;
 719                         ag->num_avgs++;
 720                         /* Time to send averaged data? */
 721                         if (devc->avg_samples > 0 &&
 722                             ag->num_avgs >= devc->avg_samples)
 723                                 goto do_send;
 724                 }
 725
 726                 if (devc->avg_samples == 0) {
 727                         /* We're averaging all the samples, so wait with
 728                          * sending until the very end.
 729                          */
 730                         *analog_sent = ag->num_avgs;
 731                         return;
 732                 }
 733
 734 do_send:
 735                 ag->packet.data = &ag->avg_val;
 736                 ag->packet.num_samples = 1;
 737
 738                 sr_session_send(sdi, &packet);
 739                 *analog_sent = ag->num_avgs;
 740
 741                 ag->num_avgs = 0;
 742                 ag->avg_val = 0.0f;
 743         }
 744 }
 745
 746 /* Callback handling data */
 747 static int prepare_data(int fd, int revents, void *cb_data)
 748 {
 749         struct sr_dev_inst *sdi;
 750         struct dev_context *devc;
 751         struct sr_datafeed_packet packet;
 752         struct sr_datafeed_logic logic;
 753         struct analog_gen *ag;
 754         GHashTableIter iter;
 755         void *value;
 756         uint64_t logic_todo, analog_todo, expected_samplenum, analog_sent, sending_now;
 757         int64_t time, elapsed;
 758
 759         (void)fd;
 760         (void)revents;
 761
 762         sdi = cb_data;
 763         devc = sdi->priv;
 764         logic_todo = analog_todo = 0;
 765
 766         /* How many samples should we have sent by now? */
 767         time = g_get_monotonic_time();
 768         elapsed = time - devc->starttime;
 769         expected_samplenum = elapsed * devc->cur_samplerate / 1000000;
 770
 771         /* But never more than the limit, if there is one. */
 772         if (!devc->continuous)
 773                 expected_samplenum = MIN(expected_samplenum, devc->limit_samples);
 774
 775         /* Of those, how many do we still have to send? */
 776         if (devc->num_logic_channels)
 777                 logic_todo = expected_samplenum - devc->logic_counter;
 778         if (devc->num_analog_channels)
 779                 analog_todo = expected_samplenum - devc->analog_counter;
 780
 781         while (logic_todo || analog_todo) {
 782                 /* Logic */
 783                 if (logic_todo > 0) {
 784                         sending_now = MIN(logic_todo, 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_todo -= sending_now;
 793                         devc->logic_counter += sending_now;
 794                 }
 795
 796                 /* Analog, one channel at a time */
 797                 if (analog_todo > 0) {
 798                         analog_sent = 0;
 799
 800                         g_hash_table_iter_init(&iter, devc->ch_ag);
 801                         while (g_hash_table_iter_next(&iter, NULL, &value)) {
 802                                 send_analog_packet(value, sdi,
 803                                                    &analog_sent, analog_todo);
 804                         }
 805                         analog_todo -= analog_sent;
 806                         devc->analog_counter += analog_sent;
 807                 }
 808         }
 809
 810         if (!devc->continuous
 811                         && (!devc->num_logic_channels || devc->logic_counter >= devc->limit_samples)
 812                         && (!devc->num_analog_channels || devc->analog_counter >= devc->limit_samples)) {
 813                 /* If we're averaging everything - now is the time to send data */
 814                 if (devc->avg_samples == 0) {
 815                         g_hash_table_iter_init(&iter, devc->ch_ag);
 816                         while (g_hash_table_iter_next(&iter, NULL, &value)) {
 817                                 ag = value;
 818                                 packet.type = SR_DF_ANALOG;
 819                                 packet.payload = &ag->packet;
 820                                 ag->packet.data = &ag->avg_val;
 821                                 ag->packet.num_samples = 1;
 822                                 sr_session_send(sdi, &packet);
 823                         }
 824                 }
 825
 826                 sr_dbg("Requested number of samples reached.");
 827                 dev_acquisition_stop(sdi, cb_data);
 828                 return TRUE;
 829         }
 830
 831         return TRUE;
 832 }
 833
 834 static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
 835 {
 836         struct dev_context *devc;
 837         GHashTableIter iter;
 838         void *value;
 839
 840         (void)cb_data;
 841
 842         if (sdi->status != SR_ST_ACTIVE)
 843                 return SR_ERR_DEV_CLOSED;
 844
 845         devc = sdi->priv;
 846         devc->continuous = !devc->limit_samples;
 847         devc->logic_counter = devc->analog_counter = 0;
 848
 849         /*
 850          * Setting two channels connected by a pipe is a remnant from when the
 851          * demo driver generated data in a thread, and collected and sent the
 852          * data in the main program loop.
 853          * They are kept here because it provides a convenient way of setting
 854          * up a timeout-based polling mechanism.
 855          */
 856         if (pipe(devc->pipe_fds)) {
 857                 sr_err("%s: pipe() failed", __func__);
 858                 return SR_ERR;
 859         }
 860
 861         g_hash_table_iter_init(&iter, devc->ch_ag);
 862         while (g_hash_table_iter_next(&iter, NULL, &value))
 863                 generate_analog_pattern(value, devc->cur_samplerate);
 864
 865         devc->channel = g_io_channel_unix_new(devc->pipe_fds[0]);
 866         g_io_channel_set_flags(devc->channel, G_IO_FLAG_NONBLOCK, NULL);
 867
 868         /* Set channel encoding to binary (default is UTF-8). */
 869         g_io_channel_set_encoding(devc->channel, NULL, NULL);
 870
 871         /* Make channels unbuffered. */
 872         g_io_channel_set_buffered(devc->channel, FALSE);
 873
 874         sr_session_source_add_channel(sdi->session, devc->channel,
 875                         G_IO_IN | G_IO_ERR, 40, prepare_data, (void *)sdi);
 876
 877         /* Send header packet to the session bus. */
 878         std_session_send_df_header(sdi, LOG_PREFIX);
 879
 880         /* We use this timestamp to decide how many more samples to send. */
 881         devc->starttime = g_get_monotonic_time();
 882
 883         return SR_OK;
 884 }
 885
 886 static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
 887 {
 888         struct dev_context *devc;
 889         struct sr_datafeed_packet packet;
 890
 891         (void)cb_data;
 892
 893         devc = sdi->priv;
 894         sr_dbg("Stopping acquisition.");
 895
 896         sr_session_source_remove_channel(sdi->session, devc->channel);
 897         g_io_channel_shutdown(devc->channel, FALSE, NULL);
 898         g_io_channel_unref(devc->channel);
 899         devc->channel = NULL;
 900
 901         /* Send last packet. */
 902         packet.type = SR_DF_END;
 903         sr_session_send(sdi, &packet);
 904
 905         return SR_OK;
 906 }
 907
 908 SR_PRIV struct sr_dev_driver demo_driver_info = {
 909         .name = "demo",
 910         .longname = "Demo driver and pattern generator",
 911         .api_version = 1,
 912         .init = init,
 913         .cleanup = cleanup,
 914         .scan = scan,
 915         .dev_list = dev_list,
 916         .dev_clear = NULL,
 917         .config_get = config_get,
 918         .config_set = config_set,
 919         .config_list = config_list,
 920         .dev_open = dev_open,
 921         .dev_close = dev_close,
 922         .dev_acquisition_start = dev_acquisition_start,
 923         .dev_acquisition_stop = dev_acquisition_stop,
 924         .priv = NULL,
 925 };