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 #define STR_PATTERN_SIGROK   "sigrok"
  53 #define STR_PATTERN_RANDOM   "random"
  54 #define STR_PATTERN_INC      "incremental"
  55 #define STR_PATTERN_ALL_LOW  "all-low"
  56 #define STR_PATTERN_ALL_HIGH "all-high"
  57
  58 /* Supported patterns which we can generate */
  59 enum {
  60         /**
  61          * Pattern which spells "sigrok" using '0's (with '1's as "background")
  62          * when displayed using the 'bits' output format.
  63          */
  64         PATTERN_SIGROK,
  65
  66         /** Pattern which consists of (pseudo-)random values on all probes. */
  67         PATTERN_RANDOM,
  68
  69         /**
  70          * Pattern which consists of incrementing numbers.
  71          * TODO: Better description.
  72          */
  73         PATTERN_INC,
  74
  75         /** Pattern where all probes have a low logic state. */
  76         PATTERN_ALL_LOW,
  77
  78         /** Pattern where all probes have a high logic state. */
  79         PATTERN_ALL_HIGH,
  80 };
  81
  82 /* Private, per-device-instance driver context. */
  83 struct dev_context {
  84         struct sr_dev_inst *sdi;
  85         int pipe_fds[2];
  86         GIOChannel *channel;
  87         uint64_t cur_samplerate;
  88         uint64_t limit_samples;
  89         uint64_t limit_msec;
  90         uint8_t sample_generator;
  91         uint64_t samples_counter;
  92         void *cb_data;
  93         int64_t starttime;
  94 };
  95
  96 static const int hwcaps[] = {
  97         SR_CONF_LOGIC_ANALYZER,
  98         SR_CONF_DEMO_DEV,
  99         SR_CONF_SAMPLERATE,
 100         SR_CONF_PATTERN_MODE,
 101         SR_CONF_LIMIT_SAMPLES,
 102         SR_CONF_LIMIT_MSEC,
 103         SR_CONF_CONTINUOUS,
 104 };
 105
 106 static const uint64_t samplerates[] = {
 107         SR_HZ(1),
 108         SR_GHZ(1),
 109         SR_HZ(1),
 110 };
 111
 112 static const char *pattern_strings[] = {
 113         "sigrok",
 114         "random",
 115         "incremental",
 116         "all-low",
 117         "all-high",
 118 };
 119
 120 /* We name the probes 0-7 on our demo driver. */
 121 static const char *probe_names[NUM_PROBES + 1] = {
 122         "0", "1", "2", "3", "4", "5", "6", "7",
 123         NULL,
 124 };
 125
 126 static uint8_t pattern_sigrok[] = {
 127         0x4c, 0x92, 0x92, 0x92, 0x64, 0x00, 0x00, 0x00,
 128         0x82, 0xfe, 0xfe, 0x82, 0x00, 0x00, 0x00, 0x00,
 129         0x7c, 0x82, 0x82, 0x92, 0x74, 0x00, 0x00, 0x00,
 130         0xfe, 0x12, 0x12, 0x32, 0xcc, 0x00, 0x00, 0x00,
 131         0x7c, 0x82, 0x82, 0x82, 0x7c, 0x00, 0x00, 0x00,
 132         0xfe, 0x10, 0x28, 0x44, 0x82, 0x00, 0x00, 0x00,
 133         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 134         0xbe, 0xbe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 135 };
 136
 137 /* Private, per-device-instance driver context. */
 138 /* TODO: struct context as with the other drivers. */
 139
 140 /* List of struct sr_dev_inst, maintained by dev_open()/dev_close(). */
 141 SR_PRIV struct sr_dev_driver demo_driver_info;
 142 static struct sr_dev_driver *di = &demo_driver_info;
 143
 144 static int hw_dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data);
 145
 146 static int clear_instances(void)
 147 {
 148         /* Nothing needed so far. */
 149
 150         return SR_OK;
 151 }
 152
 153 static int hw_init(struct sr_context *sr_ctx)
 154 {
 155         return std_hw_init(sr_ctx, di, DRIVER_LOG_DOMAIN);
 156 }
 157
 158 static GSList *hw_scan(GSList *options)
 159 {
 160         struct sr_dev_inst *sdi;
 161         struct sr_probe *probe;
 162         struct drv_context *drvc;
 163         struct dev_context *devc;
 164         GSList *devices;
 165         int i;
 166
 167         (void)options;
 168
 169         drvc = di->priv;
 170
 171         devices = NULL;
 172
 173         sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, DEMONAME, NULL, NULL);
 174         if (!sdi) {
 175                 sr_err("Device instance creation failed.");
 176                 return NULL;
 177         }
 178         sdi->driver = di;
 179
 180         for (i = 0; probe_names[i]; i++) {
 181                 if (!(probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE,
 182                                 probe_names[i])))
 183                         return NULL;
 184                 sdi->probes = g_slist_append(sdi->probes, probe);
 185         }
 186
 187         devices = g_slist_append(devices, sdi);
 188         drvc->instances = g_slist_append(drvc->instances, sdi);
 189
 190         if (!(devc = g_try_malloc(sizeof(struct dev_context)))) {
 191                 sr_err("Device context malloc failed.");
 192                 return NULL;
 193         }
 194
 195         devc->sdi = sdi;
 196         devc->cur_samplerate = SR_KHZ(200);
 197         devc->limit_samples = 0;
 198         devc->limit_msec = 0;
 199         devc->sample_generator = PATTERN_SIGROK;
 200
 201         sdi->priv = devc;
 202
 203         return devices;
 204 }
 205
 206 static GSList *hw_dev_list(void)
 207 {
 208         return ((struct drv_context *)(di->priv))->instances;
 209 }
 210
 211 static int hw_dev_open(struct sr_dev_inst *sdi)
 212 {
 213         (void)sdi;
 214
 215         /* Nothing needed so far. */
 216
 217         return SR_OK;
 218 }
 219
 220 static int hw_dev_close(struct sr_dev_inst *sdi)
 221 {
 222         (void)sdi;
 223
 224         /* Nothing needed so far. */
 225
 226         return SR_OK;
 227 }
 228
 229 static int hw_cleanup(void)
 230 {
 231         GSList *l;
 232         struct sr_dev_inst *sdi;
 233         struct drv_context *drvc;
 234         int ret = SR_OK;
 235
 236         if (!(drvc = di->priv))
 237                 return SR_OK;
 238
 239         /* Properly close and free all devices. */
 240         for (l = drvc->instances; l; l = l->next) {
 241                 if (!(sdi = l->data)) {
 242                         /* Log error, but continue cleaning up the rest. */
 243                         sr_err("%s: sdi was NULL, continuing", __func__);
 244                         ret = SR_ERR_BUG;
 245                         continue;
 246                 }
 247                 sr_dev_inst_free(sdi);
 248         }
 249         g_slist_free(drvc->instances);
 250         drvc->instances = NULL;
 251
 252         return ret;
 253 }
 254
 255 static int config_get(int id, GVariant **data, const struct sr_dev_inst *sdi)
 256 {
 257         struct dev_context *const devc = sdi->priv;
 258
 259         switch (id) {
 260         case SR_CONF_SAMPLERATE:
 261                 *data = g_variant_new_uint64(devc->cur_samplerate);
 262                 break;
 263         case SR_CONF_LIMIT_SAMPLES:
 264                 *data = g_variant_new_uint64(devc->limit_samples);
 265                 break;
 266         case SR_CONF_LIMIT_MSEC:
 267                 *data = g_variant_new_uint64(devc->limit_msec);
 268                 break;
 269         case SR_CONF_PATTERN_MODE:
 270                 switch (devc->sample_generator) {
 271                 case PATTERN_SIGROK:
 272                         *data = g_variant_new_string(STR_PATTERN_SIGROK);
 273                         break;
 274                 case PATTERN_RANDOM:
 275                         *data = g_variant_new_string(STR_PATTERN_RANDOM);
 276                         break;
 277                 case PATTERN_INC:
 278                         *data = g_variant_new_string(STR_PATTERN_INC);
 279                         break;
 280                 case PATTERN_ALL_LOW:
 281                         *data = g_variant_new_string(STR_PATTERN_ALL_LOW);
 282                         break;
 283                 case PATTERN_ALL_HIGH:
 284                         *data = g_variant_new_string(STR_PATTERN_ALL_HIGH);
 285                         break;
 286                 }
 287                 break;
 288         default:
 289                 return SR_ERR_NA;
 290         }
 291
 292         return SR_OK;
 293 }
 294
 295 static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi)
 296 {
 297         int ret;
 298         const char *stropt;
 299
 300         struct dev_context *const devc = sdi->priv;
 301
 302         if (id == SR_CONF_SAMPLERATE) {
 303                 devc->cur_samplerate = g_variant_get_uint64(data);
 304                 sr_dbg("%s: setting samplerate to %" PRIu64, __func__,
 305                        devc->cur_samplerate);
 306                 ret = SR_OK;
 307         } else if (id == SR_CONF_LIMIT_SAMPLES) {
 308                 devc->limit_msec = 0;
 309                 devc->limit_samples = g_variant_get_uint64(data);
 310                 sr_dbg("%s: setting limit_samples to %" PRIu64, __func__,
 311                        devc->limit_samples);
 312                 ret = SR_OK;
 313         } else if (id == SR_CONF_LIMIT_MSEC) {
 314                 devc->limit_msec = g_variant_get_uint64(data);
 315                 devc->limit_samples = 0;
 316                 sr_dbg("%s: setting limit_msec to %" PRIu64, __func__,
 317                        devc->limit_msec);
 318                 ret = SR_OK;
 319         } else if (id == SR_CONF_PATTERN_MODE) {
 320                 stropt = g_variant_get_string(data, NULL);
 321                 ret = SR_OK;
 322                 if (!strcmp(stropt, STR_PATTERN_SIGROK)) {
 323                         devc->sample_generator = PATTERN_SIGROK;
 324                 } else if (!strcmp(stropt, STR_PATTERN_RANDOM)) {
 325                         devc->sample_generator = PATTERN_RANDOM;
 326                 } else if (!strcmp(stropt, STR_PATTERN_INC)) {
 327                         devc->sample_generator = PATTERN_INC;
 328                 } else if (!strcmp(stropt, STR_PATTERN_ALL_LOW)) {
 329                         devc->sample_generator = PATTERN_ALL_LOW;
 330                 } else if (!strcmp(stropt, STR_PATTERN_ALL_HIGH)) {
 331                         devc->sample_generator = PATTERN_ALL_HIGH;
 332                 } else {
 333                         ret = SR_ERR;
 334                 }
 335                 sr_dbg("%s: setting pattern to %d",
 336                         __func__, devc->sample_generator);
 337         } else {
 338                 ret = SR_ERR_NA;
 339         }
 340
 341         return ret;
 342 }
 343
 344 static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi)
 345 {
 346         GVariant *gvar;
 347         GVariantBuilder gvb;
 348
 349         (void)sdi;
 350
 351         switch (key) {
 352         case SR_CONF_DEVICE_OPTIONS:
 353                 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
 354                                 hwcaps, ARRAY_SIZE(hwcaps), sizeof(int32_t));
 355                 break;
 356         case SR_CONF_SAMPLERATE:
 357                 g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
 358                 gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates,
 359                                 ARRAY_SIZE(samplerates), sizeof(uint64_t));
 360                 g_variant_builder_add(&gvb, "{sv}", "samplerate-steps", gvar);
 361                 *data = g_variant_builder_end(&gvb);
 362                 break;
 363         case SR_CONF_PATTERN_MODE:
 364                 *data = g_variant_new_strv(pattern_strings, ARRAY_SIZE(pattern_strings));
 365                 break;
 366         default:
 367                 return SR_ERR_NA;
 368         }
 369
 370         return SR_OK;
 371 }
 372
 373 static void samples_generator(uint8_t *buf, uint64_t size,
 374                               struct dev_context *devc)
 375 {
 376         static uint64_t p = 0;
 377         uint64_t i;
 378
 379         /* TODO: Needed? */
 380         memset(buf, 0, size);
 381
 382         switch (devc->sample_generator) {
 383         case PATTERN_SIGROK: /* sigrok pattern */
 384                 for (i = 0; i < size; i++) {
 385                         *(buf + i) = ~(pattern_sigrok[
 386                                 p++ % sizeof(pattern_sigrok)] >> 1);
 387                 }
 388                 break;
 389         case PATTERN_RANDOM: /* Random */
 390                 for (i = 0; i < size; i++)
 391                         *(buf + i) = (uint8_t)(rand() & 0xff);
 392                 break;
 393         case PATTERN_INC: /* Simple increment */
 394                 for (i = 0; i < size; i++)
 395                         *(buf + i) = p++;
 396                 break;
 397         case PATTERN_ALL_LOW: /* All probes are low */
 398                 memset(buf, 0x00, size);
 399                 break;
 400         case PATTERN_ALL_HIGH: /* All probes are high */
 401                 memset(buf, 0xff, size);
 402                 break;
 403         default:
 404                 sr_err("Unknown pattern: %d.", devc->sample_generator);
 405                 break;
 406         }
 407 }
 408
 409 /* Callback handling data */
 410 static int receive_data(int fd, int revents, void *cb_data)
 411 {
 412         struct dev_context *devc = cb_data;
 413         struct sr_datafeed_packet packet;
 414         struct sr_datafeed_logic logic;
 415         uint8_t buf[BUFSIZE];
 416         static uint64_t samples_to_send, expected_samplenum, sending_now;
 417         int64_t time, elapsed;
 418
 419         (void)fd;
 420         (void)revents;
 421
 422         /* How many "virtual" samples should we have collected by now? */
 423         time = g_get_monotonic_time();
 424         elapsed = time - devc->starttime;
 425         expected_samplenum = elapsed * devc->cur_samplerate / 1000000;
 426         /* Of those, how many do we still have to send? */
 427         samples_to_send = expected_samplenum - devc->samples_counter;
 428
 429         if (devc->limit_samples) {
 430                 samples_to_send = MIN(samples_to_send,
 431                                  devc->limit_samples - devc->samples_counter);
 432         }
 433
 434         while (samples_to_send > 0) {
 435                 sending_now = MIN(samples_to_send, sizeof(buf));
 436                 samples_to_send -= sending_now;
 437                 samples_generator(buf, sending_now, devc);
 438
 439                 packet.type = SR_DF_LOGIC;
 440                 packet.payload = &logic;
 441                 logic.length = sending_now;
 442                 logic.unitsize = 1;
 443                 logic.data = buf;
 444                 sr_session_send(devc->cb_data, &packet);
 445                 devc->samples_counter += sending_now;
 446         }
 447
 448         if (devc->limit_samples &&
 449                 devc->samples_counter >= devc->limit_samples) {
 450                 sr_info("Requested number of samples reached.");
 451                 hw_dev_acquisition_stop(devc->sdi, cb_data);
 452                 return TRUE;
 453         }
 454
 455         return TRUE;
 456 }
 457
 458 static int hw_dev_acquisition_start(const struct sr_dev_inst *sdi,
 459                 void *cb_data)
 460 {
 461         struct dev_context *const devc = sdi->priv;
 462
 463         devc->cb_data = cb_data;
 464         devc->samples_counter = 0;
 465
 466         /*
 467          * Setting two channels connected by a pipe is a remnant from when the
 468          * demo driver generated data in a thread, and collected and sent the
 469          * data in the main program loop.
 470          * They are kept here because it provides a convenient way of setting
 471          * up a timeout-based polling mechanism.
 472          */
 473         if (pipe(devc->pipe_fds)) {
 474                 /* TODO: Better error message. */
 475                 sr_err("%s: pipe() failed", __func__);
 476                 return SR_ERR;
 477         }
 478
 479         devc->channel = g_io_channel_unix_new(devc->pipe_fds[0]);
 480
 481         g_io_channel_set_flags(devc->channel, G_IO_FLAG_NONBLOCK, NULL);
 482
 483         /* Set channel encoding to binary (default is UTF-8). */
 484         g_io_channel_set_encoding(devc->channel, NULL, NULL);
 485
 486         /* Make channels to unbuffered. */
 487         g_io_channel_set_buffered(devc->channel, FALSE);
 488
 489         sr_session_source_add_channel(devc->channel, G_IO_IN | G_IO_ERR,
 490                     40, receive_data, devc);
 491
 492         /* Send header packet to the session bus. */
 493         std_session_send_df_header(cb_data, DRIVER_LOG_DOMAIN);
 494
 495         /* We use this timestamp to decide how many more samples to send. */
 496         devc->starttime = g_get_monotonic_time();
 497
 498         return SR_OK;
 499 }
 500
 501 static int hw_dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
 502 {
 503         struct dev_context *const devc = sdi->priv;
 504         struct sr_datafeed_packet packet;
 505
 506         (void)cb_data;
 507
 508         sr_dbg("Stopping aquisition.");
 509
 510         sr_session_source_remove_channel(devc->channel);
 511         g_io_channel_shutdown(devc->channel, FALSE, NULL);
 512         g_io_channel_unref(devc->channel);
 513         devc->channel = NULL;
 514
 515         /* Send last packet. */
 516         packet.type = SR_DF_END;
 517         sr_session_send(devc->cb_data, &packet);
 518
 519         return SR_OK;
 520 }
 521
 522 SR_PRIV struct sr_dev_driver demo_driver_info = {
 523         .name = "demo",
 524         .longname = "Demo driver and pattern generator",
 525         .api_version = 1,
 526         .init = hw_init,
 527         .cleanup = hw_cleanup,
 528         .scan = hw_scan,
 529         .dev_list = hw_dev_list,
 530         .dev_clear = clear_instances,
 531         .config_get = config_get,
 532         .config_set = config_set,
 533         .config_list = config_list,
 534         .dev_open = hw_dev_open,
 535         .dev_close = hw_dev_close,
 536         .dev_acquisition_start = hw_dev_acquisition_start,
 537         .dev_acquisition_stop = hw_dev_acquisition_stop,
 538         .priv = NULL,
 539 };