hardware/demo/demo.c

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