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