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         if (limit_samples && devc->samples_counter >= limit_samples) {
 386                 sr_info("Requested number of samples reached.");
 387                 hw_dev_acquisition_stop(NULL, cb_data);
 388                 return TRUE;
 389         }
 390
 391         return TRUE;
 392 }
 393
 394 static int hw_dev_acquisition_start(const struct sr_dev_inst *sdi,
 395                 void *cb_data)
 396 {
 397         struct sr_datafeed_packet *packet;
 398         struct sr_datafeed_header *header;
 399         struct sr_datafeed_meta_logic meta;
 400         struct dev_context *devc;
 401
 402         (void)sdi;
 403
 404         sr_dbg("Starting acquisition.");
 405
 406         /* TODO: 'devc' is never g_free()'d? */
 407         if (!(devc = g_try_malloc(sizeof(struct dev_context)))) {
 408                 sr_err("%s: devc malloc failed", __func__);
 409                 return SR_ERR_MALLOC;
 410         }
 411
 412         devc->sample_generator = default_pattern;
 413         devc->session_dev_id = cb_data;
 414         devc->samples_counter = 0;
 415
 416         /*
 417          * Setting two channels connected by a pipe is a remnant from when the
 418          * demo driver generated data in a thread, and collected and sent the
 419          * data in the main program loop.
 420          * They are kept here because it provides a convenient way of setting
 421          * up a timeout-based polling mechanism.
 422          */
 423         if (pipe(devc->pipe_fds)) {
 424                 /* TODO: Better error message. */
 425                 sr_err("%s: pipe() failed", __func__);
 426                 return SR_ERR;
 427         }
 428
 429         devc->channels[0] = g_io_channel_unix_new(devc->pipe_fds[0]);
 430         devc->channels[1] = g_io_channel_unix_new(devc->pipe_fds[1]);
 431
 432         g_io_channel_set_flags(devc->channels[0], G_IO_FLAG_NONBLOCK, NULL);
 433
 434         /* Set channel encoding to binary (default is UTF-8). */
 435         g_io_channel_set_encoding(devc->channels[0], NULL, NULL);
 436         g_io_channel_set_encoding(devc->channels[1], NULL, NULL);
 437
 438         /* Make channels to unbuffered. */
 439         g_io_channel_set_buffered(devc->channels[0], FALSE);
 440         g_io_channel_set_buffered(devc->channels[1], FALSE);
 441
 442         sr_session_source_add_channel(devc->channels[0], G_IO_IN | G_IO_ERR,
 443                     40, receive_data, devc);
 444
 445         if (!(packet = g_try_malloc(sizeof(struct sr_datafeed_packet)))) {
 446                 sr_err("%s: packet malloc failed", __func__);
 447                 return SR_ERR_MALLOC;
 448         }
 449
 450         if (!(header = g_try_malloc(sizeof(struct sr_datafeed_header)))) {
 451                 sr_err("%s: header malloc failed", __func__);
 452                 return SR_ERR_MALLOC;
 453         }
 454
 455         packet->type = SR_DF_HEADER;
 456         packet->payload = header;
 457         header->feed_version = 1;
 458         gettimeofday(&header->starttime, NULL);
 459         sr_session_send(devc->session_dev_id, packet);
 460
 461         /* Send metadata about the SR_DF_LOGIC packets to come. */
 462         packet->type = SR_DF_META_LOGIC;
 463         packet->payload = &meta;
 464         meta.samplerate = cur_samplerate;
 465         meta.num_probes = NUM_PROBES;
 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         .dev_open = hw_dev_open,
 508         .dev_close = hw_dev_close,
 509         .info_get = hw_info_get,
 510         .dev_config_set = hw_dev_config_set,
 511         .dev_acquisition_start = hw_dev_acquisition_start,
 512         .dev_acquisition_stop = hw_dev_acquisition_stop,
 513         .priv = NULL,
 514 };