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