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