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