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         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_channels;
 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_channels;
 126         GSList *analog_channel_groups;
 127 };
 128
 129 static const int32_t scanopts[] = {
 130         SR_CONF_NUM_LOGIC_CHANNELS,
 131         SR_CONF_NUM_ANALOG_CHANNELS,
 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 *cg, 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 = cg->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], cg->name);
 187
 188         switch (ag->pattern) {
 189         case PATTERN_SQUARE:
 190                 value = ANALOG_AMPLITUDE;
 191                 last_end = 0;
 192                 for (i = 0; i < num_samples; i++) {
 193                         if (i % 5 == 0)
 194                                 value = -value;
 195                         if (i % 10 == 0)
 196                                 last_end = i - 1;
 197                         ag->pattern_data[i] = value;
 198                 }
 199                 ag->num_samples = last_end;
 200                 break;
 201
 202         case PATTERN_SINE:
 203                 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
 204
 205                 /* Make sure the number of samples we put out is an integer
 206                  * multiple of our period size */
 207                 /* FIXME we actually need only one period. A ringbuffer would be
 208                  * usefull here.*/
 209                 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
 210                         num_samples--;
 211
 212                 for (i = 0; i < num_samples; i++) {
 213                         t = (double) i / (double) sample_rate;
 214                         ag->pattern_data[i] = ANALOG_AMPLITUDE *
 215                                                 sin(2 * M_PI * frequency * t);
 216                 }
 217
 218                 ag->num_samples = num_samples;
 219                 break;
 220
 221         case PATTERN_TRIANGLE:
 222                 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
 223
 224                 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
 225                         num_samples--;
 226
 227                 for (i = 0; i < num_samples; i++) {
 228                         t = (double) i / (double) sample_rate;
 229                         ag->pattern_data[i] = (2 * ANALOG_AMPLITUDE / M_PI) *
 230                                                 asin(sin(2 * M_PI * frequency * t));
 231                 }
 232
 233                 ag->num_samples = num_samples;
 234                 break;
 235
 236         case PATTERN_SAWTOOTH:
 237                 frequency = (double) sample_rate / ANALOG_SAMPLES_PER_PERIOD;
 238
 239                 while (num_samples % ANALOG_SAMPLES_PER_PERIOD != 0)
 240                         num_samples--;
 241
 242                 for (i = 0; i < num_samples; i++) {
 243                         t = (double) i / (double) sample_rate;
 244                         ag->pattern_data[i] = 2 * ANALOG_AMPLITUDE *
 245                                                 ((t * frequency) - floor(0.5f + t * frequency));
 246                 }
 247
 248                 ag->num_samples = num_samples;
 249                 break;
 250         }
 251 }
 252
 253 static GSList *scan(GSList *options)
 254 {
 255         struct drv_context *drvc;
 256         struct dev_context *devc;
 257         struct sr_dev_inst *sdi;
 258         struct sr_channel *ch;
 259         struct sr_channel_group *cg;
 260         struct sr_config *src;
 261         struct analog_gen *ag;
 262         GSList *devices, *l;
 263         int num_logic_channels, num_analog_channels, pattern, i;
 264         char channel_name[16];
 265
 266         drvc = di->priv;
 267
 268         num_logic_channels = DEFAULT_NUM_LOGIC_CHANNELS;
 269         num_analog_channels = DEFAULT_NUM_ANALOG_CHANNELS;
 270         for (l = options; l; l = l->next) {
 271                 src = l->data;
 272                 switch (src->key) {
 273                 case SR_CONF_NUM_LOGIC_CHANNELS:
 274                         num_logic_channels = g_variant_get_int32(src->data);
 275                         break;
 276                 case SR_CONF_NUM_ANALOG_CHANNELS:
 277                         num_analog_channels = g_variant_get_int32(src->data);
 278                         break;
 279                 }
 280         }
 281
 282         devices = NULL;
 283         sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, "Demo device", NULL, NULL);
 284         if (!sdi) {
 285                 sr_err("Device instance creation failed.");
 286                 return NULL;
 287         }
 288         sdi->driver = di;
 289
 290         if (!(devc = g_try_malloc(sizeof(struct dev_context)))) {
 291                 sr_err("Device context malloc failed.");
 292                 return NULL;
 293         }
 294         devc->cur_samplerate = SR_KHZ(200);
 295         devc->limit_samples = 0;
 296         devc->limit_msec = 0;
 297         devc->step = 0;
 298         devc->num_logic_channels = num_logic_channels;
 299         devc->logic_unitsize = (devc->num_logic_channels + 7) / 8;
 300         devc->logic_pattern = PATTERN_SIGROK;
 301         devc->num_analog_channels = num_analog_channels;
 302         devc->analog_channel_groups = NULL;
 303
 304         /* Logic channels, all in one channel group. */
 305         if (!(cg = g_try_malloc(sizeof(struct sr_channel_group))))
 306                 return NULL;
 307         cg->name = g_strdup("Logic");
 308         cg->channels = NULL;
 309         cg->priv = NULL;
 310         for (i = 0; i < num_logic_channels; i++) {
 311                 sprintf(channel_name, "D%d", i);
 312                 if (!(ch = sr_channel_new(i, SR_CHANNEL_LOGIC, TRUE, channel_name)))
 313                         return NULL;
 314                 sdi->channels = g_slist_append(sdi->channels, ch);
 315                 cg->channels = g_slist_append(cg->channels, ch);
 316         }
 317         sdi->channel_groups = g_slist_append(NULL, cg);
 318
 319         /* Analog channels, channel groups and pattern generators. */
 320
 321         pattern = 0;
 322         for (i = 0; i < num_analog_channels; i++) {
 323                 sprintf(channel_name, "A%d", i);
 324                 if (!(ch = sr_channel_new(i + num_logic_channels,
 325                                 SR_CHANNEL_ANALOG, TRUE, channel_name)))
 326                         return NULL;
 327                 sdi->channels = g_slist_append(sdi->channels, ch);
 328
 329                 /* Every analog channel gets its own channel group. */
 330                 if (!(cg = g_try_malloc(sizeof(struct sr_channel_group))))
 331                         return NULL;
 332                 cg->name = g_strdup(channel_name);
 333                 cg->channels = g_slist_append(NULL, ch);
 334
 335                 /* Every channel group gets a generator struct. */
 336                 if (!(ag = g_try_malloc(sizeof(struct analog_gen))))
 337                         return NULL;
 338                 ag->packet.channels = cg->channels;
 339                 ag->packet.mq = 0;
 340                 ag->packet.mqflags = 0;
 341                 ag->packet.unit = SR_UNIT_VOLT;
 342                 ag->packet.data = ag->pattern_data;
 343                 ag->pattern = pattern;
 344                 cg->priv = ag;
 345
 346                 sdi->channel_groups = g_slist_append(sdi->channel_groups, cg);
 347                 devc->analog_channel_groups = g_slist_append(devc->analog_channel_groups, cg);
 348
 349                 if (++pattern == ARRAY_SIZE(analog_pattern_str))
 350                         pattern = 0;
 351         }
 352
 353         sdi->priv = devc;
 354         devices = g_slist_append(devices, sdi);
 355         drvc->instances = g_slist_append(drvc->instances, sdi);
 356
 357         return devices;
 358 }
 359
 360 static GSList *dev_list(void)
 361 {
 362         return ((struct drv_context *)(di->priv))->instances;
 363 }
 364
 365 static int dev_open(struct sr_dev_inst *sdi)
 366 {
 367         sdi->status = SR_ST_ACTIVE;
 368
 369         return SR_OK;
 370 }
 371
 372 static int dev_close(struct sr_dev_inst *sdi)
 373 {
 374         sdi->status = SR_ST_INACTIVE;
 375
 376         return SR_OK;
 377 }
 378
 379 static int cleanup(void)
 380 {
 381         return std_dev_clear(di, NULL);
 382 }
 383
 384 static int config_get(int id, GVariant **data, const struct sr_dev_inst *sdi,
 385                 const struct sr_channel_group *cg)
 386 {
 387         struct dev_context *devc;
 388         struct sr_channel *ch;
 389         struct analog_gen *ag;
 390         int pattern;
 391
 392         if (!sdi)
 393                 return SR_ERR_ARG;
 394
 395         devc = sdi->priv;
 396         switch (id) {
 397         case SR_CONF_SAMPLERATE:
 398                 *data = g_variant_new_uint64(devc->cur_samplerate);
 399                 break;
 400         case SR_CONF_LIMIT_SAMPLES:
 401                 *data = g_variant_new_uint64(devc->limit_samples);
 402                 break;
 403         case SR_CONF_LIMIT_MSEC:
 404                 *data = g_variant_new_uint64(devc->limit_msec);
 405                 break;
 406         case SR_CONF_PATTERN_MODE:
 407                 if (!cg)
 408                         return SR_ERR_CHANNEL_GROUP;
 409                 ch = cg->channels->data;
 410                 if (ch->type == SR_CHANNEL_LOGIC) {
 411                         pattern = devc->logic_pattern;
 412                         *data = g_variant_new_string(logic_pattern_str[pattern]);
 413                 } else if (ch->type == SR_CHANNEL_ANALOG) {
 414                         ag = cg->priv;
 415                         pattern = ag->pattern;
 416                         *data = g_variant_new_string(analog_pattern_str[pattern]);
 417                 } else
 418                         return SR_ERR_BUG;
 419                 break;
 420         case SR_CONF_NUM_LOGIC_CHANNELS:
 421                 *data = g_variant_new_int32(devc->num_logic_channels);
 422                 break;
 423         case SR_CONF_NUM_ANALOG_CHANNELS:
 424                 *data = g_variant_new_int32(devc->num_analog_channels);
 425                 break;
 426         default:
 427                 return SR_ERR_NA;
 428         }
 429
 430         return SR_OK;
 431 }
 432
 433 static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi,
 434                 const struct sr_channel_group *cg)
 435 {
 436         struct dev_context *devc;
 437         struct analog_gen *ag;
 438         struct sr_channel *ch;
 439         int pattern, ret;
 440         unsigned int i;
 441         const char *stropt;
 442
 443         devc = sdi->priv;
 444
 445         if (sdi->status != SR_ST_ACTIVE)
 446                 return SR_ERR_DEV_CLOSED;
 447
 448         ret = SR_OK;
 449         switch (id) {
 450         case SR_CONF_SAMPLERATE:
 451                 devc->cur_samplerate = g_variant_get_uint64(data);
 452                 sr_dbg("Setting samplerate to %" PRIu64, devc->cur_samplerate);
 453                 break;
 454         case SR_CONF_LIMIT_SAMPLES:
 455                 devc->limit_msec = 0;
 456                 devc->limit_samples = g_variant_get_uint64(data);
 457                 sr_dbg("Setting sample limit to %" PRIu64, devc->limit_samples);
 458                 break;
 459         case SR_CONF_LIMIT_MSEC:
 460                 devc->limit_msec = g_variant_get_uint64(data);
 461                 devc->limit_samples = 0;
 462                 sr_dbg("Setting time limit to %" PRIu64"ms", devc->limit_msec);
 463                 break;
 464         case SR_CONF_PATTERN_MODE:
 465                 if (!cg)
 466                         return SR_ERR_CHANNEL_GROUP;
 467                 stropt = g_variant_get_string(data, NULL);
 468                 ch = cg->channels->data;
 469                 pattern = -1;
 470                 if (ch->type == SR_CHANNEL_LOGIC) {
 471                         for (i = 0; i < ARRAY_SIZE(logic_pattern_str); i++) {
 472                                 if (!strcmp(stropt, logic_pattern_str[i])) {
 473                                         pattern = i;
 474                                         break;
 475                                 }
 476                         }
 477                         if (pattern == -1)
 478                                 return SR_ERR_ARG;
 479                         devc->logic_pattern = pattern;
 480
 481                         /* Might as well do this now, these are static. */
 482                         if (pattern == PATTERN_ALL_LOW)
 483                                 memset(devc->logic_data, 0x00, LOGIC_BUFSIZE);
 484                         else if (pattern == PATTERN_ALL_HIGH)
 485                                 memset(devc->logic_data, 0xff, LOGIC_BUFSIZE);
 486                         sr_dbg("Setting logic pattern to %s",
 487                                         logic_pattern_str[pattern]);
 488                 } else if (ch->type == SR_CHANNEL_ANALOG) {
 489                         for (i = 0; i < ARRAY_SIZE(analog_pattern_str); i++) {
 490                                 if (!strcmp(stropt, analog_pattern_str[i])) {
 491                                         pattern = i;
 492                                         break;
 493                                 }
 494                         }
 495                         if (pattern == -1)
 496                                 return SR_ERR_ARG;
 497                         sr_dbg("Setting analog pattern for channel group %s to %s",
 498                                         cg->name, analog_pattern_str[pattern]);
 499                         ag = cg->priv;
 500                         ag->pattern = pattern;
 501                 } else
 502                         return SR_ERR_BUG;
 503                 break;
 504         default:
 505                 ret = SR_ERR_NA;
 506         }
 507
 508         return ret;
 509 }
 510
 511 static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi,
 512                 const struct sr_channel_group *cg)
 513 {
 514         struct sr_channel *ch;
 515         GVariant *gvar;
 516         GVariantBuilder gvb;
 517
 518         (void)sdi;
 519
 520         if (key == SR_CONF_SCAN_OPTIONS) {
 521                 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
 522                                 scanopts, ARRAY_SIZE(scanopts), sizeof(int32_t));
 523                 return SR_OK;
 524         }
 525
 526         if (!sdi)
 527                 return SR_ERR_ARG;
 528
 529         if (!cg) {
 530                 switch (key) {
 531                 case SR_CONF_DEVICE_OPTIONS:
 532                         *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
 533                                         devopts, ARRAY_SIZE(devopts), sizeof(int32_t));
 534                         break;
 535                 case SR_CONF_SAMPLERATE:
 536                         g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
 537                         gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates,
 538                                         ARRAY_SIZE(samplerates), sizeof(uint64_t));
 539                         g_variant_builder_add(&gvb, "{sv}", "samplerate-steps", gvar);
 540                         *data = g_variant_builder_end(&gvb);
 541                         break;
 542                 default:
 543                         return SR_ERR_NA;
 544                 }
 545         } else {
 546                 ch = cg->channels->data;
 547                 switch (key) {
 548                 case SR_CONF_DEVICE_OPTIONS:
 549                         *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
 550                                         devopts_cg, ARRAY_SIZE(devopts_cg), sizeof(int32_t));
 551                         break;
 552                 case SR_CONF_PATTERN_MODE:
 553                         if (ch->type == SR_CHANNEL_LOGIC)
 554                                 *data = g_variant_new_strv(logic_pattern_str,
 555                                                 ARRAY_SIZE(logic_pattern_str));
 556                         else if (ch->type == SR_CHANNEL_ANALOG)
 557                                 *data = g_variant_new_strv(analog_pattern_str,
 558                                                 ARRAY_SIZE(analog_pattern_str));
 559                         else
 560                                 return SR_ERR_BUG;
 561                         break;
 562                 default:
 563                         return SR_ERR_NA;
 564                 }
 565         }
 566
 567         return SR_OK;
 568 }
 569
 570 static void logic_generator(struct sr_dev_inst *sdi, uint64_t size)
 571 {
 572         struct dev_context *devc;
 573         uint64_t i, j;
 574         uint8_t pat;
 575
 576         devc = sdi->priv;
 577
 578         switch (devc->logic_pattern) {
 579         case PATTERN_SIGROK:
 580                 memset(devc->logic_data, 0x00, size);
 581                 for (i = 0; i < size; i += devc->logic_unitsize) {
 582                         for (j = 0; j < devc->logic_unitsize; j++) {
 583                                 pat = pattern_sigrok[(devc->step + j) % sizeof(pattern_sigrok)] >> 1;
 584                                 devc->logic_data[i + j] = ~pat;
 585                         }
 586                         devc->step++;
 587                 }
 588                 break;
 589         case PATTERN_RANDOM:
 590                 for (i = 0; i < size; i++)
 591                         devc->logic_data[i] = (uint8_t)(rand() & 0xff);
 592                 break;
 593         case PATTERN_INC:
 594                 for (i = 0; i < size; i++) {
 595                         for (j = 0; j < devc->logic_unitsize; j++) {
 596                                 devc->logic_data[i + j] = devc->step;
 597                         }
 598                         devc->step++;
 599                 }
 600                 break;
 601         case PATTERN_ALL_LOW:
 602         case PATTERN_ALL_HIGH:
 603                 /* These were set when the pattern mode was selected. */
 604                 break;
 605         default:
 606                 sr_err("Unknown pattern: %d.", devc->logic_pattern);
 607                 break;
 608         }
 609 }
 610
 611 /* Callback handling data */
 612 static int prepare_data(int fd, int revents, void *cb_data)
 613 {
 614         struct sr_dev_inst *sdi;
 615         struct dev_context *devc;
 616         struct sr_datafeed_packet packet;
 617         struct sr_datafeed_logic logic;
 618         struct sr_channel_group *cg;
 619         struct analog_gen *ag;
 620         GSList *l;
 621         uint64_t logic_todo, analog_todo, expected_samplenum, analog_samples, sending_now;
 622         int64_t time, elapsed;
 623
 624         (void)fd;
 625         (void)revents;
 626
 627         sdi = cb_data;
 628         devc = sdi->priv;
 629
 630         /* How many "virtual" samples should we have collected by now? */
 631         time = g_get_monotonic_time();
 632         elapsed = time - devc->starttime;
 633         expected_samplenum = elapsed * devc->cur_samplerate / 1000000;
 634
 635         /* Of those, how many do we still have to send? */
 636         logic_todo = MIN(expected_samplenum, devc->limit_samples) - devc->logic_counter;
 637         analog_todo = MIN(expected_samplenum, devc->limit_samples) - devc->analog_counter;
 638
 639         while (logic_todo || analog_todo) {
 640                 /* Logic */
 641                 if (devc->num_logic_channels > 0 && logic_todo > 0) {
 642                         sending_now = MIN(logic_todo,
 643                                         LOGIC_BUFSIZE / devc->logic_unitsize);
 644                         logic_generator(sdi, sending_now * devc->logic_unitsize);
 645                         packet.type = SR_DF_LOGIC;
 646                         packet.payload = &logic;
 647                         logic.length = sending_now * devc->logic_unitsize;
 648                         logic.unitsize = devc->logic_unitsize;
 649                         logic.data = devc->logic_data;
 650                         sr_session_send(sdi, &packet);
 651                         logic_todo -= sending_now;
 652                         devc->logic_counter += sending_now;
 653                 }
 654
 655                 /* Analog, one channel at a time */
 656                 if (devc->num_analog_channels > 0 && analog_todo > 0) {
 657                         sending_now = 0;
 658                         for (l = devc->analog_channel_groups; l; l = l->next) {
 659                                 cg = l->data;
 660                                 ag = cg->priv;
 661                                 packet.type = SR_DF_ANALOG;
 662                                 packet.payload = &ag->packet;
 663
 664                                 /* FIXME we should make sure we output a whole
 665                                  * period of data before we send out again the
 666                                  * beginning of our buffer. A ring buffer would
 667                                  * help here as well */
 668
 669                                 analog_samples = MIN(analog_todo, ag->num_samples);
 670                                 /* Whichever channel group gets there first. */
 671                                 sending_now = MAX(sending_now, analog_samples);
 672                                 ag->packet.num_samples = analog_samples;
 673                                 sr_session_send(sdi, &packet);
 674                         }
 675                         analog_todo -= sending_now;
 676                         devc->analog_counter += sending_now;
 677                 }
 678         }
 679
 680         if (devc->logic_counter >= devc->limit_samples &&
 681                         devc->analog_counter >= devc->limit_samples) {
 682                 sr_dbg("Requested number of samples reached.");
 683                 dev_acquisition_stop(sdi, cb_data);
 684                 return TRUE;
 685         }
 686
 687         return TRUE;
 688 }
 689
 690 static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
 691 {
 692         GSList *l;
 693         struct dev_context *devc;
 694
 695         (void)cb_data;
 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(sdi->session, 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(sdi, 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(sdi->session, 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 };