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 #ifdef _WIN32
  27 #include <io.h>
  28 #include <fcntl.h>
  29 #define pipe(fds) _pipe(fds, 4096, _O_BINARY)
  30 #endif
  31 #include "libsigrok.h"
  32 #include "libsigrok-internal.h"
  33
  34 /* Message logging helpers with driver-specific prefix string. */
  35 #define DRIVER_LOG_DOMAIN "demo: "
  36 #define sr_log(l, s, args...) sr_log(l, DRIVER_LOG_DOMAIN s, ## args)
  37 #define sr_spew(s, args...) sr_spew(DRIVER_LOG_DOMAIN s, ## args)
  38 #define sr_dbg(s, args...) sr_dbg(DRIVER_LOG_DOMAIN s, ## args)
  39 #define sr_info(s, args...) sr_info(DRIVER_LOG_DOMAIN s, ## args)
  40 #define sr_warn(s, args...) sr_warn(DRIVER_LOG_DOMAIN s, ## args)
  41 #define sr_err(s, args...) sr_err(DRIVER_LOG_DOMAIN s, ## args)
  42
  43 /* TODO: Number of probes should be configurable. */
  44 #define NUM_PROBES             8
  45
  46 #define DEMONAME               "Demo device"
  47
  48 /* The size of chunks to send through the session bus. */
  49 /* TODO: Should be configurable. */
  50 #define BUFSIZE                4096
  51
  52 #define STR_PATTERN_SIGROK   "sigrok"
  53 #define STR_PATTERN_RANDOM   "random"
  54 #define STR_PATTERN_INC      "incremental"
  55 #define STR_PATTERN_ALL_LOW  "all-low"
  56 #define STR_PATTERN_ALL_HIGH "all-high"
  57
  58 /* Supported patterns which we can generate */
  59 enum {
  60         /**
  61          * Pattern which spells "sigrok" using '0's (with '1's as "background")
  62          * when displayed using the 'bits' output format.
  63          */
  64         PATTERN_SIGROK,
  65
  66         /** Pattern which consists of (pseudo-)random values on all probes. */
  67         PATTERN_RANDOM,
  68
  69         /**
  70          * Pattern which consists of incrementing numbers.
  71          * TODO: Better description.
  72          */
  73         PATTERN_INC,
  74
  75         /** Pattern where all probes have a low logic state. */
  76         PATTERN_ALL_LOW,
  77
  78         /** Pattern where all probes have a high logic state. */
  79         PATTERN_ALL_HIGH,
  80 };
  81
  82 /* Private, per-device-instance driver context. */
  83 struct dev_context {
  84         struct sr_dev_inst *sdi;
  85         int pipe_fds[2];
  86         GIOChannel *channel;
  87         uint64_t cur_samplerate;
  88         uint64_t limit_samples;
  89         uint64_t limit_msec;
  90         uint8_t sample_generator;
  91         uint64_t samples_counter;
  92         void *cb_data;
  93         int64_t starttime;
  94 };
  95
  96 static const int hwcaps[] = {
  97         SR_CONF_LOGIC_ANALYZER,
  98         SR_CONF_DEMO_DEV,
  99         SR_CONF_SAMPLERATE,
 100         SR_CONF_PATTERN_MODE,
 101         SR_CONF_LIMIT_SAMPLES,
 102         SR_CONF_LIMIT_MSEC,
 103         SR_CONF_CONTINUOUS,
 104 };
 105
 106 static const uint64_t samplerates[] = {
 107         SR_HZ(1),
 108         SR_GHZ(1),
 109         SR_HZ(1),
 110 };
 111
 112 static const char *pattern_strings[] = {
 113         "sigrok",
 114         "random",
 115         "incremental",
 116         "all-low",
 117         "all-high",
 118 };
 119
 120 /* We name the probes 0-7 on our demo driver. */
 121 static const char *probe_names[NUM_PROBES + 1] = {
 122         "0", "1", "2", "3", "4", "5", "6", "7",
 123         NULL,
 124 };
 125
 126 static uint8_t pattern_sigrok[] = {
 127         0x4c, 0x92, 0x92, 0x92, 0x64, 0x00, 0x00, 0x00,
 128         0x82, 0xfe, 0xfe, 0x82, 0x00, 0x00, 0x00, 0x00,
 129         0x7c, 0x82, 0x82, 0x92, 0x74, 0x00, 0x00, 0x00,
 130         0xfe, 0x12, 0x12, 0x32, 0xcc, 0x00, 0x00, 0x00,
 131         0x7c, 0x82, 0x82, 0x82, 0x7c, 0x00, 0x00, 0x00,
 132         0xfe, 0x10, 0x28, 0x44, 0x82, 0x00, 0x00, 0x00,
 133         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 134         0xbe, 0xbe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 135 };
 136
 137 /* Private, per-device-instance driver context. */
 138 /* TODO: struct context as with the other drivers. */
 139
 140 /* List of struct sr_dev_inst, maintained by dev_open()/dev_close(). */
 141 SR_PRIV struct sr_dev_driver demo_driver_info;
 142 static struct sr_dev_driver *di = &demo_driver_info;
 143
 144 static int hw_dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data);
 145
 146 static int clear_instances(void)
 147 {
 148         /* Nothing needed so far. */
 149
 150         return SR_OK;
 151 }
 152
 153 static int hw_init(struct sr_context *sr_ctx)
 154 {
 155         return std_hw_init(sr_ctx, di, DRIVER_LOG_DOMAIN);
 156 }
 157
 158 static GSList *hw_scan(GSList *options)
 159 {
 160         struct sr_dev_inst *sdi;
 161         struct sr_probe *probe;
 162         struct drv_context *drvc;
 163         struct dev_context *devc;
 164         GSList *devices;
 165         int i;
 166
 167         (void)options;
 168
 169         drvc = di->priv;
 170
 171         devices = NULL;
 172
 173         sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, DEMONAME, NULL, NULL);
 174         if (!sdi) {
 175                 sr_err("Device instance creation failed.");
 176                 return NULL;
 177         }
 178         sdi->driver = di;
 179
 180         for (i = 0; probe_names[i]; i++) {
 181                 if (!(probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE,
 182                                 probe_names[i])))
 183                         return NULL;
 184                 sdi->probes = g_slist_append(sdi->probes, probe);
 185         }
 186
 187         devices = g_slist_append(devices, sdi);
 188         drvc->instances = g_slist_append(drvc->instances, sdi);
 189
 190         if (!(devc = g_try_malloc(sizeof(struct dev_context)))) {
 191                 sr_err("Device context malloc failed.");
 192                 return NULL;
 193         }
 194
 195         devc->sdi = sdi;
 196         devc->cur_samplerate = SR_KHZ(200);
 197         devc->limit_samples = 0;
 198         devc->limit_msec = 0;
 199         devc->sample_generator = PATTERN_SIGROK;
 200
 201         sdi->priv = devc;
 202
 203         return devices;
 204 }
 205
 206 static GSList *hw_dev_list(void)
 207 {
 208         return ((struct drv_context *)(di->priv))->instances;
 209 }
 210
 211 static int hw_dev_open(struct sr_dev_inst *sdi)
 212 {
 213         (void)sdi;
 214
 215         sdi->status = SR_ST_ACTIVE;
 216
 217         return SR_OK;
 218 }
 219
 220 static int hw_dev_close(struct sr_dev_inst *sdi)
 221 {
 222         (void)sdi;
 223
 224     sdi->status = SR_ST_INACTIVE;
 225
 226         return SR_OK;
 227 }
 228
 229 static int hw_cleanup(void)
 230 {
 231         GSList *l;
 232         struct sr_dev_inst *sdi;
 233         struct drv_context *drvc;
 234         int ret = SR_OK;
 235
 236         if (!(drvc = di->priv))
 237                 return SR_OK;
 238
 239         /* Properly close and free all devices. */
 240         for (l = drvc->instances; l; l = l->next) {
 241                 if (!(sdi = l->data)) {
 242                         /* Log error, but continue cleaning up the rest. */
 243                         sr_err("%s: sdi was NULL, continuing", __func__);
 244                         ret = SR_ERR_BUG;
 245                         continue;
 246                 }
 247                 sr_dev_inst_free(sdi);
 248         }
 249         g_slist_free(drvc->instances);
 250         drvc->instances = NULL;
 251
 252         return ret;
 253 }
 254
 255 static int config_get(int id, GVariant **data, const struct sr_dev_inst *sdi)
 256 {
 257         struct dev_context *const devc = sdi->priv;
 258
 259         switch (id) {
 260         case SR_CONF_SAMPLERATE:
 261                 *data = g_variant_new_uint64(devc->cur_samplerate);
 262                 break;
 263         case SR_CONF_LIMIT_SAMPLES:
 264                 *data = g_variant_new_uint64(devc->limit_samples);
 265                 break;
 266         case SR_CONF_LIMIT_MSEC:
 267                 *data = g_variant_new_uint64(devc->limit_msec);
 268                 break;
 269         case SR_CONF_PATTERN_MODE:
 270                 switch (devc->sample_generator) {
 271                 case PATTERN_SIGROK:
 272                         *data = g_variant_new_string(STR_PATTERN_SIGROK);
 273                         break;
 274                 case PATTERN_RANDOM:
 275                         *data = g_variant_new_string(STR_PATTERN_RANDOM);
 276                         break;
 277                 case PATTERN_INC:
 278                         *data = g_variant_new_string(STR_PATTERN_INC);
 279                         break;
 280                 case PATTERN_ALL_LOW:
 281                         *data = g_variant_new_string(STR_PATTERN_ALL_LOW);
 282                         break;
 283                 case PATTERN_ALL_HIGH:
 284                         *data = g_variant_new_string(STR_PATTERN_ALL_HIGH);
 285                         break;
 286                 }
 287                 break;
 288         default:
 289                 return SR_ERR_NA;
 290         }
 291
 292         return SR_OK;
 293 }
 294
 295 static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi)
 296 {
 297         int ret;
 298         const char *stropt;
 299
 300         struct dev_context *const devc = sdi->priv;
 301
 302         if (sdi->status != SR_ST_ACTIVE)
 303                 return SR_ERR_DEV_CLOSED;
 304
 305         if (id == SR_CONF_SAMPLERATE) {
 306                 devc->cur_samplerate = g_variant_get_uint64(data);
 307                 sr_dbg("%s: setting samplerate to %" PRIu64, __func__,
 308                        devc->cur_samplerate);
 309                 ret = SR_OK;
 310         } else if (id == SR_CONF_LIMIT_SAMPLES) {
 311                 devc->limit_msec = 0;
 312                 devc->limit_samples = g_variant_get_uint64(data);
 313                 sr_dbg("%s: setting limit_samples to %" PRIu64, __func__,
 314                        devc->limit_samples);
 315                 ret = SR_OK;
 316         } else if (id == SR_CONF_LIMIT_MSEC) {
 317                 devc->limit_msec = g_variant_get_uint64(data);
 318                 devc->limit_samples = 0;
 319                 sr_dbg("%s: setting limit_msec to %" PRIu64, __func__,
 320                        devc->limit_msec);
 321                 ret = SR_OK;
 322         } else if (id == SR_CONF_PATTERN_MODE) {
 323                 stropt = g_variant_get_string(data, NULL);
 324                 ret = SR_OK;
 325                 if (!strcmp(stropt, STR_PATTERN_SIGROK)) {
 326                         devc->sample_generator = PATTERN_SIGROK;
 327                 } else if (!strcmp(stropt, STR_PATTERN_RANDOM)) {
 328                         devc->sample_generator = PATTERN_RANDOM;
 329                 } else if (!strcmp(stropt, STR_PATTERN_INC)) {
 330                         devc->sample_generator = PATTERN_INC;
 331                 } else if (!strcmp(stropt, STR_PATTERN_ALL_LOW)) {
 332                         devc->sample_generator = PATTERN_ALL_LOW;
 333                 } else if (!strcmp(stropt, STR_PATTERN_ALL_HIGH)) {
 334                         devc->sample_generator = PATTERN_ALL_HIGH;
 335                 } else {
 336                         ret = SR_ERR;
 337                 }
 338                 sr_dbg("%s: setting pattern to %d",
 339                         __func__, devc->sample_generator);
 340         } else {
 341                 ret = SR_ERR_NA;
 342         }
 343
 344         return ret;
 345 }
 346
 347 static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi)
 348 {
 349         GVariant *gvar;
 350         GVariantBuilder gvb;
 351
 352         (void)sdi;
 353
 354         switch (key) {
 355         case SR_CONF_DEVICE_OPTIONS:
 356                 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
 357                                 hwcaps, ARRAY_SIZE(hwcaps), sizeof(int32_t));
 358                 break;
 359         case SR_CONF_SAMPLERATE:
 360                 g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
 361                 gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates,
 362                                 ARRAY_SIZE(samplerates), sizeof(uint64_t));
 363                 g_variant_builder_add(&gvb, "{sv}", "samplerate-steps", gvar);
 364                 *data = g_variant_builder_end(&gvb);
 365                 break;
 366         case SR_CONF_PATTERN_MODE:
 367                 *data = g_variant_new_strv(pattern_strings, ARRAY_SIZE(pattern_strings));
 368                 break;
 369         default:
 370                 return SR_ERR_NA;
 371         }
 372
 373         return SR_OK;
 374 }
 375
 376 static void samples_generator(uint8_t *buf, uint64_t size,
 377                               struct dev_context *devc)
 378 {
 379         static uint64_t p = 0;
 380         uint64_t i;
 381
 382         /* TODO: Needed? */
 383         memset(buf, 0, size);
 384
 385         switch (devc->sample_generator) {
 386         case PATTERN_SIGROK: /* sigrok pattern */
 387                 for (i = 0; i < size; i++) {
 388                         *(buf + i) = ~(pattern_sigrok[
 389                                 p++ % sizeof(pattern_sigrok)] >> 1);
 390                 }
 391                 break;
 392         case PATTERN_RANDOM: /* Random */
 393                 for (i = 0; i < size; i++)
 394                         *(buf + i) = (uint8_t)(rand() & 0xff);
 395                 break;
 396         case PATTERN_INC: /* Simple increment */
 397                 for (i = 0; i < size; i++)
 398                         *(buf + i) = p++;
 399                 break;
 400         case PATTERN_ALL_LOW: /* All probes are low */
 401                 memset(buf, 0x00, size);
 402                 break;
 403         case PATTERN_ALL_HIGH: /* All probes are high */
 404                 memset(buf, 0xff, size);
 405                 break;
 406         default:
 407                 sr_err("Unknown pattern: %d.", devc->sample_generator);
 408                 break;
 409         }
 410 }
 411
 412 /* Callback handling data */
 413 static int receive_data(int fd, int revents, void *cb_data)
 414 {
 415         struct dev_context *devc = cb_data;
 416         struct sr_datafeed_packet packet;
 417         struct sr_datafeed_logic logic;
 418         uint8_t buf[BUFSIZE];
 419         static uint64_t samples_to_send, expected_samplenum, sending_now;
 420         int64_t time, elapsed;
 421
 422         (void)fd;
 423         (void)revents;
 424
 425         /* How many "virtual" samples should we have collected by now? */
 426         time = g_get_monotonic_time();
 427         elapsed = time - devc->starttime;
 428         expected_samplenum = elapsed * devc->cur_samplerate / 1000000;
 429         /* Of those, how many do we still have to send? */
 430         samples_to_send = expected_samplenum - devc->samples_counter;
 431
 432         if (devc->limit_samples) {
 433                 samples_to_send = MIN(samples_to_send,
 434                                  devc->limit_samples - devc->samples_counter);
 435         }
 436
 437         while (samples_to_send > 0) {
 438                 sending_now = MIN(samples_to_send, sizeof(buf));
 439                 samples_to_send -= sending_now;
 440                 samples_generator(buf, sending_now, devc);
 441
 442                 packet.type = SR_DF_LOGIC;
 443                 packet.payload = &logic;
 444                 logic.length = sending_now;
 445                 logic.unitsize = 1;
 446                 logic.data = buf;
 447                 sr_session_send(devc->cb_data, &packet);
 448                 devc->samples_counter += sending_now;
 449         }
 450
 451         if (devc->limit_samples &&
 452                 devc->samples_counter >= devc->limit_samples) {
 453                 sr_info("Requested number of samples reached.");
 454                 hw_dev_acquisition_stop(devc->sdi, cb_data);
 455                 return TRUE;
 456         }
 457
 458         return TRUE;
 459 }
 460
 461 static int hw_dev_acquisition_start(const struct sr_dev_inst *sdi,
 462                 void *cb_data)
 463 {
 464         struct dev_context *const devc = sdi->priv;
 465
 466         if (sdi->status != SR_ST_ACTIVE)
 467                 return SR_ERR_DEV_CLOSED;
 468
 469         devc->cb_data = cb_data;
 470         devc->samples_counter = 0;
 471
 472         /*
 473          * Setting two channels connected by a pipe is a remnant from when the
 474          * demo driver generated data in a thread, and collected and sent the
 475          * data in the main program loop.
 476          * They are kept here because it provides a convenient way of setting
 477          * up a timeout-based polling mechanism.
 478          */
 479         if (pipe(devc->pipe_fds)) {
 480                 /* TODO: Better error message. */
 481                 sr_err("%s: pipe() failed", __func__);
 482                 return SR_ERR;
 483         }
 484
 485         devc->channel = g_io_channel_unix_new(devc->pipe_fds[0]);
 486
 487         g_io_channel_set_flags(devc->channel, G_IO_FLAG_NONBLOCK, NULL);
 488
 489         /* Set channel encoding to binary (default is UTF-8). */
 490         g_io_channel_set_encoding(devc->channel, NULL, NULL);
 491
 492         /* Make channels to unbuffered. */
 493         g_io_channel_set_buffered(devc->channel, FALSE);
 494
 495         sr_session_source_add_channel(devc->channel, G_IO_IN | G_IO_ERR,
 496                     40, receive_data, devc);
 497
 498         /* Send header packet to the session bus. */
 499         std_session_send_df_header(cb_data, DRIVER_LOG_DOMAIN);
 500
 501         /* We use this timestamp to decide how many more samples to send. */
 502         devc->starttime = g_get_monotonic_time();
 503
 504         return SR_OK;
 505 }
 506
 507 static int hw_dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
 508 {
 509         struct dev_context *const devc = sdi->priv;
 510         struct sr_datafeed_packet packet;
 511
 512         (void)cb_data;
 513
 514         sr_dbg("Stopping aquisition.");
 515
 516         sr_session_source_remove_channel(devc->channel);
 517         g_io_channel_shutdown(devc->channel, FALSE, NULL);
 518         g_io_channel_unref(devc->channel);
 519         devc->channel = NULL;
 520
 521         /* Send last packet. */
 522         packet.type = SR_DF_END;
 523         sr_session_send(devc->cb_data, &packet);
 524
 525         return SR_OK;
 526 }
 527
 528 SR_PRIV struct sr_dev_driver demo_driver_info = {
 529         .name = "demo",
 530         .longname = "Demo driver and pattern generator",
 531         .api_version = 1,
 532         .init = hw_init,
 533         .cleanup = hw_cleanup,
 534         .scan = hw_scan,
 535         .dev_list = hw_dev_list,
 536         .dev_clear = clear_instances,
 537         .config_get = config_get,
 538         .config_set = config_set,
 539         .config_list = config_list,
 540         .dev_open = hw_dev_open,
 541         .dev_close = hw_dev_close,
 542         .dev_acquisition_start = hw_dev_acquisition_start,
 543         .dev_acquisition_stop = hw_dev_acquisition_stop,
 544         .priv = NULL,
 545 };