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 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 pattern_data[ANALOG_BUFSIZE];
 103         unsigned int num_samples;
 104         struct sr_datafeed_analog packet;
 105 };
 106
 107 /* Private, per-device-instance driver context. */
 108 struct dev_context {
 109         int pipe_fds[2];
 110         GIOChannel *channel;
 111         uint64_t cur_samplerate;
 112         gboolean continuous;
 113         uint64_t limit_samples;
 114         uint64_t limit_msec;
 115         uint64_t logic_counter;
 116         uint64_t analog_counter;
 117         int64_t starttime;
 118         uint64_t step;
 119         /* Logic */
 120         int32_t num_logic_channels;
 121         unsigned int logic_unitsize;
 122         /* There is only ever one logic channel group, so its pattern goes here. */
 123         uint8_t logic_pattern;
 124         unsigned char logic_data[LOGIC_BUFSIZE];
 125         /* Analog */
 126         int32_t num_analog_channels;
 127         GSList *analog_channel_groups;
 128 };
 129
 130 static const int32_t scanopts[] = {
 131         SR_CONF_NUM_LOGIC_CHANNELS,
 132         SR_CONF_NUM_ANALOG_CHANNELS,
 133 };
 134
 135 static const int devopts[] = {
 136         SR_CONF_LOGIC_ANALYZER,
 137         SR_CONF_DEMO_DEV,
 138         SR_CONF_SAMPLERATE,
 139         SR_CONF_CONTINUOUS,
 140         SR_CONF_LIMIT_SAMPLES,
 141         SR_CONF_LIMIT_MSEC,
 142 };
 143
 144 static const int devopts_cg[] = {
 145         SR_CONF_PATTERN_MODE,
 146 };
 147
 148 static const uint64_t samplerates[] = {
 149         SR_HZ(1),
 150         SR_GHZ(1),
 151         SR_HZ(1),
 152 };
 153
 154 static uint8_t pattern_sigrok[] = {
 155         0x4c, 0x92, 0x92, 0x92, 0x64, 0x00, 0x00, 0x00,
 156         0x82, 0xfe, 0xfe, 0x82, 0x00, 0x00, 0x00, 0x00,
 157         0x7c, 0x82, 0x82, 0x92, 0x74, 0x00, 0x00, 0x00,
 158         0xfe, 0x12, 0x12, 0x32, 0xcc, 0x00, 0x00, 0x00,
 159         0x7c, 0x82, 0x82, 0x82, 0x7c, 0x00, 0x00, 0x00,
 160         0xfe, 0x10, 0x28, 0x44, 0x82, 0x00, 0x00, 0x00,
 161         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 162         0xbe, 0xbe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 163 };
 164
 165 SR_PRIV struct sr_dev_driver demo_driver_info;
 166 static struct sr_dev_driver *di = &demo_driver_info;
 167
 168 static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data);
 169
 170
 171 static int init(struct sr_context *sr_ctx)
 172 {
 173         return std_init(sr_ctx, di, LOG_PREFIX);
 174 }
 175
 176 static void generate_analog_pattern(const struct sr_channel_group *cg, uint64_t sample_rate)
 177 {
 178         struct analog_gen *ag;
 179         double t, frequency;
 180         float value;
 181         unsigned int num_samples, i;
 182         int last_end;
 183
 184         ag = cg->priv;
 185         num_samples = ANALOG_BUFSIZE / sizeof(float);
 186
 187         sr_dbg("Generating %s pattern for channel group %s",
 188                analog_pattern_str[ag->pattern], cg->name);
 189
 190         switch (ag->pattern) {
 191         case PATTERN_SQUARE:
 192                 value = ANALOG_AMPLITUDE;
 193                 last_end = 0;
 194                 for (i = 0; i < num_samples; i++) {
 195                         if (i % 5 == 0)
 196                                 value = -value;
 197                         if (i % 10 == 0)
 198                                 last_end = i - 1;
 199                         ag->pattern_data[i] = value;
 200                 }
 201                 ag->num_samples = last_end;
 202                 break;
 203
 204         case PATTERN_SINE:
 205                 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
 206
 207                 /* Make sure the number of samples we put out is an integer
 208                  * multiple of our period size */
 209                 /* FIXME we actually need only one period. A ringbuffer would be
 210                  * usefull here.*/
 211                 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
 212                         num_samples--;
 213
 214                 for (i = 0; i < num_samples; i++) {
 215                         t = (double) i / (double) sample_rate;
 216                         ag->pattern_data[i] = ANALOG_AMPLITUDE *
 217                                                 sin(2 * M_PI * frequency * t);
 218                 }
 219
 220                 ag->num_samples = num_samples;
 221                 break;
 222
 223         case PATTERN_TRIANGLE:
 224                 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
 225
 226                 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
 227                         num_samples--;
 228
 229                 for (i = 0; i < num_samples; i++) {
 230                         t = (double) i / (double) sample_rate;
 231                         ag->pattern_data[i] = (2 * ANALOG_AMPLITUDE / M_PI) *
 232                                                 asin(sin(2 * M_PI * frequency * t));
 233                 }
 234
 235                 ag->num_samples = num_samples;
 236                 break;
 237
 238         case PATTERN_SAWTOOTH:
 239                 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
 240
 241                 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
 242                         num_samples--;
 243
 244                 for (i = 0; i < num_samples; i++) {
 245                         t = (double) i / (double) sample_rate;
 246                         ag->pattern_data[i] = 2 * ANALOG_AMPLITUDE *
 247                                                 ((t * frequency) - floor(0.5f + t * frequency));
 248                 }
 249
 250                 ag->num_samples = num_samples;
 251                 break;
 252         }
 253 }
 254
 255 static GSList *scan(GSList *options)
 256 {
 257         struct drv_context *drvc;
 258         struct dev_context *devc;
 259         struct sr_dev_inst *sdi;
 260         struct sr_channel *ch;
 261         struct sr_channel_group *cg;
 262         struct sr_config *src;
 263         struct analog_gen *ag;
 264         GSList *devices, *l;
 265         int num_logic_channels, num_analog_channels, pattern, i;
 266         char channel_name[16];
 267
 268         drvc = di->priv;
 269
 270         num_logic_channels = DEFAULT_NUM_LOGIC_CHANNELS;
 271         num_analog_channels = DEFAULT_NUM_ANALOG_CHANNELS;
 272         for (l = options; l; l = l->next) {
 273                 src = l->data;
 274                 switch (src->key) {
 275                 case SR_CONF_NUM_LOGIC_CHANNELS:
 276                         num_logic_channels = g_variant_get_int32(src->data);
 277                         break;
 278                 case SR_CONF_NUM_ANALOG_CHANNELS:
 279                         num_analog_channels = g_variant_get_int32(src->data);
 280                         break;
 281                 }
 282         }
 283
 284         devices = NULL;
 285         sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, "Demo device", NULL, NULL);
 286         if (!sdi) {
 287                 sr_err("Device instance creation failed.");
 288                 return NULL;
 289         }
 290         sdi->driver = di;
 291
 292         if (!(devc = g_try_malloc(sizeof(struct dev_context)))) {
 293                 sr_err("Device context malloc failed.");
 294                 return NULL;
 295         }
 296         devc->cur_samplerate = SR_KHZ(200);
 297         devc->limit_samples = 0;
 298         devc->limit_msec = 0;
 299         devc->step = 0;
 300         devc->continuous = FALSE;
 301         devc->num_logic_channels = num_logic_channels;
 302         devc->logic_unitsize = (devc->num_logic_channels + 7) / 8;
 303         devc->logic_pattern = PATTERN_SIGROK;
 304         devc->num_analog_channels = num_analog_channels;
 305         devc->analog_channel_groups = NULL;
 306
 307         /* Logic channels, all in one channel group. */
 308         if (!(cg = g_try_malloc(sizeof(struct sr_channel_group))))
 309                 return NULL;
 310         cg->name = g_strdup("Logic");
 311         cg->channels = NULL;
 312         cg->priv = NULL;
 313         for (i = 0; i < num_logic_channels; i++) {
 314                 sprintf(channel_name, "D%d", i);
 315                 if (!(ch = sr_channel_new(i, SR_CHANNEL_LOGIC, TRUE, channel_name)))
 316                         return NULL;
 317                 sdi->channels = g_slist_append(sdi->channels, ch);
 318                 cg->channels = g_slist_append(cg->channels, ch);
 319         }
 320         sdi->channel_groups = g_slist_append(NULL, cg);
 321
 322         /* Analog channels, channel groups and pattern generators. */
 323
 324         pattern = 0;
 325         for (i = 0; i < num_analog_channels; i++) {
 326                 sprintf(channel_name, "A%d", i);
 327                 if (!(ch = sr_channel_new(i + num_logic_channels,
 328                                 SR_CHANNEL_ANALOG, TRUE, channel_name)))
 329                         return NULL;
 330                 sdi->channels = g_slist_append(sdi->channels, ch);
 331
 332                 /* Every analog channel gets its own channel group. */
 333                 if (!(cg = g_try_malloc(sizeof(struct sr_channel_group))))
 334                         return NULL;
 335                 cg->name = g_strdup(channel_name);
 336                 cg->channels = g_slist_append(NULL, ch);
 337
 338                 /* Every channel group gets a generator struct. */
 339                 if (!(ag = g_try_malloc(sizeof(struct analog_gen))))
 340                         return NULL;
 341                 ag->packet.channels = cg->channels;
 342                 ag->packet.mq = 0;
 343                 ag->packet.mqflags = 0;
 344                 ag->packet.unit = SR_UNIT_VOLT;
 345                 ag->packet.data = ag->pattern_data;
 346                 ag->pattern = pattern;
 347                 cg->priv = ag;
 348
 349                 sdi->channel_groups = g_slist_append(sdi->channel_groups, cg);
 350                 devc->analog_channel_groups = g_slist_append(devc->analog_channel_groups, cg);
 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         struct sr_channel_group *cg;
 386         GSList *l;
 387
 388         devc = priv;
 389         for (l = devc->analog_channel_groups; l; l = l->next) {
 390                 cg = l->data;
 391                 /* Analog generators. */
 392                 g_free(cg->priv);
 393         }
 394         g_slist_free(devc->analog_channel_groups);
 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(int id, 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 (id) {
 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                 ch = cg->channels->data;
 429                 if (ch->type == SR_CHANNEL_LOGIC) {
 430                         pattern = devc->logic_pattern;
 431                         *data = g_variant_new_string(logic_pattern_str[pattern]);
 432                 } else if (ch->type == SR_CHANNEL_ANALOG) {
 433                         ag = cg->priv;
 434                         pattern = ag->pattern;
 435                         *data = g_variant_new_string(analog_pattern_str[pattern]);
 436                 } else
 437                         return SR_ERR_BUG;
 438                 break;
 439         case SR_CONF_NUM_LOGIC_CHANNELS:
 440                 *data = g_variant_new_int32(devc->num_logic_channels);
 441                 break;
 442         case SR_CONF_NUM_ANALOG_CHANNELS:
 443                 *data = g_variant_new_int32(devc->num_analog_channels);
 444                 break;
 445         default:
 446                 return SR_ERR_NA;
 447         }
 448
 449         return SR_OK;
 450 }
 451
 452 static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi,
 453                 const struct sr_channel_group *cg)
 454 {
 455         struct dev_context *devc;
 456         struct analog_gen *ag;
 457         struct sr_channel *ch;
 458         int pattern, ret;
 459         unsigned int i;
 460         const char *stropt;
 461
 462         devc = sdi->priv;
 463
 464         if (sdi->status != SR_ST_ACTIVE)
 465                 return SR_ERR_DEV_CLOSED;
 466
 467         ret = SR_OK;
 468         switch (id) {
 469         case SR_CONF_SAMPLERATE:
 470                 devc->cur_samplerate = g_variant_get_uint64(data);
 471                 sr_dbg("Setting samplerate to %" PRIu64, devc->cur_samplerate);
 472                 break;
 473         case SR_CONF_LIMIT_SAMPLES:
 474                 devc->limit_msec = 0;
 475                 devc->limit_samples = g_variant_get_uint64(data);
 476                 sr_dbg("Setting sample limit to %" PRIu64, devc->limit_samples);
 477                 break;
 478         case SR_CONF_LIMIT_MSEC:
 479                 devc->limit_msec = g_variant_get_uint64(data);
 480                 devc->limit_samples = 0;
 481                 sr_dbg("Setting time limit to %" PRIu64"ms", devc->limit_msec);
 482                 break;
 483         case SR_CONF_PATTERN_MODE:
 484                 if (!cg)
 485                         return SR_ERR_CHANNEL_GROUP;
 486                 stropt = g_variant_get_string(data, NULL);
 487                 ch = cg->channels->data;
 488                 pattern = -1;
 489                 if (ch->type == SR_CHANNEL_LOGIC) {
 490                         for (i = 0; i < ARRAY_SIZE(logic_pattern_str); i++) {
 491                                 if (!strcmp(stropt, logic_pattern_str[i])) {
 492                                         pattern = i;
 493                                         break;
 494                                 }
 495                         }
 496                         if (pattern == -1)
 497                                 return SR_ERR_ARG;
 498                         devc->logic_pattern = pattern;
 499
 500                         /* Might as well do this now, these are static. */
 501                         if (pattern == PATTERN_ALL_LOW)
 502                                 memset(devc->logic_data, 0x00, LOGIC_BUFSIZE);
 503                         else if (pattern == PATTERN_ALL_HIGH)
 504                                 memset(devc->logic_data, 0xff, LOGIC_BUFSIZE);
 505                         sr_dbg("Setting logic pattern to %s",
 506                                         logic_pattern_str[pattern]);
 507                 } else if (ch->type == SR_CHANNEL_ANALOG) {
 508                         for (i = 0; i < ARRAY_SIZE(analog_pattern_str); i++) {
 509                                 if (!strcmp(stropt, analog_pattern_str[i])) {
 510                                         pattern = i;
 511                                         break;
 512                                 }
 513                         }
 514                         if (pattern == -1)
 515                                 return SR_ERR_ARG;
 516                         sr_dbg("Setting analog pattern for channel group %s to %s",
 517                                         cg->name, analog_pattern_str[pattern]);
 518                         ag = cg->priv;
 519                         ag->pattern = pattern;
 520                 } else
 521                         return SR_ERR_BUG;
 522                 break;
 523         default:
 524                 ret = SR_ERR_NA;
 525         }
 526
 527         return ret;
 528 }
 529
 530 static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi,
 531                 const struct sr_channel_group *cg)
 532 {
 533         struct sr_channel *ch;
 534         GVariant *gvar;
 535         GVariantBuilder gvb;
 536
 537         (void)sdi;
 538
 539         if (key == SR_CONF_SCAN_OPTIONS) {
 540                 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
 541                                 scanopts, ARRAY_SIZE(scanopts), sizeof(int32_t));
 542                 return SR_OK;
 543         }
 544
 545         if (!sdi)
 546                 return SR_ERR_ARG;
 547
 548         if (!cg) {
 549                 switch (key) {
 550                 case SR_CONF_DEVICE_OPTIONS:
 551                         *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
 552                                         devopts, ARRAY_SIZE(devopts), sizeof(int32_t));
 553                         break;
 554                 case SR_CONF_SAMPLERATE:
 555                         g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
 556                         gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates,
 557                                         ARRAY_SIZE(samplerates), sizeof(uint64_t));
 558                         g_variant_builder_add(&gvb, "{sv}", "samplerate-steps", gvar);
 559                         *data = g_variant_builder_end(&gvb);
 560                         break;
 561                 default:
 562                         return SR_ERR_NA;
 563                 }
 564         } else {
 565                 ch = cg->channels->data;
 566                 switch (key) {
 567                 case SR_CONF_DEVICE_OPTIONS:
 568                         *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
 569                                         devopts_cg, ARRAY_SIZE(devopts_cg), sizeof(int32_t));
 570                         break;
 571                 case SR_CONF_PATTERN_MODE:
 572                         if (ch->type == SR_CHANNEL_LOGIC)
 573                                 *data = g_variant_new_strv(logic_pattern_str,
 574                                                 ARRAY_SIZE(logic_pattern_str));
 575                         else if (ch->type == SR_CHANNEL_ANALOG)
 576                                 *data = g_variant_new_strv(analog_pattern_str,
 577                                                 ARRAY_SIZE(analog_pattern_str));
 578                         else
 579                                 return SR_ERR_BUG;
 580                         break;
 581                 default:
 582                         return SR_ERR_NA;
 583                 }
 584         }
 585
 586         return SR_OK;
 587 }
 588
 589 static void logic_generator(struct sr_dev_inst *sdi, uint64_t size)
 590 {
 591         struct dev_context *devc;
 592         uint64_t i, j;
 593         uint8_t pat;
 594
 595         devc = sdi->priv;
 596
 597         switch (devc->logic_pattern) {
 598         case PATTERN_SIGROK:
 599                 memset(devc->logic_data, 0x00, size);
 600                 for (i = 0; i < size; i += devc->logic_unitsize) {
 601                         for (j = 0; j < devc->logic_unitsize; j++) {
 602                                 pat = pattern_sigrok[(devc->step + j) % sizeof(pattern_sigrok)] >> 1;
 603                                 devc->logic_data[i + j] = ~pat;
 604                         }
 605                         devc->step++;
 606                 }
 607                 break;
 608         case PATTERN_RANDOM:
 609                 for (i = 0; i < size; i++)
 610                         devc->logic_data[i] = (uint8_t)(rand() & 0xff);
 611                 break;
 612         case PATTERN_INC:
 613                 for (i = 0; i < size; i++) {
 614                         for (j = 0; j < devc->logic_unitsize; j++) {
 615                                 devc->logic_data[i + j] = devc->step;
 616                         }
 617                         devc->step++;
 618                 }
 619                 break;
 620         case PATTERN_ALL_LOW:
 621         case PATTERN_ALL_HIGH:
 622                 /* These were set when the pattern mode was selected. */
 623                 break;
 624         default:
 625                 sr_err("Unknown pattern: %d.", devc->logic_pattern);
 626                 break;
 627         }
 628 }
 629
 630 /* Callback handling data */
 631 static int prepare_data(int fd, int revents, void *cb_data)
 632 {
 633         struct sr_dev_inst *sdi;
 634         struct dev_context *devc;
 635         struct sr_datafeed_packet packet;
 636         struct sr_datafeed_logic logic;
 637         struct sr_channel_group *cg;
 638         struct analog_gen *ag;
 639         GSList *l;
 640         uint64_t logic_todo, analog_todo, expected_samplenum, analog_sent, sending_now;
 641         int64_t time, elapsed;
 642
 643         (void)fd;
 644         (void)revents;
 645
 646         sdi = cb_data;
 647         devc = sdi->priv;
 648         logic_todo = analog_todo = 0;
 649
 650         /* How many samples should we have sent by now? */
 651         time = g_get_monotonic_time();
 652         elapsed = time - devc->starttime;
 653         expected_samplenum = elapsed * devc->cur_samplerate / 1000000;
 654
 655         /* But never more than the limit, if there is one. */
 656         if (!devc->continuous)
 657                 expected_samplenum = MIN(expected_samplenum, devc->limit_samples);
 658
 659         /* Of those, how many do we still have to send? */
 660         if (devc->num_logic_channels)
 661                 logic_todo = expected_samplenum - devc->logic_counter;
 662         if (devc->num_analog_channels)
 663                 analog_todo = expected_samplenum - devc->analog_counter;
 664
 665         while (logic_todo || analog_todo) {
 666                 /* Logic */
 667                 if (logic_todo > 0) {
 668                         sending_now = MIN(logic_todo, LOGIC_BUFSIZE / devc->logic_unitsize);
 669                         logic_generator(sdi, sending_now * devc->logic_unitsize);
 670                         packet.type = SR_DF_LOGIC;
 671                         packet.payload = &logic;
 672                         logic.length = sending_now * devc->logic_unitsize;
 673                         logic.unitsize = devc->logic_unitsize;
 674                         logic.data = devc->logic_data;
 675                         sr_session_send(sdi, &packet);
 676                         logic_todo -= sending_now;
 677                         devc->logic_counter += sending_now;
 678                 }
 679
 680                 /* Analog, one channel at a time */
 681                 if (analog_todo > 0) {
 682                         analog_sent = 0;
 683                         for (l = devc->analog_channel_groups; l; l = l->next) {
 684                                 cg = l->data;
 685                                 ag = cg->priv;
 686                                 packet.type = SR_DF_ANALOG;
 687                                 packet.payload = &ag->packet;
 688
 689                                 /* FIXME we should make sure we output a whole
 690                                  * period of data before we send out again the
 691                                  * beginning of our buffer. A ring buffer would
 692                                  * help here as well */
 693
 694                                 sending_now = MIN(analog_todo, ag->num_samples);
 695                                 ag->packet.num_samples = sending_now;
 696                                 sr_session_send(sdi, &packet);
 697
 698                                 /* Whichever channel group gets there first. */
 699                                 analog_sent = MAX(analog_sent, sending_now);
 700                         }
 701                         analog_todo -= analog_sent;
 702                         devc->analog_counter += analog_sent;
 703                 }
 704         }
 705
 706         if (!devc->continuous
 707                         && (!devc->num_logic_channels || devc->logic_counter >= devc->limit_samples)
 708                         && (!devc->num_analog_channels || devc->analog_counter >= devc->limit_samples)) {
 709                 sr_dbg("Requested number of samples reached.");
 710                 dev_acquisition_stop(sdi, cb_data);
 711                 return TRUE;
 712         }
 713
 714         return TRUE;
 715 }
 716
 717 static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
 718 {
 719         GSList *l;
 720         struct dev_context *devc;
 721
 722         (void)cb_data;
 723
 724         if (sdi->status != SR_ST_ACTIVE)
 725                 return SR_ERR_DEV_CLOSED;
 726
 727         devc = sdi->priv;
 728         devc->continuous = !devc->limit_samples;
 729         devc->logic_counter = devc->analog_counter = 0;
 730
 731         /*
 732          * Setting two channels connected by a pipe is a remnant from when the
 733          * demo driver generated data in a thread, and collected and sent the
 734          * data in the main program loop.
 735          * They are kept here because it provides a convenient way of setting
 736          * up a timeout-based polling mechanism.
 737          */
 738         if (pipe(devc->pipe_fds)) {
 739                 sr_err("%s: pipe() failed", __func__);
 740                 return SR_ERR;
 741         }
 742
 743         for (l = devc->analog_channel_groups; l; l = l->next)
 744                 generate_analog_pattern(l->data, devc->cur_samplerate);
 745
 746         devc->channel = g_io_channel_unix_new(devc->pipe_fds[0]);
 747         g_io_channel_set_flags(devc->channel, G_IO_FLAG_NONBLOCK, NULL);
 748
 749         /* Set channel encoding to binary (default is UTF-8). */
 750         g_io_channel_set_encoding(devc->channel, NULL, NULL);
 751
 752         /* Make channels unbuffered. */
 753         g_io_channel_set_buffered(devc->channel, FALSE);
 754
 755         sr_session_source_add_channel(sdi->session, devc->channel,
 756                         G_IO_IN | G_IO_ERR, 40, prepare_data, (void *)sdi);
 757
 758         /* Send header packet to the session bus. */
 759         std_session_send_df_header(sdi, LOG_PREFIX);
 760
 761         /* We use this timestamp to decide how many more samples to send. */
 762         devc->starttime = g_get_monotonic_time();
 763
 764         return SR_OK;
 765 }
 766
 767 static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
 768 {
 769         struct dev_context *devc;
 770         struct sr_datafeed_packet packet;
 771
 772         (void)cb_data;
 773
 774         devc = sdi->priv;
 775         sr_dbg("Stopping acquisition.");
 776
 777         sr_session_source_remove_channel(sdi->session, devc->channel);
 778         g_io_channel_shutdown(devc->channel, FALSE, NULL);
 779         g_io_channel_unref(devc->channel);
 780         devc->channel = NULL;
 781
 782         /* Send last packet. */
 783         packet.type = SR_DF_END;
 784         sr_session_send(sdi, &packet);
 785
 786         return SR_OK;
 787 }
 788
 789 SR_PRIV struct sr_dev_driver demo_driver_info = {
 790         .name = "demo",
 791         .longname = "Demo driver and pattern generator",
 792         .api_version = 1,
 793         .init = init,
 794         .cleanup = cleanup,
 795         .scan = scan,
 796         .dev_list = dev_list,
 797         .dev_clear = NULL,
 798         .config_get = config_get,
 799         .config_set = config_set,
 800         .config_list = config_list,
 801         .dev_open = dev_open,
 802         .dev_close = dev_close,
 803         .dev_acquisition_start = dev_acquisition_start,
 804         .dev_acquisition_stop = dev_acquisition_stop,
 805         .priv = NULL,
 806 };