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