hardware/demo/demo.c

   1 /*
   2  * This file is part of the libsigrok 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 subsystem-specific prefix string. */
  35 #define LOG_PREFIX "demo: "
  36 #define sr_log(l, s, args...) sr_log(l, LOG_PREFIX s, ## args)
  37 #define sr_spew(s, args...) sr_spew(LOG_PREFIX s, ## args)
  38 #define sr_dbg(s, args...) sr_dbg(LOG_PREFIX s, ## args)
  39 #define sr_info(s, args...) sr_info(LOG_PREFIX s, ## args)
  40 #define sr_warn(s, args...) sr_warn(LOG_PREFIX s, ## args)
  41 #define sr_err(s, args...) sr_err(LOG_PREFIX 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 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 init(struct sr_context *sr_ctx)
 154 {
 155         return std_hw_init(sr_ctx, di, LOG_PREFIX);
 156 }
 157
 158 static GSList *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 *dev_list(void)
 207 {
 208         return ((struct drv_context *)(di->priv))->instances;
 209 }
 210
 211 static int dev_open(struct sr_dev_inst *sdi)
 212 {
 213         sdi->status = SR_ST_ACTIVE;
 214
 215         return SR_OK;
 216 }
 217
 218 static int dev_close(struct sr_dev_inst *sdi)
 219 {
 220         sdi->status = SR_ST_INACTIVE;
 221
 222         return SR_OK;
 223 }
 224
 225 static int cleanup(void)
 226 {
 227         GSList *l;
 228         struct sr_dev_inst *sdi;
 229         struct drv_context *drvc;
 230         int ret = SR_OK;
 231
 232         if (!(drvc = di->priv))
 233                 return SR_OK;
 234
 235         /* Properly close and free all devices. */
 236         for (l = drvc->instances; l; l = l->next) {
 237                 if (!(sdi = l->data)) {
 238                         /* Log error, but continue cleaning up the rest. */
 239                         sr_err("%s: sdi was NULL, continuing", __func__);
 240                         ret = SR_ERR_BUG;
 241                         continue;
 242                 }
 243                 sr_dev_inst_free(sdi);
 244         }
 245         g_slist_free(drvc->instances);
 246         drvc->instances = NULL;
 247
 248         return ret;
 249 }
 250
 251 static int config_get(int id, GVariant **data, const struct sr_dev_inst *sdi)
 252 {
 253         struct dev_context *const devc = sdi->priv;
 254
 255         switch (id) {
 256         case SR_CONF_SAMPLERATE:
 257                 *data = g_variant_new_uint64(devc->cur_samplerate);
 258                 break;
 259         case SR_CONF_LIMIT_SAMPLES:
 260                 *data = g_variant_new_uint64(devc->limit_samples);
 261                 break;
 262         case SR_CONF_LIMIT_MSEC:
 263                 *data = g_variant_new_uint64(devc->limit_msec);
 264                 break;
 265         case SR_CONF_PATTERN_MODE:
 266                 switch (devc->sample_generator) {
 267                 case PATTERN_SIGROK:
 268                         *data = g_variant_new_string(STR_PATTERN_SIGROK);
 269                         break;
 270                 case PATTERN_RANDOM:
 271                         *data = g_variant_new_string(STR_PATTERN_RANDOM);
 272                         break;
 273                 case PATTERN_INC:
 274                         *data = g_variant_new_string(STR_PATTERN_INC);
 275                         break;
 276                 case PATTERN_ALL_LOW:
 277                         *data = g_variant_new_string(STR_PATTERN_ALL_LOW);
 278                         break;
 279                 case PATTERN_ALL_HIGH:
 280                         *data = g_variant_new_string(STR_PATTERN_ALL_HIGH);
 281                         break;
 282                 }
 283                 break;
 284         default:
 285                 return SR_ERR_NA;
 286         }
 287
 288         return SR_OK;
 289 }
 290
 291 static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi)
 292 {
 293         int ret;
 294         const char *stropt;
 295
 296         struct dev_context *const devc = sdi->priv;
 297
 298         if (sdi->status != SR_ST_ACTIVE)
 299                 return SR_ERR_DEV_CLOSED;
 300
 301         if (id == SR_CONF_SAMPLERATE) {
 302                 devc->cur_samplerate = g_variant_get_uint64(data);
 303                 sr_dbg("%s: setting samplerate to %" PRIu64, __func__,
 304                        devc->cur_samplerate);
 305                 ret = SR_OK;
 306         } else if (id == SR_CONF_LIMIT_SAMPLES) {
 307                 devc->limit_msec = 0;
 308                 devc->limit_samples = g_variant_get_uint64(data);
 309                 sr_dbg("%s: setting limit_samples to %" PRIu64, __func__,
 310                        devc->limit_samples);
 311                 ret = SR_OK;
 312         } else if (id == SR_CONF_LIMIT_MSEC) {
 313                 devc->limit_msec = g_variant_get_uint64(data);
 314                 devc->limit_samples = 0;
 315                 sr_dbg("%s: setting limit_msec to %" PRIu64, __func__,
 316                        devc->limit_msec);
 317                 ret = SR_OK;
 318         } else if (id == SR_CONF_PATTERN_MODE) {
 319                 stropt = g_variant_get_string(data, NULL);
 320                 ret = SR_OK;
 321                 if (!strcmp(stropt, STR_PATTERN_SIGROK)) {
 322                         devc->sample_generator = PATTERN_SIGROK;
 323                 } else if (!strcmp(stropt, STR_PATTERN_RANDOM)) {
 324                         devc->sample_generator = PATTERN_RANDOM;
 325                 } else if (!strcmp(stropt, STR_PATTERN_INC)) {
 326                         devc->sample_generator = PATTERN_INC;
 327                 } else if (!strcmp(stropt, STR_PATTERN_ALL_LOW)) {
 328                         devc->sample_generator = PATTERN_ALL_LOW;
 329                 } else if (!strcmp(stropt, STR_PATTERN_ALL_HIGH)) {
 330                         devc->sample_generator = PATTERN_ALL_HIGH;
 331                 } else {
 332                         ret = SR_ERR;
 333                 }
 334                 sr_dbg("%s: setting pattern to %d",
 335                         __func__, devc->sample_generator);
 336         } else {
 337                 ret = SR_ERR_NA;
 338         }
 339
 340         return ret;
 341 }
 342
 343 static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi)
 344 {
 345         GVariant *gvar;
 346         GVariantBuilder gvb;
 347
 348         (void)sdi;
 349
 350         switch (key) {
 351         case SR_CONF_DEVICE_OPTIONS:
 352                 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
 353                                 hwcaps, ARRAY_SIZE(hwcaps), sizeof(int32_t));
 354                 break;
 355         case SR_CONF_SAMPLERATE:
 356                 g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
 357                 gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates,
 358                                 ARRAY_SIZE(samplerates), sizeof(uint64_t));
 359                 g_variant_builder_add(&gvb, "{sv}", "samplerate-steps", gvar);
 360                 *data = g_variant_builder_end(&gvb);
 361                 break;
 362         case SR_CONF_PATTERN_MODE:
 363                 *data = g_variant_new_strv(pattern_strings, ARRAY_SIZE(pattern_strings));
 364                 break;
 365         default:
 366                 return SR_ERR_NA;
 367         }
 368
 369         return SR_OK;
 370 }
 371
 372 static void samples_generator(uint8_t *buf, uint64_t size,
 373                               struct dev_context *devc)
 374 {
 375         static uint64_t p = 0;
 376         uint64_t i;
 377
 378         /* TODO: Needed? */
 379         memset(buf, 0, size);
 380
 381         switch (devc->sample_generator) {
 382         case PATTERN_SIGROK: /* sigrok pattern */
 383                 for (i = 0; i < size; i++) {
 384                         *(buf + i) = ~(pattern_sigrok[
 385                                 p++ % sizeof(pattern_sigrok)] >> 1);
 386                 }
 387                 break;
 388         case PATTERN_RANDOM: /* Random */
 389                 for (i = 0; i < size; i++)
 390                         *(buf + i) = (uint8_t)(rand() & 0xff);
 391                 break;
 392         case PATTERN_INC: /* Simple increment */
 393                 for (i = 0; i < size; i++)
 394                         *(buf + i) = p++;
 395                 break;
 396         case PATTERN_ALL_LOW: /* All probes are low */
 397                 memset(buf, 0x00, size);
 398                 break;
 399         case PATTERN_ALL_HIGH: /* All probes are high */
 400                 memset(buf, 0xff, size);
 401                 break;
 402         default:
 403                 sr_err("Unknown pattern: %d.", devc->sample_generator);
 404                 break;
 405         }
 406 }
 407
 408 /* Callback handling data */
 409 static int receive_data(int fd, int revents, void *cb_data)
 410 {
 411         struct dev_context *devc = cb_data;
 412         struct sr_datafeed_packet packet;
 413         struct sr_datafeed_logic logic;
 414         uint8_t buf[BUFSIZE];
 415         static uint64_t samples_to_send, expected_samplenum, sending_now;
 416         int64_t time, elapsed;
 417
 418         (void)fd;
 419         (void)revents;
 420
 421         /* How many "virtual" samples should we have collected by now? */
 422         time = g_get_monotonic_time();
 423         elapsed = time - devc->starttime;
 424         expected_samplenum = elapsed * devc->cur_samplerate / 1000000;
 425         /* Of those, how many do we still have to send? */
 426         samples_to_send = expected_samplenum - devc->samples_counter;
 427
 428         if (devc->limit_samples) {
 429                 samples_to_send = MIN(samples_to_send,
 430                                  devc->limit_samples - devc->samples_counter);
 431         }
 432
 433         while (samples_to_send > 0) {
 434                 sending_now = MIN(samples_to_send, sizeof(buf));
 435                 samples_to_send -= sending_now;
 436                 samples_generator(buf, sending_now, devc);
 437
 438                 packet.type = SR_DF_LOGIC;
 439                 packet.payload = &logic;
 440                 logic.length = sending_now;
 441                 logic.unitsize = 1;
 442                 logic.data = buf;
 443                 sr_session_send(devc->cb_data, &packet);
 444                 devc->samples_counter += sending_now;
 445         }
 446
 447         if (devc->limit_samples &&
 448                 devc->samples_counter >= devc->limit_samples) {
 449                 sr_info("Requested number of samples reached.");
 450                 dev_acquisition_stop(devc->sdi, cb_data);
 451                 return TRUE;
 452         }
 453
 454         return TRUE;
 455 }
 456
 457 static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
 458 {
 459         struct dev_context *const devc = sdi->priv;
 460
 461         if (sdi->status != SR_ST_ACTIVE)
 462                 return SR_ERR_DEV_CLOSED;
 463
 464         devc->cb_data = cb_data;
 465         devc->samples_counter = 0;
 466
 467         /*
 468          * Setting two channels connected by a pipe is a remnant from when the
 469          * demo driver generated data in a thread, and collected and sent the
 470          * data in the main program loop.
 471          * They are kept here because it provides a convenient way of setting
 472          * up a timeout-based polling mechanism.
 473          */
 474         if (pipe(devc->pipe_fds)) {
 475                 /* TODO: Better error message. */
 476                 sr_err("%s: pipe() failed", __func__);
 477                 return SR_ERR;
 478         }
 479
 480         devc->channel = g_io_channel_unix_new(devc->pipe_fds[0]);
 481
 482         g_io_channel_set_flags(devc->channel, G_IO_FLAG_NONBLOCK, NULL);
 483
 484         /* Set channel encoding to binary (default is UTF-8). */
 485         g_io_channel_set_encoding(devc->channel, NULL, NULL);
 486
 487         /* Make channels to unbuffered. */
 488         g_io_channel_set_buffered(devc->channel, FALSE);
 489
 490         sr_session_source_add_channel(devc->channel, G_IO_IN | G_IO_ERR,
 491                     40, receive_data, devc);
 492
 493         /* Send header packet to the session bus. */
 494         std_session_send_df_header(cb_data, LOG_PREFIX);
 495
 496         /* We use this timestamp to decide how many more samples to send. */
 497         devc->starttime = g_get_monotonic_time();
 498
 499         return SR_OK;
 500 }
 501
 502 static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
 503 {
 504         struct dev_context *const devc = sdi->priv;
 505         struct sr_datafeed_packet packet;
 506
 507         (void)cb_data;
 508
 509         sr_dbg("Stopping aquisition.");
 510
 511         sr_session_source_remove_channel(devc->channel);
 512         g_io_channel_shutdown(devc->channel, FALSE, NULL);
 513         g_io_channel_unref(devc->channel);
 514         devc->channel = NULL;
 515
 516         /* Send last packet. */
 517         packet.type = SR_DF_END;
 518         sr_session_send(devc->cb_data, &packet);
 519
 520         return SR_OK;
 521 }
 522
 523 SR_PRIV struct sr_dev_driver demo_driver_info = {
 524         .name = "demo",
 525         .longname = "Demo driver and pattern generator",
 526         .api_version = 1,
 527         .init = init,
 528         .cleanup = cleanup,
 529         .scan = scan,
 530         .dev_list = dev_list,
 531         .dev_clear = clear_instances,
 532         .config_get = config_get,
 533         .config_set = config_set,
 534         .config_list = config_list,
 535         .dev_open = dev_open,
 536         .dev_close = dev_close,
 537         .dev_acquisition_start = dev_acquisition_start,
 538         .dev_acquisition_stop = dev_acquisition_stop,
 539         .priv = NULL,
 540 };