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         drvc->sr_ctx = sr_ctx;
 158         di->priv = drvc;
 159
 160         return SR_OK;
 161 }
 162
 163 static GSList *hw_scan(GSList *options)
 164 {
 165         struct sr_dev_inst *sdi;
 166         struct sr_probe *probe;
 167         struct drv_context *drvc;
 168         GSList *devices;
 169         int i;
 170
 171         (void)options;
 172
 173         drvc = di->priv;
 174         devices = NULL;
 175
 176         sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, DEMONAME, NULL, NULL);
 177         if (!sdi) {
 178                 sr_err("%s: sr_dev_inst_new failed", __func__);
 179                 return 0;
 180         }
 181         sdi->driver = di;
 182
 183         for (i = 0; probe_names[i]; i++) {
 184                 if (!(probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE,
 185                                 probe_names[i])))
 186                         return NULL;
 187                 sdi->probes = g_slist_append(sdi->probes, probe);
 188         }
 189
 190         devices = g_slist_append(devices, sdi);
 191         drvc->instances = g_slist_append(drvc->instances, sdi);
 192
 193         return devices;
 194 }
 195
 196 static GSList *hw_dev_list(void)
 197 {
 198         struct drv_context *drvc;
 199
 200         drvc = di->priv;
 201
 202         return drvc->instances;
 203 }
 204
 205 static int hw_dev_open(struct sr_dev_inst *sdi)
 206 {
 207         (void)sdi;
 208
 209         /* Nothing needed so far. */
 210
 211         return SR_OK;
 212 }
 213
 214 static int hw_dev_close(struct sr_dev_inst *sdi)
 215 {
 216         (void)sdi;
 217
 218         /* Nothing needed so far. */
 219
 220         return SR_OK;
 221 }
 222
 223 static int hw_cleanup(void)
 224 {
 225         /* Nothing needed so far. */
 226         return SR_OK;
 227 }
 228
 229 static int config_get(int id, const void **data, const struct sr_dev_inst *sdi)
 230 {
 231         (void)sdi;
 232
 233         switch (id) {
 234         case SR_DI_HWCAPS:
 235                 *data = hwcaps;
 236                 break;
 237         case SR_DI_SAMPLERATES:
 238                 *data = &samplerates;
 239                 break;
 240         case SR_DI_CUR_SAMPLERATE:
 241                 *data = &cur_samplerate;
 242                 break;
 243         case SR_DI_PATTERNS:
 244                 *data = &pattern_strings;
 245                 break;
 246         default:
 247                 return SR_ERR_ARG;
 248         }
 249
 250         return SR_OK;
 251 }
 252
 253 static int config_set(int id, const void *value, const struct sr_dev_inst *sdi)
 254 {
 255         int ret;
 256         const char *stropt;
 257
 258         (void)sdi;
 259
 260         if (id == SR_CONF_SAMPLERATE) {
 261                 cur_samplerate = *(const uint64_t *)value;
 262                 sr_dbg("%s: setting samplerate to %" PRIu64, __func__,
 263                        cur_samplerate);
 264                 ret = SR_OK;
 265         } else if (id == SR_CONF_LIMIT_SAMPLES) {
 266                 limit_msec = 0;
 267                 limit_samples = *(const uint64_t *)value;
 268                 sr_dbg("%s: setting limit_samples to %" PRIu64, __func__,
 269                        limit_samples);
 270                 ret = SR_OK;
 271         } else if (id == SR_CONF_LIMIT_MSEC) {
 272                 limit_msec = *(const uint64_t *)value;
 273                 limit_samples = 0;
 274                 sr_dbg("%s: setting limit_msec to %" PRIu64, __func__,
 275                        limit_msec);
 276                 ret = SR_OK;
 277         } else if (id == SR_CONF_PATTERN_MODE) {
 278                 stropt = value;
 279                 ret = SR_OK;
 280                 if (!strcmp(stropt, "sigrok")) {
 281                         default_pattern = PATTERN_SIGROK;
 282                 } else if (!strcmp(stropt, "random")) {
 283                         default_pattern = PATTERN_RANDOM;
 284                 } else if (!strcmp(stropt, "incremental")) {
 285                         default_pattern = PATTERN_INC;
 286                 } else if (!strcmp(stropt, "all-low")) {
 287                         default_pattern = PATTERN_ALL_LOW;
 288                 } else if (!strcmp(stropt, "all-high")) {
 289                         default_pattern = PATTERN_ALL_HIGH;
 290                 } else {
 291                         ret = SR_ERR;
 292                 }
 293                 sr_dbg("%s: setting pattern to %d", __func__, default_pattern);
 294         } else {
 295                 ret = SR_ERR;
 296         }
 297
 298         return ret;
 299 }
 300
 301 static int config_list(int key, const void **data, const struct sr_dev_inst *sdi)
 302 {
 303
 304         (void)sdi;
 305
 306         switch (key) {
 307         case SR_CONF_SAMPLERATE:
 308                 *data = &samplerates;
 309                 break;
 310         default:
 311                 return SR_ERR_ARG;
 312         }
 313
 314         return SR_OK;
 315 }
 316
 317 static void samples_generator(uint8_t *buf, uint64_t size,
 318                               struct dev_context *devc)
 319 {
 320         static uint64_t p = 0;
 321         uint64_t i;
 322
 323         /* TODO: Needed? */
 324         memset(buf, 0, size);
 325
 326         switch (devc->sample_generator) {
 327         case PATTERN_SIGROK: /* sigrok pattern */
 328                 for (i = 0; i < size; i++) {
 329                         *(buf + i) = ~(pattern_sigrok[p] >> 1);
 330                         if (++p == 64)
 331                                 p = 0;
 332                 }
 333                 break;
 334         case PATTERN_RANDOM: /* Random */
 335                 for (i = 0; i < size; i++)
 336                         *(buf + i) = (uint8_t)(rand() & 0xff);
 337                 break;
 338         case PATTERN_INC: /* Simple increment */
 339                 for (i = 0; i < size; i++)
 340                         *(buf + i) = i;
 341                 break;
 342         case PATTERN_ALL_LOW: /* All probes are low */
 343                 memset(buf, 0x00, size);
 344                 break;
 345         case PATTERN_ALL_HIGH: /* All probes are high */
 346                 memset(buf, 0xff, size);
 347                 break;
 348         default:
 349                 sr_err("Unknown pattern: %d.", devc->sample_generator);
 350                 break;
 351         }
 352 }
 353
 354 /* Callback handling data */
 355 static int receive_data(int fd, int revents, void *cb_data)
 356 {
 357         struct dev_context *devc = cb_data;
 358         struct sr_datafeed_packet packet;
 359         struct sr_datafeed_logic logic;
 360         uint8_t buf[BUFSIZE];
 361         static uint64_t samples_to_send, expected_samplenum, sending_now;
 362         int64_t time, elapsed;
 363
 364         (void)fd;
 365         (void)revents;
 366
 367         /* How many "virtual" samples should we have collected by now? */
 368         time = g_get_monotonic_time();
 369         elapsed = time - devc->starttime;
 370         expected_samplenum = elapsed * cur_samplerate / 1000000;
 371         /* Of those, how many do we still have to send? */
 372         samples_to_send = expected_samplenum - devc->samples_counter;
 373
 374         if (limit_samples) {
 375                 samples_to_send = MIN(samples_to_send,
 376                                  limit_samples - devc->samples_counter);
 377         }
 378
 379         while (samples_to_send > 0) {
 380                 sending_now = MIN(samples_to_send, sizeof(buf));
 381                 samples_to_send -= sending_now;
 382                 samples_generator(buf, sending_now, devc);
 383
 384                 packet.type = SR_DF_LOGIC;
 385                 packet.payload = &logic;
 386                 logic.length = sending_now;
 387                 logic.unitsize = 1;
 388                 logic.data = buf;
 389                 sr_session_send(devc->session_dev_id, &packet);
 390                 devc->samples_counter += sending_now;
 391         }
 392
 393         if (limit_samples && devc->samples_counter >= limit_samples) {
 394                 sr_info("Requested number of samples reached.");
 395                 hw_dev_acquisition_stop(NULL, cb_data);
 396                 return TRUE;
 397         }
 398
 399         return TRUE;
 400 }
 401
 402 static int hw_dev_acquisition_start(const struct sr_dev_inst *sdi,
 403                 void *cb_data)
 404 {
 405         struct sr_datafeed_packet *packet;
 406         struct sr_datafeed_header *header;
 407         struct dev_context *devc;
 408
 409         (void)sdi;
 410
 411         sr_dbg("Starting acquisition.");
 412
 413         /* TODO: 'devc' is never g_free()'d? */
 414         if (!(devc = g_try_malloc(sizeof(struct dev_context)))) {
 415                 sr_err("%s: devc malloc failed", __func__);
 416                 return SR_ERR_MALLOC;
 417         }
 418
 419         devc->sample_generator = default_pattern;
 420         devc->session_dev_id = cb_data;
 421         devc->samples_counter = 0;
 422
 423         /*
 424          * Setting two channels connected by a pipe is a remnant from when the
 425          * demo driver generated data in a thread, and collected and sent the
 426          * data in the main program loop.
 427          * They are kept here because it provides a convenient way of setting
 428          * up a timeout-based polling mechanism.
 429          */
 430         if (pipe(devc->pipe_fds)) {
 431                 /* TODO: Better error message. */
 432                 sr_err("%s: pipe() failed", __func__);
 433                 return SR_ERR;
 434         }
 435
 436         devc->channels[0] = g_io_channel_unix_new(devc->pipe_fds[0]);
 437         devc->channels[1] = g_io_channel_unix_new(devc->pipe_fds[1]);
 438
 439         g_io_channel_set_flags(devc->channels[0], G_IO_FLAG_NONBLOCK, NULL);
 440
 441         /* Set channel encoding to binary (default is UTF-8). */
 442         g_io_channel_set_encoding(devc->channels[0], NULL, NULL);
 443         g_io_channel_set_encoding(devc->channels[1], NULL, NULL);
 444
 445         /* Make channels to unbuffered. */
 446         g_io_channel_set_buffered(devc->channels[0], FALSE);
 447         g_io_channel_set_buffered(devc->channels[1], FALSE);
 448
 449         sr_session_source_add_channel(devc->channels[0], G_IO_IN | G_IO_ERR,
 450                     40, receive_data, devc);
 451
 452         if (!(packet = g_try_malloc(sizeof(struct sr_datafeed_packet)))) {
 453                 sr_err("%s: packet malloc failed", __func__);
 454                 return SR_ERR_MALLOC;
 455         }
 456
 457         if (!(header = g_try_malloc(sizeof(struct sr_datafeed_header)))) {
 458                 sr_err("%s: header malloc failed", __func__);
 459                 return SR_ERR_MALLOC;
 460         }
 461
 462         packet->type = SR_DF_HEADER;
 463         packet->payload = header;
 464         header->feed_version = 1;
 465         gettimeofday(&header->starttime, NULL);
 466         sr_session_send(devc->session_dev_id, packet);
 467
 468         /* We use this timestamp to decide how many more samples to send. */
 469         devc->starttime = g_get_monotonic_time();
 470
 471         g_free(header);
 472         g_free(packet);
 473
 474         return SR_OK;
 475 }
 476
 477 static int hw_dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
 478 {
 479         struct dev_context *devc;
 480         struct sr_datafeed_packet packet;
 481
 482         (void)sdi;
 483
 484         devc = cb_data;
 485
 486         sr_dbg("Stopping aquisition.");
 487
 488         sr_session_source_remove_channel(devc->channels[0]);
 489         g_io_channel_shutdown(devc->channels[0], FALSE, NULL);
 490
 491         /* Send last packet. */
 492         packet.type = SR_DF_END;
 493         sr_session_send(devc->session_dev_id, &packet);
 494
 495         return SR_OK;
 496 }
 497
 498 SR_PRIV struct sr_dev_driver demo_driver_info = {
 499         .name = "demo",
 500         .longname = "Demo driver and pattern generator",
 501         .api_version = 1,
 502         .init = hw_init,
 503         .cleanup = hw_cleanup,
 504         .scan = hw_scan,
 505         .dev_list = hw_dev_list,
 506         .dev_clear = clear_instances,
 507         .config_get = config_get,
 508         .config_set = config_set,
 509         .config_list = config_list,
 510         .dev_open = hw_dev_open,
 511         .dev_close = hw_dev_close,
 512         .dev_acquisition_start = hw_dev_acquisition_start,
 513         .dev_acquisition_stop = hw_dev_acquisition_stop,
 514         .priv = NULL,
 515 };