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 int cleanup(void)
 383 {
 384         return std_dev_clear(di, NULL);
 385 }
 386
 387 static int config_get(int id, GVariant **data, const struct sr_dev_inst *sdi,
 388                 const struct sr_channel_group *cg)
 389 {
 390         struct dev_context *devc;
 391         struct sr_channel *ch;
 392         struct analog_gen *ag;
 393         int pattern;
 394
 395         if (!sdi)
 396                 return SR_ERR_ARG;
 397
 398         devc = sdi->priv;
 399         switch (id) {
 400         case SR_CONF_SAMPLERATE:
 401                 *data = g_variant_new_uint64(devc->cur_samplerate);
 402                 break;
 403         case SR_CONF_LIMIT_SAMPLES:
 404                 *data = g_variant_new_uint64(devc->limit_samples);
 405                 break;
 406         case SR_CONF_LIMIT_MSEC:
 407                 *data = g_variant_new_uint64(devc->limit_msec);
 408                 break;
 409         case SR_CONF_PATTERN_MODE:
 410                 if (!cg)
 411                         return SR_ERR_CHANNEL_GROUP;
 412                 ch = cg->channels->data;
 413                 if (ch->type == SR_CHANNEL_LOGIC) {
 414                         pattern = devc->logic_pattern;
 415                         *data = g_variant_new_string(logic_pattern_str[pattern]);
 416                 } else if (ch->type == SR_CHANNEL_ANALOG) {
 417                         ag = cg->priv;
 418                         pattern = ag->pattern;
 419                         *data = g_variant_new_string(analog_pattern_str[pattern]);
 420                 } else
 421                         return SR_ERR_BUG;
 422                 break;
 423         case SR_CONF_NUM_LOGIC_CHANNELS:
 424                 *data = g_variant_new_int32(devc->num_logic_channels);
 425                 break;
 426         case SR_CONF_NUM_ANALOG_CHANNELS:
 427                 *data = g_variant_new_int32(devc->num_analog_channels);
 428                 break;
 429         default:
 430                 return SR_ERR_NA;
 431         }
 432
 433         return SR_OK;
 434 }
 435
 436 static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi,
 437                 const struct sr_channel_group *cg)
 438 {
 439         struct dev_context *devc;
 440         struct analog_gen *ag;
 441         struct sr_channel *ch;
 442         int pattern, ret;
 443         unsigned int i;
 444         const char *stropt;
 445
 446         devc = sdi->priv;
 447
 448         if (sdi->status != SR_ST_ACTIVE)
 449                 return SR_ERR_DEV_CLOSED;
 450
 451         ret = SR_OK;
 452         switch (id) {
 453         case SR_CONF_SAMPLERATE:
 454                 devc->cur_samplerate = g_variant_get_uint64(data);
 455                 sr_dbg("Setting samplerate to %" PRIu64, devc->cur_samplerate);
 456                 break;
 457         case SR_CONF_LIMIT_SAMPLES:
 458                 devc->limit_msec = 0;
 459                 devc->limit_samples = g_variant_get_uint64(data);
 460                 sr_dbg("Setting sample limit to %" PRIu64, devc->limit_samples);
 461                 break;
 462         case SR_CONF_LIMIT_MSEC:
 463                 devc->limit_msec = g_variant_get_uint64(data);
 464                 devc->limit_samples = 0;
 465                 sr_dbg("Setting time limit to %" PRIu64"ms", devc->limit_msec);
 466                 break;
 467         case SR_CONF_PATTERN_MODE:
 468                 if (!cg)
 469                         return SR_ERR_CHANNEL_GROUP;
 470                 stropt = g_variant_get_string(data, NULL);
 471                 ch = cg->channels->data;
 472                 pattern = -1;
 473                 if (ch->type == SR_CHANNEL_LOGIC) {
 474                         for (i = 0; i < ARRAY_SIZE(logic_pattern_str); i++) {
 475                                 if (!strcmp(stropt, logic_pattern_str[i])) {
 476                                         pattern = i;
 477                                         break;
 478                                 }
 479                         }
 480                         if (pattern == -1)
 481                                 return SR_ERR_ARG;
 482                         devc->logic_pattern = pattern;
 483
 484                         /* Might as well do this now, these are static. */
 485                         if (pattern == PATTERN_ALL_LOW)
 486                                 memset(devc->logic_data, 0x00, LOGIC_BUFSIZE);
 487                         else if (pattern == PATTERN_ALL_HIGH)
 488                                 memset(devc->logic_data, 0xff, LOGIC_BUFSIZE);
 489                         sr_dbg("Setting logic pattern to %s",
 490                                         logic_pattern_str[pattern]);
 491                 } else if (ch->type == SR_CHANNEL_ANALOG) {
 492                         for (i = 0; i < ARRAY_SIZE(analog_pattern_str); i++) {
 493                                 if (!strcmp(stropt, analog_pattern_str[i])) {
 494                                         pattern = i;
 495                                         break;
 496                                 }
 497                         }
 498                         if (pattern == -1)
 499                                 return SR_ERR_ARG;
 500                         sr_dbg("Setting analog pattern for channel group %s to %s",
 501                                         cg->name, analog_pattern_str[pattern]);
 502                         ag = cg->priv;
 503                         ag->pattern = pattern;
 504                 } else
 505                         return SR_ERR_BUG;
 506                 break;
 507         default:
 508                 ret = SR_ERR_NA;
 509         }
 510
 511         return ret;
 512 }
 513
 514 static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi,
 515                 const struct sr_channel_group *cg)
 516 {
 517         struct sr_channel *ch;
 518         GVariant *gvar;
 519         GVariantBuilder gvb;
 520
 521         (void)sdi;
 522
 523         if (key == SR_CONF_SCAN_OPTIONS) {
 524                 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
 525                                 scanopts, ARRAY_SIZE(scanopts), sizeof(int32_t));
 526                 return SR_OK;
 527         }
 528
 529         if (!sdi)
 530                 return SR_ERR_ARG;
 531
 532         if (!cg) {
 533                 switch (key) {
 534                 case SR_CONF_DEVICE_OPTIONS:
 535                         *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
 536                                         devopts, ARRAY_SIZE(devopts), sizeof(int32_t));
 537                         break;
 538                 case SR_CONF_SAMPLERATE:
 539                         g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
 540                         gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates,
 541                                         ARRAY_SIZE(samplerates), sizeof(uint64_t));
 542                         g_variant_builder_add(&gvb, "{sv}", "samplerate-steps", gvar);
 543                         *data = g_variant_builder_end(&gvb);
 544                         break;
 545                 default:
 546                         return SR_ERR_NA;
 547                 }
 548         } else {
 549                 ch = cg->channels->data;
 550                 switch (key) {
 551                 case SR_CONF_DEVICE_OPTIONS:
 552                         *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
 553                                         devopts_cg, ARRAY_SIZE(devopts_cg), sizeof(int32_t));
 554                         break;
 555                 case SR_CONF_PATTERN_MODE:
 556                         if (ch->type == SR_CHANNEL_LOGIC)
 557                                 *data = g_variant_new_strv(logic_pattern_str,
 558                                                 ARRAY_SIZE(logic_pattern_str));
 559                         else if (ch->type == SR_CHANNEL_ANALOG)
 560                                 *data = g_variant_new_strv(analog_pattern_str,
 561                                                 ARRAY_SIZE(analog_pattern_str));
 562                         else
 563                                 return SR_ERR_BUG;
 564                         break;
 565                 default:
 566                         return SR_ERR_NA;
 567                 }
 568         }
 569
 570         return SR_OK;
 571 }
 572
 573 static void logic_generator(struct sr_dev_inst *sdi, uint64_t size)
 574 {
 575         struct dev_context *devc;
 576         uint64_t i, j;
 577         uint8_t pat;
 578
 579         devc = sdi->priv;
 580
 581         switch (devc->logic_pattern) {
 582         case PATTERN_SIGROK:
 583                 memset(devc->logic_data, 0x00, size);
 584                 for (i = 0; i < size; i += devc->logic_unitsize) {
 585                         for (j = 0; j < devc->logic_unitsize; j++) {
 586                                 pat = pattern_sigrok[(devc->step + j) % sizeof(pattern_sigrok)] >> 1;
 587                                 devc->logic_data[i + j] = ~pat;
 588                         }
 589                         devc->step++;
 590                 }
 591                 break;
 592         case PATTERN_RANDOM:
 593                 for (i = 0; i < size; i++)
 594                         devc->logic_data[i] = (uint8_t)(rand() & 0xff);
 595                 break;
 596         case PATTERN_INC:
 597                 for (i = 0; i < size; i++) {
 598                         for (j = 0; j < devc->logic_unitsize; j++) {
 599                                 devc->logic_data[i + j] = devc->step;
 600                         }
 601                         devc->step++;
 602                 }
 603                 break;
 604         case PATTERN_ALL_LOW:
 605         case PATTERN_ALL_HIGH:
 606                 /* These were set when the pattern mode was selected. */
 607                 break;
 608         default:
 609                 sr_err("Unknown pattern: %d.", devc->logic_pattern);
 610                 break;
 611         }
 612 }
 613
 614 /* Callback handling data */
 615 static int prepare_data(int fd, int revents, void *cb_data)
 616 {
 617         struct sr_dev_inst *sdi;
 618         struct dev_context *devc;
 619         struct sr_datafeed_packet packet;
 620         struct sr_datafeed_logic logic;
 621         struct sr_channel_group *cg;
 622         struct analog_gen *ag;
 623         GSList *l;
 624         uint64_t logic_todo, analog_todo, expected_samplenum, analog_sent, sending_now;
 625         int64_t time, elapsed;
 626
 627         (void)fd;
 628         (void)revents;
 629
 630         sdi = cb_data;
 631         devc = sdi->priv;
 632         logic_todo = analog_todo = 0;
 633
 634         /* How many samples should we have sent by now? */
 635         time = g_get_monotonic_time();
 636         elapsed = time - devc->starttime;
 637         expected_samplenum = elapsed * devc->cur_samplerate / 1000000;
 638
 639         /* But never more than the limit, if there is one. */
 640         if (!devc->continuous)
 641                 expected_samplenum = MIN(expected_samplenum, devc->limit_samples);
 642
 643         /* Of those, how many do we still have to send? */
 644         if (devc->num_logic_channels)
 645                 logic_todo = expected_samplenum - devc->logic_counter;
 646         if (devc->num_analog_channels)
 647                 analog_todo = expected_samplenum - devc->analog_counter;
 648
 649         while (logic_todo || analog_todo) {
 650                 /* Logic */
 651                 if (logic_todo > 0) {
 652                         sending_now = MIN(logic_todo, LOGIC_BUFSIZE / devc->logic_unitsize);
 653                         logic_generator(sdi, sending_now * devc->logic_unitsize);
 654                         packet.type = SR_DF_LOGIC;
 655                         packet.payload = &logic;
 656                         logic.length = sending_now * devc->logic_unitsize;
 657                         logic.unitsize = devc->logic_unitsize;
 658                         logic.data = devc->logic_data;
 659                         sr_session_send(sdi, &packet);
 660                         logic_todo -= sending_now;
 661                         devc->logic_counter += sending_now;
 662                 }
 663
 664                 /* Analog, one channel at a time */
 665                 if (analog_todo > 0) {
 666                         analog_sent = 0;
 667                         for (l = devc->analog_channel_groups; l; l = l->next) {
 668                                 cg = l->data;
 669                                 ag = cg->priv;
 670                                 packet.type = SR_DF_ANALOG;
 671                                 packet.payload = &ag->packet;
 672
 673                                 /* FIXME we should make sure we output a whole
 674                                  * period of data before we send out again the
 675                                  * beginning of our buffer. A ring buffer would
 676                                  * help here as well */
 677
 678                                 sending_now = MIN(analog_todo, ag->num_samples);
 679                                 ag->packet.num_samples = sending_now;
 680                                 sr_session_send(sdi, &packet);
 681
 682                                 /* Whichever channel group gets there first. */
 683                                 analog_sent = MAX(analog_sent, sending_now);
 684                         }
 685                         analog_todo -= analog_sent;
 686                         devc->analog_counter += analog_sent;
 687                 }
 688         }
 689
 690         if (!devc->continuous
 691                         && (!devc->num_logic_channels || devc->logic_counter >= devc->limit_samples)
 692                         && (!devc->num_analog_channels || devc->analog_counter >= devc->limit_samples)) {
 693                 sr_dbg("Requested number of samples reached.");
 694                 dev_acquisition_stop(sdi, cb_data);
 695                 return TRUE;
 696         }
 697
 698         return TRUE;
 699 }
 700
 701 static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
 702 {
 703         GSList *l;
 704         struct dev_context *devc;
 705
 706         (void)cb_data;
 707
 708         if (sdi->status != SR_ST_ACTIVE)
 709                 return SR_ERR_DEV_CLOSED;
 710
 711         devc = sdi->priv;
 712         devc->continuous = !devc->limit_samples;
 713         devc->logic_counter = devc->analog_counter = 0;
 714
 715         /*
 716          * Setting two channels connected by a pipe is a remnant from when the
 717          * demo driver generated data in a thread, and collected and sent the
 718          * data in the main program loop.
 719          * They are kept here because it provides a convenient way of setting
 720          * up a timeout-based polling mechanism.
 721          */
 722         if (pipe(devc->pipe_fds)) {
 723                 sr_err("%s: pipe() failed", __func__);
 724                 return SR_ERR;
 725         }
 726
 727         for (l = devc->analog_channel_groups; l; l = l->next)
 728                 generate_analog_pattern(l->data, devc->cur_samplerate);
 729
 730         devc->channel = g_io_channel_unix_new(devc->pipe_fds[0]);
 731         g_io_channel_set_flags(devc->channel, G_IO_FLAG_NONBLOCK, NULL);
 732
 733         /* Set channel encoding to binary (default is UTF-8). */
 734         g_io_channel_set_encoding(devc->channel, NULL, NULL);
 735
 736         /* Make channels unbuffered. */
 737         g_io_channel_set_buffered(devc->channel, FALSE);
 738
 739         sr_session_source_add_channel(sdi->session, devc->channel,
 740                         G_IO_IN | G_IO_ERR, 40, prepare_data, (void *)sdi);
 741
 742         /* Send header packet to the session bus. */
 743         std_session_send_df_header(sdi, LOG_PREFIX);
 744
 745         /* We use this timestamp to decide how many more samples to send. */
 746         devc->starttime = g_get_monotonic_time();
 747
 748         return SR_OK;
 749 }
 750
 751 static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
 752 {
 753         struct dev_context *devc;
 754         struct sr_datafeed_packet packet;
 755
 756         (void)cb_data;
 757
 758         devc = sdi->priv;
 759         sr_dbg("Stopping acquisition.");
 760
 761         sr_session_source_remove_channel(sdi->session, devc->channel);
 762         g_io_channel_shutdown(devc->channel, FALSE, NULL);
 763         g_io_channel_unref(devc->channel);
 764         devc->channel = NULL;
 765
 766         /* Send last packet. */
 767         packet.type = SR_DF_END;
 768         sr_session_send(sdi, &packet);
 769
 770         return SR_OK;
 771 }
 772
 773 SR_PRIV struct sr_dev_driver demo_driver_info = {
 774         .name = "demo",
 775         .longname = "Demo driver and pattern generator",
 776         .api_version = 1,
 777         .init = init,
 778         .cleanup = cleanup,
 779         .scan = scan,
 780         .dev_list = dev_list,
 781         .dev_clear = NULL,
 782         .config_get = config_get,
 783         .config_set = config_set,
 784         .config_list = config_list,
 785         .dev_open = dev_open,
 786         .dev_close = dev_close,
 787         .dev_acquisition_start = dev_acquisition_start,
 788         .dev_acquisition_stop = dev_acquisition_stop,
 789         .priv = NULL,
 790 };