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