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