src/hardware/rigol-ds/api.c

   1 /*
   2  * This file is part of the libsigrok project.
   3  *
   4  * Copyright (C) 2012 Martin Ling <martin-git@earth.li>
   5  * Copyright (C) 2013 Bert Vermeulen <bert@biot.com>
   6  * Copyright (C) 2013 Mathias Grimmberger <mgri@zaphod.sax.de>
   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 3 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, see <http://www.gnu.org/licenses/>.
  20  */
  21
  22 #include <config.h>
  23 #include <fcntl.h>
  24 #include <unistd.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <strings.h>
  28 #include <math.h>
  29 #include <glib.h>
  30 #include <libsigrok/libsigrok.h>
  31 #include "libsigrok-internal.h"
  32 #include "scpi.h"
  33 #include "protocol.h"
  34
  35 static const uint32_t scanopts[] = {
  36         SR_CONF_CONN,
  37         SR_CONF_SERIALCOMM
  38 };
  39
  40 static const uint32_t devopts[] = {
  41         SR_CONF_OSCILLOSCOPE,
  42         SR_CONF_LIMIT_FRAMES | SR_CONF_SET,
  43         SR_CONF_TIMEBASE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  44         SR_CONF_TRIGGER_SOURCE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  45         SR_CONF_TRIGGER_SLOPE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  46         SR_CONF_HORIZ_TRIGGERPOS | SR_CONF_SET,
  47         SR_CONF_NUM_HDIV | SR_CONF_GET,
  48         SR_CONF_SAMPLERATE | SR_CONF_GET,
  49         SR_CONF_DATA_SOURCE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  50 };
  51
  52 static const uint32_t analog_devopts[] = {
  53         SR_CONF_NUM_VDIV | SR_CONF_GET,
  54         SR_CONF_VDIV | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  55         SR_CONF_COUPLING | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  56 };
  57
  58 static const uint64_t timebases[][2] = {
  59         /* nanoseconds */
  60         { 1, 1000000000 },
  61         { 2, 1000000000 },
  62         { 5, 1000000000 },
  63         { 10, 1000000000 },
  64         { 20, 1000000000 },
  65         { 50, 1000000000 },
  66         { 100, 1000000000 },
  67         { 500, 1000000000 },
  68         /* microseconds */
  69         { 1, 1000000 },
  70         { 2, 1000000 },
  71         { 5, 1000000 },
  72         { 10, 1000000 },
  73         { 20, 1000000 },
  74         { 50, 1000000 },
  75         { 100, 1000000 },
  76         { 200, 1000000 },
  77         { 500, 1000000 },
  78         /* milliseconds */
  79         { 1, 1000 },
  80         { 2, 1000 },
  81         { 5, 1000 },
  82         { 10, 1000 },
  83         { 20, 1000 },
  84         { 50, 1000 },
  85         { 100, 1000 },
  86         { 200, 1000 },
  87         { 500, 1000 },
  88         /* seconds */
  89         { 1, 1 },
  90         { 2, 1 },
  91         { 5, 1 },
  92         { 10, 1 },
  93         { 20, 1 },
  94         { 50, 1 },
  95         { 100, 1 },
  96         { 200, 1 },
  97         { 500, 1 },
  98         { 1000, 1 },
  99 };
 100
 101 static const uint64_t vdivs[][2] = {
 102         /* microvolts */
 103         { 500, 1000000 },
 104         /* millivolts */
 105         { 1, 1000 },
 106         { 2, 1000 },
 107         { 5, 1000 },
 108         { 10, 1000 },
 109         { 20, 1000 },
 110         { 50, 1000 },
 111         { 100, 1000 },
 112         { 200, 1000 },
 113         { 500, 1000 },
 114         /* volts */
 115         { 1, 1 },
 116         { 2, 1 },
 117         { 5, 1 },
 118         { 10, 1 },
 119         { 20, 1 },
 120         { 50, 1 },
 121         { 100, 1 },
 122 };
 123
 124 #define NUM_TIMEBASE  ARRAY_SIZE(timebases)
 125 #define NUM_VDIV      ARRAY_SIZE(vdivs)
 126
 127 static const char *trigger_sources[] = {
 128         "CH1",
 129         "CH2",
 130         "CH3",
 131         "CH4",
 132         "EXT",
 133         "AC Line",
 134         "D0",
 135         "D1",
 136         "D2",
 137         "D3",
 138         "D4",
 139         "D5",
 140         "D6",
 141         "D7",
 142         "D8",
 143         "D9",
 144         "D10",
 145         "D11",
 146         "D12",
 147         "D13",
 148         "D14",
 149         "D15",
 150 };
 151
 152 static const char *trigger_slopes[] = {
 153         "r",
 154         "f",
 155 };
 156
 157 static const char *coupling[] = {
 158         "AC",
 159         "DC",
 160         "GND",
 161 };
 162
 163 /* Do not change the order of entries */
 164 static const char *data_sources[] = {
 165         "Live",
 166         "Memory",
 167         "Segmented",
 168 };
 169
 170 enum vendor {
 171         RIGOL,
 172         AGILENT,
 173 };
 174
 175 enum series {
 176         VS5000,
 177         DS1000,
 178         DS2000,
 179         DS2000A,
 180         DSO1000,
 181         DS1000Z,
 182 };
 183
 184 /* short name, full name */
 185 static const struct rigol_ds_vendor supported_vendors[] = {
 186         [RIGOL] = {"Rigol", "Rigol Technologies"},
 187         [AGILENT] = {"Agilent", "Agilent Technologies"},
 188 };
 189
 190 #define VENDOR(x) &supported_vendors[x]
 191 /* vendor, series, protocol, max timebase, min vdiv, number of horizontal divs,
 192  * live waveform samples, memory buffer samples */
 193 static const struct rigol_ds_series supported_series[] = {
 194         [VS5000] = {VENDOR(RIGOL), "VS5000", PROTOCOL_V1, FORMAT_RAW,
 195                 {50, 1}, {2, 1000}, 14, 2048, 0},
 196         [DS1000] = {VENDOR(RIGOL), "DS1000", PROTOCOL_V2, FORMAT_IEEE488_2,
 197                 {50, 1}, {2, 1000}, 12, 600, 1048576},
 198         [DS2000] = {VENDOR(RIGOL), "DS2000", PROTOCOL_V3, FORMAT_IEEE488_2,
 199                 {500, 1}, {500, 1000000}, 14, 1400, 14000},
 200         [DS2000A] = {VENDOR(RIGOL), "DS2000A", PROTOCOL_V3, FORMAT_IEEE488_2,
 201                 {1000, 1}, {500, 1000000}, 14, 1400, 14000},
 202         [DSO1000] = {VENDOR(AGILENT), "DSO1000", PROTOCOL_V3, FORMAT_IEEE488_2,
 203                 {50, 1}, {2, 1000}, 12, 600, 20480},
 204         [DS1000Z] = {VENDOR(RIGOL), "DS1000Z", PROTOCOL_V4, FORMAT_IEEE488_2,
 205                 {50, 1}, {1, 1000}, 12, 1200, 12000000},
 206 };
 207
 208 #define SERIES(x) &supported_series[x]
 209 /* series, model, min timebase, analog channels, digital */
 210 static const struct rigol_ds_model supported_models[] = {
 211         {SERIES(VS5000), "VS5022", {20, 1000000000}, 2, false},
 212         {SERIES(VS5000), "VS5042", {10, 1000000000}, 2, false},
 213         {SERIES(VS5000), "VS5062", {5, 1000000000}, 2, false},
 214         {SERIES(VS5000), "VS5102", {2, 1000000000}, 2, false},
 215         {SERIES(VS5000), "VS5202", {2, 1000000000}, 2, false},
 216         {SERIES(VS5000), "VS5022D", {20, 1000000000}, 2, true},
 217         {SERIES(VS5000), "VS5042D", {10, 1000000000}, 2, true},
 218         {SERIES(VS5000), "VS5062D", {5, 1000000000}, 2, true},
 219         {SERIES(VS5000), "VS5102D", {2, 1000000000}, 2, true},
 220         {SERIES(VS5000), "VS5202D", {2, 1000000000}, 2, true},
 221         {SERIES(DS1000), "DS1052E", {5, 1000000000}, 2, false},
 222         {SERIES(DS1000), "DS1102E", {2, 1000000000}, 2, false},
 223         {SERIES(DS1000), "DS1152E", {2, 1000000000}, 2, false},
 224         {SERIES(DS1000), "DS1052D", {5, 1000000000}, 2, true},
 225         {SERIES(DS1000), "DS1102D", {2, 1000000000}, 2, true},
 226         {SERIES(DS1000), "DS1152D", {2, 1000000000}, 2, true},
 227         {SERIES(DS2000), "DS2072", {5, 1000000000}, 2, false},
 228         {SERIES(DS2000), "DS2102", {5, 1000000000}, 2, false},
 229         {SERIES(DS2000), "DS2202", {2, 1000000000}, 2, false},
 230         {SERIES(DS2000), "DS2302", {1, 1000000000}, 2, false},
 231         {SERIES(DS2000A), "DS2072A", {5, 1000000000}, 2, false},
 232         {SERIES(DS2000A), "DS2102A", {5, 1000000000}, 2, false},
 233         {SERIES(DS2000A), "DS2202A", {2, 1000000000}, 2, false},
 234         {SERIES(DS2000A), "DS2302A", {1, 1000000000}, 2, false},
 235         {SERIES(DSO1000), "DSO1002A", {5, 1000000000}, 2, false},
 236         {SERIES(DSO1000), "DSO1004A", {5, 1000000000}, 4, false},
 237         {SERIES(DSO1000), "DSO1012A", {2, 1000000000}, 2, false},
 238         {SERIES(DSO1000), "DSO1014A", {2, 1000000000}, 4, false},
 239         {SERIES(DSO1000), "DSO1022A", {2, 1000000000}, 2, false},
 240         {SERIES(DSO1000), "DSO1024A", {2, 1000000000}, 4, false},
 241         {SERIES(DS1000Z), "DS1054Z", {5, 1000000000}, 4, false},
 242         {SERIES(DS1000Z), "DS1074Z", {5, 1000000000}, 4, false},
 243         {SERIES(DS1000Z), "DS1104Z", {5, 1000000000}, 4, false},
 244         {SERIES(DS1000Z), "DS1074Z-S", {5, 1000000000}, 4, false},
 245         {SERIES(DS1000Z), "DS1104Z-S", {5, 1000000000}, 4, false},
 246         {SERIES(DS1000Z), "MSO1074Z", {5, 1000000000}, 4, true},
 247         {SERIES(DS1000Z), "MSO1104Z", {5, 1000000000}, 4, true},
 248         {SERIES(DS1000Z), "MSO1074Z-S", {5, 1000000000}, 4, true},
 249         {SERIES(DS1000Z), "MSO1104Z-S", {5, 1000000000}, 4, true},
 250 };
 251
 252 SR_PRIV struct sr_dev_driver rigol_ds_driver_info;
 253
 254 static void clear_helper(void *priv)
 255 {
 256         struct dev_context *devc;
 257         unsigned int i;
 258
 259         devc = priv;
 260         g_free(devc->data);
 261         g_free(devc->buffer);
 262         for (i = 0; i < ARRAY_SIZE(devc->coupling); i++)
 263                 g_free(devc->coupling[i]);
 264         g_free(devc->trigger_source);
 265         g_free(devc->trigger_slope);
 266         g_free(devc->analog_groups);
 267         g_free(devc);
 268 }
 269
 270 static int dev_clear(const struct sr_dev_driver *di)
 271 {
 272         return std_dev_clear(di, clear_helper);
 273 }
 274
 275 static int init(struct sr_dev_driver *di, struct sr_context *sr_ctx)
 276 {
 277         return std_init(sr_ctx, di, LOG_PREFIX);
 278 }
 279
 280 static struct sr_dev_inst *probe_device(struct sr_scpi_dev_inst *scpi)
 281 {
 282         struct dev_context *devc;
 283         struct sr_dev_inst *sdi;
 284         struct sr_scpi_hw_info *hw_info;
 285         struct sr_channel *ch;
 286         long n[3];
 287         unsigned int i;
 288         const struct rigol_ds_model *model = NULL;
 289         gchar *channel_name, **version;
 290
 291         if (sr_scpi_get_hw_id(scpi, &hw_info) != SR_OK) {
 292                 sr_info("Couldn't get IDN response, retrying.");
 293                 sr_scpi_close(scpi);
 294                 sr_scpi_open(scpi);
 295                 if (sr_scpi_get_hw_id(scpi, &hw_info) != SR_OK) {
 296                         sr_info("Couldn't get IDN response.");
 297                         return NULL;
 298                 }
 299         }
 300
 301         for (i = 0; i < ARRAY_SIZE(supported_models); i++) {
 302                 if (!g_ascii_strcasecmp(hw_info->manufacturer,
 303                                         supported_models[i].series->vendor->full_name) &&
 304                                 !strcmp(hw_info->model, supported_models[i].name)) {
 305                         model = &supported_models[i];
 306                         break;
 307                 }
 308         }
 309
 310         if (!model) {
 311                 sr_scpi_hw_info_free(hw_info);
 312                 return NULL;
 313         }
 314
 315         sdi = g_malloc0(sizeof(struct sr_dev_inst));
 316         sdi->status = SR_ST_ACTIVE;
 317         sdi->vendor = g_strdup(model->series->vendor->name);
 318         sdi->model = g_strdup(model->name);
 319         sdi->version = g_strdup(hw_info->firmware_version);
 320         sdi->conn = scpi;
 321         sdi->driver = &rigol_ds_driver_info;
 322         sdi->inst_type = SR_INST_SCPI;
 323         sdi->serial_num = g_strdup(hw_info->serial_number);
 324         devc = g_malloc0(sizeof(struct dev_context));
 325         devc->limit_frames = 0;
 326         devc->model = model;
 327         devc->format = model->series->format;
 328
 329         /* DS1000 models with firmware before 0.2.4 used the old data format. */
 330         if (model->series == SERIES(DS1000)) {
 331                 version = g_strsplit(hw_info->firmware_version, ".", 0);
 332                 do {
 333                         if (!version[0] || !version[1] || !version[2])
 334                                 break;
 335                         if (version[0][0] == 0 || version[1][0] == 0 || version[2][0] == 0)
 336                                 break;
 337                         for (i = 0; i < 3; i++) {
 338                                 if (sr_atol(version[i], &n[i]) != SR_OK)
 339                                         break;
 340                         }
 341                         if (i != 3)
 342                                 break;
 343                         scpi->firmware_version = n[0] * 100 + n[1] * 10 + n[2];
 344                         if (scpi->firmware_version < 24) {
 345                                 sr_dbg("Found DS1000 firmware < 0.2.4, using raw data format.");
 346                                 devc->format = FORMAT_RAW;
 347                         }
 348                         break;
 349                 } while (0);
 350                 g_strfreev(version);
 351         }
 352
 353         sr_scpi_hw_info_free(hw_info);
 354
 355         devc->analog_groups = g_malloc0(sizeof(struct sr_channel_group*) *
 356                                         model->analog_channels);
 357
 358         for (i = 0; i < model->analog_channels; i++) {
 359                 channel_name = g_strdup_printf("CH%d", i + 1);
 360                 ch = sr_channel_new(sdi, i, SR_CHANNEL_ANALOG, TRUE, channel_name);
 361
 362                 devc->analog_groups[i] = g_malloc0(sizeof(struct sr_channel_group));
 363
 364                 devc->analog_groups[i]->name = channel_name;
 365                 devc->analog_groups[i]->channels = g_slist_append(NULL, ch);
 366                 sdi->channel_groups = g_slist_append(sdi->channel_groups,
 367                                 devc->analog_groups[i]);
 368         }
 369
 370         if (devc->model->has_digital) {
 371                 devc->digital_group = g_malloc0(sizeof(struct sr_channel_group));
 372
 373                 for (i = 0; i < ARRAY_SIZE(devc->digital_channels); i++) {
 374                         channel_name = g_strdup_printf("D%d", i);
 375                         ch = sr_channel_new(sdi, i, SR_CHANNEL_LOGIC, TRUE, channel_name);
 376                         g_free(channel_name);
 377                         devc->digital_group->channels = g_slist_append(
 378                                         devc->digital_group->channels, ch);
 379                 }
 380                 devc->digital_group->name = g_strdup("LA");
 381                 sdi->channel_groups = g_slist_append(sdi->channel_groups,
 382                                 devc->digital_group);
 383         }
 384
 385         for (i = 0; i < NUM_TIMEBASE; i++) {
 386                 if (!memcmp(&devc->model->min_timebase, &timebases[i], sizeof(uint64_t[2])))
 387                         devc->timebases = &timebases[i];
 388                 if (!memcmp(&devc->model->series->max_timebase, &timebases[i], sizeof(uint64_t[2])))
 389                         devc->num_timebases = &timebases[i] - devc->timebases + 1;
 390         }
 391
 392         for (i = 0; i < NUM_VDIV; i++) {
 393                 if (!memcmp(&devc->model->series->min_vdiv,
 394                                         &vdivs[i], sizeof(uint64_t[2]))) {
 395                         devc->vdivs = &vdivs[i];
 396                         devc->num_vdivs = NUM_VDIV - i;
 397                 }
 398         }
 399
 400         devc->buffer = g_malloc(ACQ_BUFFER_SIZE);
 401         devc->data = g_malloc(ACQ_BUFFER_SIZE * sizeof(float));
 402
 403         devc->data_source = DATA_SOURCE_LIVE;
 404
 405         sdi->priv = devc;
 406
 407         sdi->status = SR_ST_INACTIVE;
 408
 409         sr_scpi_close(scpi);
 410
 411         return sdi;
 412 }
 413
 414 static GSList *scan(struct sr_dev_driver *di, GSList *options)
 415 {
 416         return sr_scpi_scan(di->context, options, probe_device);
 417 }
 418
 419 static GSList *dev_list(const struct sr_dev_driver *di)
 420 {
 421         return ((struct drv_context *)(di->context))->instances;
 422 }
 423
 424 static int dev_open(struct sr_dev_inst *sdi)
 425 {
 426         int ret;
 427         struct sr_scpi_dev_inst *scpi = sdi->conn;
 428
 429         if ((ret = sr_scpi_open(scpi)) < 0) {
 430                 sr_err("Failed to open SCPI device: %s.", sr_strerror(ret));
 431                 return SR_ERR;
 432         }
 433
 434         if ((ret = rigol_ds_get_dev_cfg(sdi)) < 0) {
 435                 sr_err("Failed to get device config: %s.", sr_strerror(ret));
 436                 return SR_ERR;
 437         }
 438
 439         sdi->status = SR_ST_ACTIVE;
 440
 441         return SR_OK;
 442 }
 443
 444 static int dev_close(struct sr_dev_inst *sdi)
 445 {
 446         struct sr_scpi_dev_inst *scpi;
 447         struct dev_context *devc;
 448
 449         if (sdi->status != SR_ST_ACTIVE)
 450                 return SR_ERR_DEV_CLOSED;
 451
 452         scpi = sdi->conn;
 453         devc = sdi->priv;
 454
 455         if (devc->model->series->protocol == PROTOCOL_V2)
 456                 rigol_ds_config_set(sdi, ":KEY:LOCK DISABLE");
 457
 458         if (scpi) {
 459                 if (sr_scpi_close(scpi) < 0)
 460                         return SR_ERR;
 461                 sdi->status = SR_ST_INACTIVE;
 462         }
 463
 464         return SR_OK;
 465 }
 466
 467 static int cleanup(const struct sr_dev_driver *di)
 468 {
 469         return dev_clear(di);
 470 }
 471
 472 static int analog_frame_size(const struct sr_dev_inst *sdi)
 473 {
 474         struct dev_context *devc = sdi->priv;
 475         struct sr_channel *ch;
 476         int analog_channels = 0;
 477         GSList *l;
 478
 479         for (l = sdi->channels; l; l = l->next) {
 480                 ch = l->data;
 481                 if (ch->type == SR_CHANNEL_ANALOG && ch->enabled)
 482                         analog_channels++;
 483         }
 484
 485         if (analog_channels == 0)
 486                 return 0;
 487
 488         switch (devc->data_source) {
 489         case DATA_SOURCE_LIVE:
 490                 return devc->model->series->live_samples;
 491         case DATA_SOURCE_MEMORY:
 492                 return devc->model->series->buffer_samples / analog_channels;
 493         default:
 494                 return 0;
 495         }
 496 }
 497
 498 static int digital_frame_size(const struct sr_dev_inst *sdi)
 499 {
 500         struct dev_context *devc = sdi->priv;
 501
 502         switch (devc->data_source) {
 503         case DATA_SOURCE_LIVE:
 504                 return devc->model->series->live_samples * 2;
 505         case DATA_SOURCE_MEMORY:
 506                 return devc->model->series->buffer_samples * 2;
 507         default:
 508                 return 0;
 509         }
 510 }
 511
 512 static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
 513                 const struct sr_channel_group *cg)
 514 {
 515         struct dev_context *devc;
 516         struct sr_channel *ch;
 517         const char *tmp_str;
 518         uint64_t samplerate;
 519         int analog_channel = -1;
 520         float smallest_diff = INFINITY;
 521         int idx = -1;
 522         unsigned i;
 523
 524         if (!sdi || !(devc = sdi->priv))
 525                 return SR_ERR_ARG;
 526
 527         /* If a channel group is specified, it must be a valid one. */
 528         if (cg && !g_slist_find(sdi->channel_groups, cg)) {
 529                 sr_err("Invalid channel group specified.");
 530                 return SR_ERR;
 531         }
 532
 533         if (cg) {
 534                 ch = g_slist_nth_data(cg->channels, 0);
 535                 if (!ch)
 536                         return SR_ERR;
 537                 if (ch->type == SR_CHANNEL_ANALOG) {
 538                         if (ch->name[2] < '1' || ch->name[2] > '4')
 539                                 return SR_ERR;
 540                         analog_channel = ch->name[2] - '1';
 541                 }
 542         }
 543
 544         switch (key) {
 545         case SR_CONF_NUM_HDIV:
 546                 *data = g_variant_new_int32(devc->model->series->num_horizontal_divs);
 547                 break;
 548         case SR_CONF_NUM_VDIV:
 549                 *data = g_variant_new_int32(devc->num_vdivs);
 550                 break;
 551         case SR_CONF_DATA_SOURCE:
 552                 if (devc->data_source == DATA_SOURCE_LIVE)
 553                         *data = g_variant_new_string("Live");
 554                 else if (devc->data_source == DATA_SOURCE_MEMORY)
 555                         *data = g_variant_new_string("Memory");
 556                 else
 557                         *data = g_variant_new_string("Segmented");
 558                 break;
 559         case SR_CONF_SAMPLERATE:
 560                 if (devc->data_source == DATA_SOURCE_LIVE) {
 561                         samplerate = analog_frame_size(sdi) /
 562                                 (devc->timebase * devc->model->series->num_horizontal_divs);
 563                         *data = g_variant_new_uint64(samplerate);
 564                 } else {
 565                         sr_dbg("Unknown data source: %d.", devc->data_source);
 566                         return SR_ERR_NA;
 567                 }
 568                 break;
 569         case SR_CONF_TRIGGER_SOURCE:
 570                 if (!strcmp(devc->trigger_source, "ACL"))
 571                         tmp_str = "AC Line";
 572                 else if (!strcmp(devc->trigger_source, "CHAN1"))
 573                         tmp_str = "CH1";
 574                 else if (!strcmp(devc->trigger_source, "CHAN2"))
 575                         tmp_str = "CH2";
 576                 else if (!strcmp(devc->trigger_source, "CHAN3"))
 577                         tmp_str = "CH3";
 578                 else if (!strcmp(devc->trigger_source, "CHAN4"))
 579                         tmp_str = "CH4";
 580                 else
 581                         tmp_str = devc->trigger_source;
 582                 *data = g_variant_new_string(tmp_str);
 583                 break;
 584         case SR_CONF_TRIGGER_SLOPE:
 585                 if (!strncmp(devc->trigger_slope, "POS", 3)) {
 586                         tmp_str = "r";
 587                 } else if (!strncmp(devc->trigger_slope, "NEG", 3)) {
 588                         tmp_str = "f";
 589                 } else {
 590                         sr_dbg("Unknown trigger slope: '%s'.", devc->trigger_slope);
 591                         return SR_ERR_NA;
 592                 }
 593                 *data = g_variant_new_string(tmp_str);
 594                 break;
 595         case SR_CONF_TIMEBASE:
 596                 for (i = 0; i < devc->num_timebases; i++) {
 597                         float tb = (float)devc->timebases[i][0] / devc->timebases[i][1];
 598                         float diff = fabs(devc->timebase - tb);
 599                         if (diff < smallest_diff) {
 600                                 smallest_diff = diff;
 601                                 idx = i;
 602                         }
 603                 }
 604                 if (idx < 0) {
 605                         sr_dbg("Negative timebase index: %d.", idx);
 606                         return SR_ERR_NA;
 607                 }
 608                 *data = g_variant_new("(tt)", devc->timebases[idx][0],
 609                                               devc->timebases[idx][1]);
 610                 break;
 611         case SR_CONF_VDIV:
 612                 if (analog_channel < 0) {
 613                         sr_dbg("Negative analog channel: %d.", analog_channel);
 614                         return SR_ERR_NA;
 615                 }
 616                 for (i = 0; i < ARRAY_SIZE(vdivs); i++) {
 617                         float vdiv = (float)vdivs[i][0] / vdivs[i][1];
 618                         float diff = fabs(devc->vdiv[analog_channel] - vdiv);
 619                         if (diff < smallest_diff) {
 620                                 smallest_diff = diff;
 621                                 idx = i;
 622                         }
 623                 }
 624                 if (idx < 0) {
 625                         sr_dbg("Negative vdiv index: %d.", idx);
 626                         return SR_ERR_NA;
 627                 }
 628                 *data = g_variant_new("(tt)", vdivs[idx][0], vdivs[idx][1]);
 629                 break;
 630         case SR_CONF_COUPLING:
 631                 if (analog_channel < 0) {
 632                         sr_dbg("Negative analog channel: %d.", analog_channel);
 633                         return SR_ERR_NA;
 634                 }
 635                 *data = g_variant_new_string(devc->coupling[analog_channel]);
 636                 break;
 637         default:
 638                 return SR_ERR_NA;
 639         }
 640
 641         return SR_OK;
 642 }
 643
 644 static int config_set(uint32_t key, GVariant *data, const struct sr_dev_inst *sdi,
 645                 const struct sr_channel_group *cg)
 646 {
 647         struct dev_context *devc;
 648         uint64_t p, q;
 649         double t_dbl;
 650         unsigned int i, j;
 651         int ret;
 652         const char *tmp_str;
 653         char buffer[16];
 654
 655         if (!(devc = sdi->priv))
 656                 return SR_ERR_ARG;
 657
 658         if (sdi->status != SR_ST_ACTIVE)
 659                 return SR_ERR_DEV_CLOSED;
 660
 661         /* If a channel group is specified, it must be a valid one. */
 662         if (cg && !g_slist_find(sdi->channel_groups, cg)) {
 663                 sr_err("Invalid channel group specified.");
 664                 return SR_ERR;
 665         }
 666
 667         ret = SR_OK;
 668         switch (key) {
 669         case SR_CONF_LIMIT_FRAMES:
 670                 devc->limit_frames = g_variant_get_uint64(data);
 671                 break;
 672         case SR_CONF_TRIGGER_SLOPE:
 673                 tmp_str = g_variant_get_string(data, NULL);
 674
 675                 if (!tmp_str || !(tmp_str[0] == 'f' || tmp_str[0] == 'r')) {
 676                         sr_err("Unknown trigger slope: '%s'.",
 677                                (tmp_str) ? tmp_str : "NULL");
 678                         return SR_ERR_ARG;
 679                 }
 680
 681                 g_free(devc->trigger_slope);
 682                 devc->trigger_slope = g_strdup((tmp_str[0] == 'r') ? "POS" : "NEG");
 683                 ret = rigol_ds_config_set(sdi, ":TRIG:EDGE:SLOP %s", devc->trigger_slope);
 684                 break;
 685         case SR_CONF_HORIZ_TRIGGERPOS:
 686                 t_dbl = g_variant_get_double(data);
 687                 if (t_dbl < 0.0 || t_dbl > 1.0) {
 688                         sr_err("Invalid horiz. trigger position: %g.", t_dbl);
 689                         return SR_ERR;
 690                 }
 691                 devc->horiz_triggerpos = t_dbl;
 692                 /* We have the trigger offset as a percentage of the frame, but
 693                  * need to express this in seconds. */
 694                 t_dbl = -(devc->horiz_triggerpos - 0.5) * devc->timebase * devc->num_timebases;
 695                 g_ascii_formatd(buffer, sizeof(buffer), "%.6f", t_dbl);
 696                 ret = rigol_ds_config_set(sdi, ":TIM:OFFS %s", buffer);
 697                 break;
 698         case SR_CONF_TIMEBASE:
 699                 g_variant_get(data, "(tt)", &p, &q);
 700                 for (i = 0; i < devc->num_timebases; i++) {
 701                         if (devc->timebases[i][0] == p && devc->timebases[i][1] == q) {
 702                                 devc->timebase = (float)p / q;
 703                                 g_ascii_formatd(buffer, sizeof(buffer), "%.9f",
 704                                                 devc->timebase);
 705                                 ret = rigol_ds_config_set(sdi, ":TIM:SCAL %s", buffer);
 706                                 break;
 707                         }
 708                 }
 709                 if (i == devc->num_timebases) {
 710                         sr_err("Invalid timebase index: %d.", i);
 711                         ret = SR_ERR_ARG;
 712                 }
 713                 break;
 714         case SR_CONF_TRIGGER_SOURCE:
 715                 tmp_str = g_variant_get_string(data, NULL);
 716                 for (i = 0; i < ARRAY_SIZE(trigger_sources); i++) {
 717                         if (!strcmp(trigger_sources[i], tmp_str)) {
 718                                 g_free(devc->trigger_source);
 719                                 devc->trigger_source = g_strdup(trigger_sources[i]);
 720                                 if (!strcmp(devc->trigger_source, "AC Line"))
 721                                         tmp_str = "ACL";
 722                                 else if (!strcmp(devc->trigger_source, "CH1"))
 723                                         tmp_str = "CHAN1";
 724                                 else if (!strcmp(devc->trigger_source, "CH2"))
 725                                         tmp_str = "CHAN2";
 726                                 else if (!strcmp(devc->trigger_source, "CH3"))
 727                                         tmp_str = "CHAN3";
 728                                 else if (!strcmp(devc->trigger_source, "CH4"))
 729                                         tmp_str = "CHAN4";
 730                                 else
 731                                         tmp_str = (char *)devc->trigger_source;
 732                                 ret = rigol_ds_config_set(sdi, ":TRIG:EDGE:SOUR %s", tmp_str);
 733                                 break;
 734                         }
 735                 }
 736                 if (i == ARRAY_SIZE(trigger_sources)) {
 737                         sr_err("Invalid trigger source index: %d.", i);
 738                         ret = SR_ERR_ARG;
 739                 }
 740                 break;
 741         case SR_CONF_VDIV:
 742                 if (!cg) {
 743                         sr_err("No channel group specified.");
 744                         return SR_ERR_CHANNEL_GROUP;
 745                 }
 746                 g_variant_get(data, "(tt)", &p, &q);
 747                 for (i = 0; i < devc->model->analog_channels; i++) {
 748                         if (cg == devc->analog_groups[i]) {
 749                                 for (j = 0; j < ARRAY_SIZE(vdivs); j++) {
 750                                         if (vdivs[j][0] != p || vdivs[j][1] != q)
 751                                                 continue;
 752                                         devc->vdiv[i] = (float)p / q;
 753                                         g_ascii_formatd(buffer, sizeof(buffer), "%.3f",
 754                                                         devc->vdiv[i]);
 755                                         return rigol_ds_config_set(sdi, ":CHAN%d:SCAL %s", i + 1,
 756                                                         buffer);
 757                                 }
 758                                 sr_err("Invalid vdiv index: %d.", j);
 759                                 return SR_ERR_ARG;
 760                         }
 761                 }
 762                 sr_dbg("Didn't set vdiv, unknown channel(group).");
 763                 return SR_ERR_NA;
 764         case SR_CONF_COUPLING:
 765                 if (!cg) {
 766                         sr_err("No channel group specified.");
 767                         return SR_ERR_CHANNEL_GROUP;
 768                 }
 769                 tmp_str = g_variant_get_string(data, NULL);
 770                 for (i = 0; i < devc->model->analog_channels; i++) {
 771                         if (cg == devc->analog_groups[i]) {
 772                                 for (j = 0; j < ARRAY_SIZE(coupling); j++) {
 773                                         if (!strcmp(tmp_str, coupling[j])) {
 774                                                 g_free(devc->coupling[i]);
 775                                                 devc->coupling[i] = g_strdup(coupling[j]);
 776                                                 return rigol_ds_config_set(sdi, ":CHAN%d:COUP %s", i + 1,
 777                                                                 devc->coupling[i]);
 778                                         }
 779                                 }
 780                                 sr_err("Invalid coupling index: %d.", j);
 781                                 return SR_ERR_ARG;
 782                         }
 783                 }
 784                 sr_dbg("Didn't set coupling, unknown channel(group).");
 785                 return SR_ERR_NA;
 786         case SR_CONF_DATA_SOURCE:
 787                 tmp_str = g_variant_get_string(data, NULL);
 788                 if (!strcmp(tmp_str, "Live"))
 789                         devc->data_source = DATA_SOURCE_LIVE;
 790                 else if (devc->model->series->protocol >= PROTOCOL_V2
 791                         && !strcmp(tmp_str, "Memory"))
 792                         devc->data_source = DATA_SOURCE_MEMORY;
 793                 else if (devc->model->series->protocol >= PROTOCOL_V3
 794                          && !strcmp(tmp_str, "Segmented"))
 795                         devc->data_source = DATA_SOURCE_SEGMENTED;
 796                 else {
 797                         sr_err("Unknown data source: '%s'.", tmp_str);
 798                         return SR_ERR;
 799                 }
 800                 break;
 801         default:
 802                 return SR_ERR_NA;
 803         }
 804
 805         return ret;
 806 }
 807
 808 static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
 809                 const struct sr_channel_group *cg)
 810 {
 811         GVariant *tuple, *rational[2];
 812         GVariantBuilder gvb;
 813         unsigned int i;
 814         struct dev_context *devc = NULL;
 815
 816         if (key == SR_CONF_SCAN_OPTIONS) {
 817                 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
 818                                 scanopts, ARRAY_SIZE(scanopts), sizeof(uint32_t));
 819                 return SR_OK;
 820         } else if (key == SR_CONF_DEVICE_OPTIONS && !cg) {
 821                 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
 822                                 devopts, ARRAY_SIZE(devopts), sizeof(uint32_t));
 823                 return SR_OK;
 824         }
 825
 826         /* Every other option requires a valid device instance. */
 827         if (!sdi || !(devc = sdi->priv))
 828                 return SR_ERR_ARG;
 829
 830         /* If a channel group is specified, it must be a valid one. */
 831         if (cg && !g_slist_find(sdi->channel_groups, cg)) {
 832                 sr_err("Invalid channel group specified.");
 833                 return SR_ERR;
 834         }
 835
 836         switch (key) {
 837         case SR_CONF_DEVICE_OPTIONS:
 838                 if (!cg) {
 839                         sr_err("No channel group specified.");
 840                         return SR_ERR_CHANNEL_GROUP;
 841                 }
 842                 if (cg == devc->digital_group) {
 843                         *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
 844                                 NULL, 0, sizeof(uint32_t));
 845                         return SR_OK;
 846                 } else {
 847                         for (i = 0; i < devc->model->analog_channels; i++) {
 848                                 if (cg == devc->analog_groups[i]) {
 849                                         *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
 850                                                 analog_devopts, ARRAY_SIZE(analog_devopts), sizeof(uint32_t));
 851                                         return SR_OK;
 852                                 }
 853                         }
 854                         return SR_ERR_NA;
 855                 }
 856                 break;
 857         case SR_CONF_COUPLING:
 858                 if (!cg) {
 859                         sr_err("No channel group specified.");
 860                         return SR_ERR_CHANNEL_GROUP;
 861                 }
 862                 *data = g_variant_new_strv(coupling, ARRAY_SIZE(coupling));
 863                 break;
 864         case SR_CONF_VDIV:
 865                 if (!devc)
 866                         /* Can't know this until we have the exact model. */
 867                         return SR_ERR_ARG;
 868                 if (!cg) {
 869                         sr_err("No channel group specified.");
 870                         return SR_ERR_CHANNEL_GROUP;
 871                 }
 872                 g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
 873                 for (i = 0; i < devc->num_vdivs; i++) {
 874                         rational[0] = g_variant_new_uint64(devc->vdivs[i][0]);
 875                         rational[1] = g_variant_new_uint64(devc->vdivs[i][1]);
 876                         tuple = g_variant_new_tuple(rational, 2);
 877                         g_variant_builder_add_value(&gvb, tuple);
 878                 }
 879                 *data = g_variant_builder_end(&gvb);
 880                 break;
 881         case SR_CONF_TIMEBASE:
 882                 if (!devc)
 883                         /* Can't know this until we have the exact model. */
 884                         return SR_ERR_ARG;
 885                 if (devc->num_timebases <= 0)
 886                         return SR_ERR_NA;
 887                 g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
 888                 for (i = 0; i < devc->num_timebases; i++) {
 889                         rational[0] = g_variant_new_uint64(devc->timebases[i][0]);
 890                         rational[1] = g_variant_new_uint64(devc->timebases[i][1]);
 891                         tuple = g_variant_new_tuple(rational, 2);
 892                         g_variant_builder_add_value(&gvb, tuple);
 893                 }
 894                 *data = g_variant_builder_end(&gvb);
 895                 break;
 896         case SR_CONF_TRIGGER_SOURCE:
 897                 if (!devc)
 898                         /* Can't know this until we have the exact model. */
 899                         return SR_ERR_ARG;
 900                 *data = g_variant_new_strv(trigger_sources,
 901                                 devc->model->has_digital ? ARRAY_SIZE(trigger_sources) : 4);
 902                 break;
 903         case SR_CONF_TRIGGER_SLOPE:
 904                 *data = g_variant_new_strv(trigger_slopes, ARRAY_SIZE(trigger_slopes));
 905                 break;
 906         case SR_CONF_DATA_SOURCE:
 907                 if (!devc)
 908                         /* Can't know this until we have the exact model. */
 909                         return SR_ERR_ARG;
 910                 switch (devc->model->series->protocol) {
 911                 case PROTOCOL_V1:
 912                         *data = g_variant_new_strv(data_sources, ARRAY_SIZE(data_sources) - 2);
 913                         break;
 914                 case PROTOCOL_V2:
 915                         *data = g_variant_new_strv(data_sources, ARRAY_SIZE(data_sources) - 1);
 916                         break;
 917                 default:
 918                         *data = g_variant_new_strv(data_sources, ARRAY_SIZE(data_sources));
 919                         break;
 920                 }
 921                 break;
 922         default:
 923                 return SR_ERR_NA;
 924         }
 925
 926         return SR_OK;
 927 }
 928
 929 static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
 930 {
 931         struct sr_scpi_dev_inst *scpi;
 932         struct dev_context *devc;
 933         struct sr_channel *ch;
 934         struct sr_datafeed_packet packet;
 935         gboolean some_digital;
 936         GSList *l;
 937
 938         if (sdi->status != SR_ST_ACTIVE)
 939                 return SR_ERR_DEV_CLOSED;
 940
 941         scpi = sdi->conn;
 942         devc = sdi->priv;
 943
 944         devc->num_frames = 0;
 945
 946         some_digital = FALSE;
 947         for (l = sdi->channels; l; l = l->next) {
 948                 ch = l->data;
 949                 sr_dbg("handling channel %s", ch->name);
 950                 if (ch->type == SR_CHANNEL_ANALOG) {
 951                         if (ch->enabled)
 952                                 devc->enabled_channels = g_slist_append(
 953                                                 devc->enabled_channels, ch);
 954                         if (ch->enabled != devc->analog_channels[ch->index]) {
 955                                 /* Enabled channel is currently disabled, or vice versa. */
 956                                 if (rigol_ds_config_set(sdi, ":CHAN%d:DISP %s", ch->index + 1,
 957                                                 ch->enabled ? "ON" : "OFF") != SR_OK)
 958                                         return SR_ERR;
 959                                 devc->analog_channels[ch->index] = ch->enabled;
 960                         }
 961                 } else if (ch->type == SR_CHANNEL_LOGIC) {
 962                         /* Only one list entry for DS1000D series. All channels are retrieved
 963                          * together when this entry is processed. */
 964                         if (ch->enabled && (
 965                                                 devc->model->series->protocol > PROTOCOL_V2 ||
 966                                                 !some_digital))
 967                                 devc->enabled_channels = g_slist_append(
 968                                                 devc->enabled_channels, ch);
 969                         if (ch->enabled) {
 970                                 some_digital = TRUE;
 971                                 /* Turn on LA module if currently off. */
 972                                 if (!devc->la_enabled) {
 973                                         if (rigol_ds_config_set(sdi,
 974                                                         devc->model->series->protocol >= PROTOCOL_V4 ?
 975                                                                 ":LA:STAT ON" : ":LA:DISP ON") != SR_OK)
 976                                                 return SR_ERR;
 977                                         devc->la_enabled = TRUE;
 978                                 }
 979                         }
 980                         if (ch->enabled != devc->digital_channels[ch->index]) {
 981                                 /* Enabled channel is currently disabled, or vice versa. */
 982                                 if (rigol_ds_config_set(sdi,
 983                                                 devc->model->series->protocol >= PROTOCOL_V4 ?
 984                                                         ":LA:DIG%d:DISP %s" : ":DIG%d:TURN %s", ch->index,
 985                                                 ch->enabled ? "ON" : "OFF") != SR_OK)
 986                                         return SR_ERR;
 987                                 devc->digital_channels[ch->index] = ch->enabled;
 988                         }
 989                 }
 990         }
 991
 992         if (!devc->enabled_channels)
 993                 return SR_ERR;
 994
 995         /* Turn off LA module if on and no digital channels selected. */
 996         if (devc->la_enabled && !some_digital)
 997                 if (rigol_ds_config_set(sdi,
 998                                 devc->model->series->protocol >= PROTOCOL_V4 ?
 999                                         ":LA:STAT OFF" : ":LA:DISP OFF") != SR_OK)
1000                         return SR_ERR;
1001
1002         /* Set memory mode. */
1003         if (devc->data_source == DATA_SOURCE_SEGMENTED) {
1004                 sr_err("Data source 'Segmented' not yet supported");
1005                 return SR_ERR;
1006         }
1007
1008         devc->analog_frame_size = analog_frame_size(sdi);
1009         devc->digital_frame_size = digital_frame_size(sdi);
1010
1011         switch (devc->model->series->protocol) {
1012         case PROTOCOL_V2:
1013                 if (rigol_ds_config_set(sdi, ":ACQ:MEMD LONG") != SR_OK)
1014                         return SR_ERR;
1015                 break;
1016         case PROTOCOL_V3:
1017                 /* Apparently for the DS2000 the memory
1018                  * depth can only be set in Running state -
1019                  * this matches the behaviour of the UI. */
1020                 if (rigol_ds_config_set(sdi, ":RUN") != SR_OK)
1021                         return SR_ERR;
1022                 if (rigol_ds_config_set(sdi, ":ACQ:MDEP %d",
1023                                         devc->analog_frame_size) != SR_OK)
1024                         return SR_ERR;
1025                 if (rigol_ds_config_set(sdi, ":STOP") != SR_OK)
1026                         return SR_ERR;
1027                 break;
1028         default:
1029                 break;
1030         }
1031
1032         if (devc->data_source == DATA_SOURCE_LIVE)
1033                 if (rigol_ds_config_set(sdi, ":RUN") != SR_OK)
1034                         return SR_ERR;
1035
1036         sr_scpi_source_add(sdi->session, scpi, G_IO_IN, 50,
1037                         rigol_ds_receive, (void *)sdi);
1038
1039         /* Send header packet to the session bus. */
1040         std_session_send_df_header(cb_data, LOG_PREFIX);
1041
1042         devc->channel_entry = devc->enabled_channels;
1043
1044         if (rigol_ds_capture_start(sdi) != SR_OK)
1045                 return SR_ERR;
1046
1047         /* Start of first frame. */
1048         packet.type = SR_DF_FRAME_BEGIN;
1049         sr_session_send(cb_data, &packet);
1050
1051         return SR_OK;
1052 }
1053
1054 static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
1055 {
1056         struct dev_context *devc;
1057         struct sr_scpi_dev_inst *scpi;
1058         struct sr_datafeed_packet packet;
1059
1060         (void)cb_data;
1061
1062         devc = sdi->priv;
1063
1064         if (sdi->status != SR_ST_ACTIVE) {
1065                 sr_err("Device inactive, can't stop acquisition.");
1066                 return SR_ERR;
1067         }
1068
1069         /* End of last frame. */
1070         packet.type = SR_DF_END;
1071         sr_session_send(sdi, &packet);
1072
1073         g_slist_free(devc->enabled_channels);
1074         devc->enabled_channels = NULL;
1075         scpi = sdi->conn;
1076         sr_scpi_source_remove(sdi->session, scpi);
1077
1078         return SR_OK;
1079 }
1080
1081 SR_PRIV struct sr_dev_driver rigol_ds_driver_info = {
1082         .name = "rigol-ds",
1083         .longname = "Rigol DS",
1084         .api_version = 1,
1085         .init = init,
1086         .cleanup = cleanup,
1087         .scan = scan,
1088         .dev_list = dev_list,
1089         .dev_clear = dev_clear,
1090         .config_get = config_get,
1091         .config_set = config_set,
1092         .config_list = config_list,
1093         .dev_open = dev_open,
1094         .dev_close = dev_close,
1095         .dev_acquisition_start = dev_acquisition_start,
1096         .dev_acquisition_stop = dev_acquisition_stop,
1097         .context = NULL,
1098 };