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