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 struct sr_dev_inst *probe_device(struct sr_scpi_dev_inst *scpi)
 276 {
 277         struct dev_context *devc;
 278         struct sr_dev_inst *sdi;
 279         struct sr_scpi_hw_info *hw_info;
 280         struct sr_channel *ch;
 281         long n[3];
 282         unsigned int i;
 283         const struct rigol_ds_model *model = NULL;
 284         gchar *channel_name, **version;
 285
 286         if (sr_scpi_get_hw_id(scpi, &hw_info) != SR_OK) {
 287                 sr_info("Couldn't get IDN response, retrying.");
 288                 sr_scpi_close(scpi);
 289                 sr_scpi_open(scpi);
 290                 if (sr_scpi_get_hw_id(scpi, &hw_info) != SR_OK) {
 291                         sr_info("Couldn't get IDN response.");
 292                         return NULL;
 293                 }
 294         }
 295
 296         for (i = 0; i < ARRAY_SIZE(supported_models); i++) {
 297                 if (!g_ascii_strcasecmp(hw_info->manufacturer,
 298                                         supported_models[i].series->vendor->full_name) &&
 299                                 !strcmp(hw_info->model, supported_models[i].name)) {
 300                         model = &supported_models[i];
 301                         break;
 302                 }
 303         }
 304
 305         if (!model) {
 306                 sr_scpi_hw_info_free(hw_info);
 307                 return NULL;
 308         }
 309
 310         sdi = g_malloc0(sizeof(struct sr_dev_inst));
 311         sdi->vendor = g_strdup(model->series->vendor->name);
 312         sdi->model = g_strdup(model->name);
 313         sdi->version = g_strdup(hw_info->firmware_version);
 314         sdi->conn = scpi;
 315         sdi->driver = &rigol_ds_driver_info;
 316         sdi->inst_type = SR_INST_SCPI;
 317         sdi->serial_num = g_strdup(hw_info->serial_number);
 318         devc = g_malloc0(sizeof(struct dev_context));
 319         devc->limit_frames = 0;
 320         devc->model = model;
 321         devc->format = model->series->format;
 322
 323         /* DS1000 models with firmware before 0.2.4 used the old data format. */
 324         if (model->series == SERIES(DS1000)) {
 325                 version = g_strsplit(hw_info->firmware_version, ".", 0);
 326                 do {
 327                         if (!version[0] || !version[1] || !version[2])
 328                                 break;
 329                         if (version[0][0] == 0 || version[1][0] == 0 || version[2][0] == 0)
 330                                 break;
 331                         for (i = 0; i < 3; i++) {
 332                                 if (sr_atol(version[i], &n[i]) != SR_OK)
 333                                         break;
 334                         }
 335                         if (i != 3)
 336                                 break;
 337                         scpi->firmware_version = n[0] * 100 + n[1] * 10 + n[2];
 338                         if (scpi->firmware_version < 24) {
 339                                 sr_dbg("Found DS1000 firmware < 0.2.4, using raw data format.");
 340                                 devc->format = FORMAT_RAW;
 341                         }
 342                         break;
 343                 } while (0);
 344                 g_strfreev(version);
 345         }
 346
 347         sr_scpi_hw_info_free(hw_info);
 348
 349         devc->analog_groups = g_malloc0(sizeof(struct sr_channel_group*) *
 350                                         model->analog_channels);
 351
 352         for (i = 0; i < model->analog_channels; i++) {
 353                 channel_name = g_strdup_printf("CH%d", i + 1);
 354                 ch = sr_channel_new(sdi, i, SR_CHANNEL_ANALOG, TRUE, channel_name);
 355
 356                 devc->analog_groups[i] = g_malloc0(sizeof(struct sr_channel_group));
 357
 358                 devc->analog_groups[i]->name = channel_name;
 359                 devc->analog_groups[i]->channels = g_slist_append(NULL, ch);
 360                 sdi->channel_groups = g_slist_append(sdi->channel_groups,
 361                                 devc->analog_groups[i]);
 362         }
 363
 364         if (devc->model->has_digital) {
 365                 devc->digital_group = g_malloc0(sizeof(struct sr_channel_group));
 366
 367                 for (i = 0; i < ARRAY_SIZE(devc->digital_channels); i++) {
 368                         channel_name = g_strdup_printf("D%d", i);
 369                         ch = sr_channel_new(sdi, i, SR_CHANNEL_LOGIC, TRUE, channel_name);
 370                         g_free(channel_name);
 371                         devc->digital_group->channels = g_slist_append(
 372                                         devc->digital_group->channels, ch);
 373                 }
 374                 devc->digital_group->name = g_strdup("LA");
 375                 sdi->channel_groups = g_slist_append(sdi->channel_groups,
 376                                 devc->digital_group);
 377         }
 378
 379         for (i = 0; i < NUM_TIMEBASE; i++) {
 380                 if (!memcmp(&devc->model->min_timebase, &timebases[i], sizeof(uint64_t[2])))
 381                         devc->timebases = &timebases[i];
 382                 if (!memcmp(&devc->model->series->max_timebase, &timebases[i], sizeof(uint64_t[2])))
 383                         devc->num_timebases = &timebases[i] - devc->timebases + 1;
 384         }
 385
 386         for (i = 0; i < NUM_VDIV; i++) {
 387                 if (!memcmp(&devc->model->series->min_vdiv,
 388                                         &vdivs[i], sizeof(uint64_t[2]))) {
 389                         devc->vdivs = &vdivs[i];
 390                         devc->num_vdivs = NUM_VDIV - i;
 391                 }
 392         }
 393
 394         devc->buffer = g_malloc(ACQ_BUFFER_SIZE);
 395         devc->data = g_malloc(ACQ_BUFFER_SIZE * sizeof(float));
 396
 397         devc->data_source = DATA_SOURCE_LIVE;
 398
 399         sdi->priv = devc;
 400
 401         return sdi;
 402 }
 403
 404 static GSList *scan(struct sr_dev_driver *di, GSList *options)
 405 {
 406         return sr_scpi_scan(di->context, options, probe_device);
 407 }
 408
 409 static int dev_open(struct sr_dev_inst *sdi)
 410 {
 411         int ret;
 412         struct sr_scpi_dev_inst *scpi = sdi->conn;
 413
 414         if ((ret = sr_scpi_open(scpi)) < 0) {
 415                 sr_err("Failed to open SCPI device: %s.", sr_strerror(ret));
 416                 return SR_ERR;
 417         }
 418
 419         if ((ret = rigol_ds_get_dev_cfg(sdi)) < 0) {
 420                 sr_err("Failed to get device config: %s.", sr_strerror(ret));
 421                 return SR_ERR;
 422         }
 423
 424         sdi->status = SR_ST_ACTIVE;
 425
 426         return SR_OK;
 427 }
 428
 429 static int dev_close(struct sr_dev_inst *sdi)
 430 {
 431         struct sr_scpi_dev_inst *scpi;
 432         struct dev_context *devc;
 433
 434         if (sdi->status != SR_ST_ACTIVE)
 435                 return SR_ERR_DEV_CLOSED;
 436
 437         scpi = sdi->conn;
 438         devc = sdi->priv;
 439
 440         if (devc->model->series->protocol == PROTOCOL_V2)
 441                 rigol_ds_config_set(sdi, ":KEY:LOCK DISABLE");
 442
 443         if (scpi) {
 444                 if (sr_scpi_close(scpi) < 0)
 445                         return SR_ERR;
 446                 sdi->status = SR_ST_INACTIVE;
 447         }
 448
 449         return SR_OK;
 450 }
 451
 452 static int analog_frame_size(const struct sr_dev_inst *sdi)
 453 {
 454         struct dev_context *devc = sdi->priv;
 455         struct sr_channel *ch;
 456         int analog_channels = 0;
 457         GSList *l;
 458
 459         for (l = sdi->channels; l; l = l->next) {
 460                 ch = l->data;
 461                 if (ch->type == SR_CHANNEL_ANALOG && ch->enabled)
 462                         analog_channels++;
 463         }
 464
 465         if (analog_channels == 0)
 466                 return 0;
 467
 468         switch (devc->data_source) {
 469         case DATA_SOURCE_LIVE:
 470                 return devc->model->series->live_samples;
 471         case DATA_SOURCE_MEMORY:
 472                 return devc->model->series->buffer_samples / analog_channels;
 473         default:
 474                 return 0;
 475         }
 476 }
 477
 478 static int digital_frame_size(const struct sr_dev_inst *sdi)
 479 {
 480         struct dev_context *devc = sdi->priv;
 481
 482         switch (devc->data_source) {
 483         case DATA_SOURCE_LIVE:
 484                 return devc->model->series->live_samples * 2;
 485         case DATA_SOURCE_MEMORY:
 486                 return devc->model->series->buffer_samples * 2;
 487         default:
 488                 return 0;
 489         }
 490 }
 491
 492 static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
 493                 const struct sr_channel_group *cg)
 494 {
 495         struct dev_context *devc;
 496         struct sr_channel *ch;
 497         const char *tmp_str;
 498         uint64_t samplerate;
 499         int analog_channel = -1;
 500         float smallest_diff = INFINITY;
 501         int idx = -1;
 502         unsigned i;
 503
 504         if (!sdi || !(devc = sdi->priv))
 505                 return SR_ERR_ARG;
 506
 507         /* If a channel group is specified, it must be a valid one. */
 508         if (cg && !g_slist_find(sdi->channel_groups, cg)) {
 509                 sr_err("Invalid channel group specified.");
 510                 return SR_ERR;
 511         }
 512
 513         if (cg) {
 514                 ch = g_slist_nth_data(cg->channels, 0);
 515                 if (!ch)
 516                         return SR_ERR;
 517                 if (ch->type == SR_CHANNEL_ANALOG) {
 518                         if (ch->name[2] < '1' || ch->name[2] > '4')
 519                                 return SR_ERR;
 520                         analog_channel = ch->name[2] - '1';
 521                 }
 522         }
 523
 524         switch (key) {
 525         case SR_CONF_NUM_HDIV:
 526                 *data = g_variant_new_int32(devc->model->series->num_horizontal_divs);
 527                 break;
 528         case SR_CONF_NUM_VDIV:
 529                 *data = g_variant_new_int32(devc->num_vdivs);
 530                 break;
 531         case SR_CONF_DATA_SOURCE:
 532                 if (devc->data_source == DATA_SOURCE_LIVE)
 533                         *data = g_variant_new_string("Live");
 534                 else if (devc->data_source == DATA_SOURCE_MEMORY)
 535                         *data = g_variant_new_string("Memory");
 536                 else
 537                         *data = g_variant_new_string("Segmented");
 538                 break;
 539         case SR_CONF_SAMPLERATE:
 540                 if (devc->data_source == DATA_SOURCE_LIVE) {
 541                         samplerate = analog_frame_size(sdi) /
 542                                 (devc->timebase * devc->model->series->num_horizontal_divs);
 543                         *data = g_variant_new_uint64(samplerate);
 544                 } else {
 545                         sr_dbg("Unknown data source: %d.", devc->data_source);
 546                         return SR_ERR_NA;
 547                 }
 548                 break;
 549         case SR_CONF_TRIGGER_SOURCE:
 550                 if (!strcmp(devc->trigger_source, "ACL"))
 551                         tmp_str = "AC Line";
 552                 else if (!strcmp(devc->trigger_source, "CHAN1"))
 553                         tmp_str = "CH1";
 554                 else if (!strcmp(devc->trigger_source, "CHAN2"))
 555                         tmp_str = "CH2";
 556                 else if (!strcmp(devc->trigger_source, "CHAN3"))
 557                         tmp_str = "CH3";
 558                 else if (!strcmp(devc->trigger_source, "CHAN4"))
 559                         tmp_str = "CH4";
 560                 else
 561                         tmp_str = devc->trigger_source;
 562                 *data = g_variant_new_string(tmp_str);
 563                 break;
 564         case SR_CONF_TRIGGER_SLOPE:
 565                 if (!strncmp(devc->trigger_slope, "POS", 3)) {
 566                         tmp_str = "r";
 567                 } else if (!strncmp(devc->trigger_slope, "NEG", 3)) {
 568                         tmp_str = "f";
 569                 } else {
 570                         sr_dbg("Unknown trigger slope: '%s'.", devc->trigger_slope);
 571                         return SR_ERR_NA;
 572                 }
 573                 *data = g_variant_new_string(tmp_str);
 574                 break;
 575         case SR_CONF_TIMEBASE:
 576                 for (i = 0; i < devc->num_timebases; i++) {
 577                         float tb = (float)devc->timebases[i][0] / devc->timebases[i][1];
 578                         float diff = fabs(devc->timebase - tb);
 579                         if (diff < smallest_diff) {
 580                                 smallest_diff = diff;
 581                                 idx = i;
 582                         }
 583                 }
 584                 if (idx < 0) {
 585                         sr_dbg("Negative timebase index: %d.", idx);
 586                         return SR_ERR_NA;
 587                 }
 588                 *data = g_variant_new("(tt)", devc->timebases[idx][0],
 589                                               devc->timebases[idx][1]);
 590                 break;
 591         case SR_CONF_VDIV:
 592                 if (analog_channel < 0) {
 593                         sr_dbg("Negative analog channel: %d.", analog_channel);
 594                         return SR_ERR_NA;
 595                 }
 596                 for (i = 0; i < ARRAY_SIZE(vdivs); i++) {
 597                         float vdiv = (float)vdivs[i][0] / vdivs[i][1];
 598                         float diff = fabs(devc->vdiv[analog_channel] - vdiv);
 599                         if (diff < smallest_diff) {
 600                                 smallest_diff = diff;
 601                                 idx = i;
 602                         }
 603                 }
 604                 if (idx < 0) {
 605                         sr_dbg("Negative vdiv index: %d.", idx);
 606                         return SR_ERR_NA;
 607                 }
 608                 *data = g_variant_new("(tt)", vdivs[idx][0], vdivs[idx][1]);
 609                 break;
 610         case SR_CONF_COUPLING:
 611                 if (analog_channel < 0) {
 612                         sr_dbg("Negative analog channel: %d.", analog_channel);
 613                         return SR_ERR_NA;
 614                 }
 615                 *data = g_variant_new_string(devc->coupling[analog_channel]);
 616                 break;
 617         default:
 618                 return SR_ERR_NA;
 619         }
 620
 621         return SR_OK;
 622 }
 623
 624 static int config_set(uint32_t key, GVariant *data, const struct sr_dev_inst *sdi,
 625                 const struct sr_channel_group *cg)
 626 {
 627         struct dev_context *devc;
 628         uint64_t p, q;
 629         double t_dbl;
 630         unsigned int i, j;
 631         int ret;
 632         const char *tmp_str;
 633         char buffer[16];
 634
 635         devc = sdi->priv;
 636
 637         if (sdi->status != SR_ST_ACTIVE)
 638                 return SR_ERR_DEV_CLOSED;
 639
 640         /* If a channel group is specified, it must be a valid one. */
 641         if (cg && !g_slist_find(sdi->channel_groups, cg)) {
 642                 sr_err("Invalid channel group specified.");
 643                 return SR_ERR;
 644         }
 645
 646         ret = SR_OK;
 647         switch (key) {
 648         case SR_CONF_LIMIT_FRAMES:
 649                 devc->limit_frames = g_variant_get_uint64(data);
 650                 break;
 651         case SR_CONF_TRIGGER_SLOPE:
 652                 tmp_str = g_variant_get_string(data, NULL);
 653
 654                 if (!tmp_str || !(tmp_str[0] == 'f' || tmp_str[0] == 'r')) {
 655                         sr_err("Unknown trigger slope: '%s'.",
 656                                (tmp_str) ? tmp_str : "NULL");
 657                         return SR_ERR_ARG;
 658                 }
 659
 660                 g_free(devc->trigger_slope);
 661                 devc->trigger_slope = g_strdup((tmp_str[0] == 'r') ? "POS" : "NEG");
 662                 ret = rigol_ds_config_set(sdi, ":TRIG:EDGE:SLOP %s", devc->trigger_slope);
 663                 break;
 664         case SR_CONF_HORIZ_TRIGGERPOS:
 665                 t_dbl = g_variant_get_double(data);
 666                 if (t_dbl < 0.0 || t_dbl > 1.0) {
 667                         sr_err("Invalid horiz. trigger position: %g.", t_dbl);
 668                         return SR_ERR;
 669                 }
 670                 devc->horiz_triggerpos = t_dbl;
 671                 /* We have the trigger offset as a percentage of the frame, but
 672                  * need to express this in seconds. */
 673                 t_dbl = -(devc->horiz_triggerpos - 0.5) * devc->timebase * devc->num_timebases;
 674                 g_ascii_formatd(buffer, sizeof(buffer), "%.6f", t_dbl);
 675                 ret = rigol_ds_config_set(sdi, ":TIM:OFFS %s", buffer);
 676                 break;
 677         case SR_CONF_TIMEBASE:
 678                 g_variant_get(data, "(tt)", &p, &q);
 679                 for (i = 0; i < devc->num_timebases; i++) {
 680                         if (devc->timebases[i][0] == p && devc->timebases[i][1] == q) {
 681                                 devc->timebase = (float)p / q;
 682                                 g_ascii_formatd(buffer, sizeof(buffer), "%.9f",
 683                                                 devc->timebase);
 684                                 ret = rigol_ds_config_set(sdi, ":TIM:SCAL %s", buffer);
 685                                 break;
 686                         }
 687                 }
 688                 if (i == devc->num_timebases) {
 689                         sr_err("Invalid timebase index: %d.", i);
 690                         ret = SR_ERR_ARG;
 691                 }
 692                 break;
 693         case SR_CONF_TRIGGER_SOURCE:
 694                 tmp_str = g_variant_get_string(data, NULL);
 695                 for (i = 0; i < ARRAY_SIZE(trigger_sources); i++) {
 696                         if (!strcmp(trigger_sources[i], tmp_str)) {
 697                                 g_free(devc->trigger_source);
 698                                 devc->trigger_source = g_strdup(trigger_sources[i]);
 699                                 if (!strcmp(devc->trigger_source, "AC Line"))
 700                                         tmp_str = "ACL";
 701                                 else if (!strcmp(devc->trigger_source, "CH1"))
 702                                         tmp_str = "CHAN1";
 703                                 else if (!strcmp(devc->trigger_source, "CH2"))
 704                                         tmp_str = "CHAN2";
 705                                 else if (!strcmp(devc->trigger_source, "CH3"))
 706                                         tmp_str = "CHAN3";
 707                                 else if (!strcmp(devc->trigger_source, "CH4"))
 708                                         tmp_str = "CHAN4";
 709                                 else
 710                                         tmp_str = (char *)devc->trigger_source;
 711                                 ret = rigol_ds_config_set(sdi, ":TRIG:EDGE:SOUR %s", tmp_str);
 712                                 break;
 713                         }
 714                 }
 715                 if (i == ARRAY_SIZE(trigger_sources)) {
 716                         sr_err("Invalid trigger source index: %d.", i);
 717                         ret = SR_ERR_ARG;
 718                 }
 719                 break;
 720         case SR_CONF_VDIV:
 721                 if (!cg) {
 722                         sr_err("No channel group specified.");
 723                         return SR_ERR_CHANNEL_GROUP;
 724                 }
 725                 g_variant_get(data, "(tt)", &p, &q);
 726                 for (i = 0; i < devc->model->analog_channels; i++) {
 727                         if (cg == devc->analog_groups[i]) {
 728                                 for (j = 0; j < ARRAY_SIZE(vdivs); j++) {
 729                                         if (vdivs[j][0] != p || vdivs[j][1] != q)
 730                                                 continue;
 731                                         devc->vdiv[i] = (float)p / q;
 732                                         g_ascii_formatd(buffer, sizeof(buffer), "%.3f",
 733                                                         devc->vdiv[i]);
 734                                         return rigol_ds_config_set(sdi, ":CHAN%d:SCAL %s", i + 1,
 735                                                         buffer);
 736                                 }
 737                                 sr_err("Invalid vdiv index: %d.", j);
 738                                 return SR_ERR_ARG;
 739                         }
 740                 }
 741                 sr_dbg("Didn't set vdiv, unknown channel(group).");
 742                 return SR_ERR_NA;
 743         case SR_CONF_COUPLING:
 744                 if (!cg) {
 745                         sr_err("No channel group specified.");
 746                         return SR_ERR_CHANNEL_GROUP;
 747                 }
 748                 tmp_str = g_variant_get_string(data, NULL);
 749                 for (i = 0; i < devc->model->analog_channels; i++) {
 750                         if (cg == devc->analog_groups[i]) {
 751                                 for (j = 0; j < ARRAY_SIZE(coupling); j++) {
 752                                         if (!strcmp(tmp_str, coupling[j])) {
 753                                                 g_free(devc->coupling[i]);
 754                                                 devc->coupling[i] = g_strdup(coupling[j]);
 755                                                 return rigol_ds_config_set(sdi, ":CHAN%d:COUP %s", i + 1,
 756                                                                 devc->coupling[i]);
 757                                         }
 758                                 }
 759                                 sr_err("Invalid coupling index: %d.", j);
 760                                 return SR_ERR_ARG;
 761                         }
 762                 }
 763                 sr_dbg("Didn't set coupling, unknown channel(group).");
 764                 return SR_ERR_NA;
 765         case SR_CONF_DATA_SOURCE:
 766                 tmp_str = g_variant_get_string(data, NULL);
 767                 if (!strcmp(tmp_str, "Live"))
 768                         devc->data_source = DATA_SOURCE_LIVE;
 769                 else if (devc->model->series->protocol >= PROTOCOL_V2
 770                         && !strcmp(tmp_str, "Memory"))
 771                         devc->data_source = DATA_SOURCE_MEMORY;
 772                 else if (devc->model->series->protocol >= PROTOCOL_V3
 773                          && !strcmp(tmp_str, "Segmented"))
 774                         devc->data_source = DATA_SOURCE_SEGMENTED;
 775                 else {
 776                         sr_err("Unknown data source: '%s'.", tmp_str);
 777                         return SR_ERR;
 778                 }
 779                 break;
 780         default:
 781                 return SR_ERR_NA;
 782         }
 783
 784         return ret;
 785 }
 786
 787 static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
 788                 const struct sr_channel_group *cg)
 789 {
 790         GVariant *tuple, *rational[2];
 791         GVariantBuilder gvb;
 792         unsigned int i;
 793         struct dev_context *devc = NULL;
 794
 795         if (key == SR_CONF_SCAN_OPTIONS) {
 796                 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
 797                                 scanopts, ARRAY_SIZE(scanopts), sizeof(uint32_t));
 798                 return SR_OK;
 799         } else if (key == SR_CONF_DEVICE_OPTIONS && !cg) {
 800                 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
 801                                 devopts, ARRAY_SIZE(devopts), sizeof(uint32_t));
 802                 return SR_OK;
 803         }
 804
 805         /* Every other option requires a valid device instance. */
 806         if (!sdi || !(devc = sdi->priv))
 807                 return SR_ERR_ARG;
 808
 809         /* If a channel group is specified, it must be a valid one. */
 810         if (cg && !g_slist_find(sdi->channel_groups, cg)) {
 811                 sr_err("Invalid channel group specified.");
 812                 return SR_ERR;
 813         }
 814
 815         switch (key) {
 816         case SR_CONF_DEVICE_OPTIONS:
 817                 if (!cg) {
 818                         sr_err("No channel group specified.");
 819                         return SR_ERR_CHANNEL_GROUP;
 820                 }
 821                 if (cg == devc->digital_group) {
 822                         *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
 823                                 NULL, 0, sizeof(uint32_t));
 824                         return SR_OK;
 825                 } else {
 826                         for (i = 0; i < devc->model->analog_channels; i++) {
 827                                 if (cg == devc->analog_groups[i]) {
 828                                         *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
 829                                                 analog_devopts, ARRAY_SIZE(analog_devopts), sizeof(uint32_t));
 830                                         return SR_OK;
 831                                 }
 832                         }
 833                         return SR_ERR_NA;
 834                 }
 835                 break;
 836         case SR_CONF_COUPLING:
 837                 if (!cg) {
 838                         sr_err("No channel group specified.");
 839                         return SR_ERR_CHANNEL_GROUP;
 840                 }
 841                 *data = g_variant_new_strv(coupling, ARRAY_SIZE(coupling));
 842                 break;
 843         case SR_CONF_VDIV:
 844                 if (!devc)
 845                         /* Can't know this until we have the exact model. */
 846                         return SR_ERR_ARG;
 847                 if (!cg) {
 848                         sr_err("No channel group specified.");
 849                         return SR_ERR_CHANNEL_GROUP;
 850                 }
 851                 g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
 852                 for (i = 0; i < devc->num_vdivs; i++) {
 853                         rational[0] = g_variant_new_uint64(devc->vdivs[i][0]);
 854                         rational[1] = g_variant_new_uint64(devc->vdivs[i][1]);
 855                         tuple = g_variant_new_tuple(rational, 2);
 856                         g_variant_builder_add_value(&gvb, tuple);
 857                 }
 858                 *data = g_variant_builder_end(&gvb);
 859                 break;
 860         case SR_CONF_TIMEBASE:
 861                 if (!devc)
 862                         /* Can't know this until we have the exact model. */
 863                         return SR_ERR_ARG;
 864                 if (devc->num_timebases <= 0)
 865                         return SR_ERR_NA;
 866                 g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
 867                 for (i = 0; i < devc->num_timebases; i++) {
 868                         rational[0] = g_variant_new_uint64(devc->timebases[i][0]);
 869                         rational[1] = g_variant_new_uint64(devc->timebases[i][1]);
 870                         tuple = g_variant_new_tuple(rational, 2);
 871                         g_variant_builder_add_value(&gvb, tuple);
 872                 }
 873                 *data = g_variant_builder_end(&gvb);
 874                 break;
 875         case SR_CONF_TRIGGER_SOURCE:
 876                 if (!devc)
 877                         /* Can't know this until we have the exact model. */
 878                         return SR_ERR_ARG;
 879                 *data = g_variant_new_strv(trigger_sources,
 880                                 devc->model->has_digital ? ARRAY_SIZE(trigger_sources) : 4);
 881                 break;
 882         case SR_CONF_TRIGGER_SLOPE:
 883                 *data = g_variant_new_strv(trigger_slopes, ARRAY_SIZE(trigger_slopes));
 884                 break;
 885         case SR_CONF_DATA_SOURCE:
 886                 if (!devc)
 887                         /* Can't know this until we have the exact model. */
 888                         return SR_ERR_ARG;
 889                 switch (devc->model->series->protocol) {
 890                 case PROTOCOL_V1:
 891                         *data = g_variant_new_strv(data_sources, ARRAY_SIZE(data_sources) - 2);
 892                         break;
 893                 case PROTOCOL_V2:
 894                         *data = g_variant_new_strv(data_sources, ARRAY_SIZE(data_sources) - 1);
 895                         break;
 896                 default:
 897                         *data = g_variant_new_strv(data_sources, ARRAY_SIZE(data_sources));
 898                         break;
 899                 }
 900                 break;
 901         default:
 902                 return SR_ERR_NA;
 903         }
 904
 905         return SR_OK;
 906 }
 907
 908 static int dev_acquisition_start(const struct sr_dev_inst *sdi)
 909 {
 910         struct sr_scpi_dev_inst *scpi;
 911         struct dev_context *devc;
 912         struct sr_channel *ch;
 913         struct sr_datafeed_packet packet;
 914         gboolean some_digital;
 915         GSList *l;
 916
 917         if (sdi->status != SR_ST_ACTIVE)
 918                 return SR_ERR_DEV_CLOSED;
 919
 920         scpi = sdi->conn;
 921         devc = sdi->priv;
 922
 923         devc->num_frames = 0;
 924
 925         some_digital = FALSE;
 926         for (l = sdi->channels; l; l = l->next) {
 927                 ch = l->data;
 928                 sr_dbg("handling channel %s", ch->name);
 929                 if (ch->type == SR_CHANNEL_ANALOG) {
 930                         if (ch->enabled)
 931                                 devc->enabled_channels = g_slist_append(
 932                                                 devc->enabled_channels, ch);
 933                         if (ch->enabled != devc->analog_channels[ch->index]) {
 934                                 /* Enabled channel is currently disabled, or vice versa. */
 935                                 if (rigol_ds_config_set(sdi, ":CHAN%d:DISP %s", ch->index + 1,
 936                                                 ch->enabled ? "ON" : "OFF") != SR_OK)
 937                                         return SR_ERR;
 938                                 devc->analog_channels[ch->index] = ch->enabled;
 939                         }
 940                 } else if (ch->type == SR_CHANNEL_LOGIC) {
 941                         /* Only one list entry for DS1000D series. All channels are retrieved
 942                          * together when this entry is processed. */
 943                         if (ch->enabled && (
 944                                                 devc->model->series->protocol > PROTOCOL_V2 ||
 945                                                 !some_digital))
 946                                 devc->enabled_channels = g_slist_append(
 947                                                 devc->enabled_channels, ch);
 948                         if (ch->enabled) {
 949                                 some_digital = TRUE;
 950                                 /* Turn on LA module if currently off. */
 951                                 if (!devc->la_enabled) {
 952                                         if (rigol_ds_config_set(sdi,
 953                                                         devc->model->series->protocol >= PROTOCOL_V4 ?
 954                                                                 ":LA:STAT ON" : ":LA:DISP ON") != SR_OK)
 955                                                 return SR_ERR;
 956                                         devc->la_enabled = TRUE;
 957                                 }
 958                         }
 959                         if (ch->enabled != devc->digital_channels[ch->index]) {
 960                                 /* Enabled channel is currently disabled, or vice versa. */
 961                                 if (rigol_ds_config_set(sdi,
 962                                                 devc->model->series->protocol >= PROTOCOL_V4 ?
 963                                                         ":LA:DIG%d:DISP %s" : ":DIG%d:TURN %s", ch->index,
 964                                                 ch->enabled ? "ON" : "OFF") != SR_OK)
 965                                         return SR_ERR;
 966                                 devc->digital_channels[ch->index] = ch->enabled;
 967                         }
 968                 }
 969         }
 970
 971         if (!devc->enabled_channels)
 972                 return SR_ERR;
 973
 974         /* Turn off LA module if on and no digital channels selected. */
 975         if (devc->la_enabled && !some_digital)
 976                 if (rigol_ds_config_set(sdi,
 977                                 devc->model->series->protocol >= PROTOCOL_V4 ?
 978                                         ":LA:STAT OFF" : ":LA:DISP OFF") != SR_OK)
 979                         return SR_ERR;
 980
 981         /* Set memory mode. */
 982         if (devc->data_source == DATA_SOURCE_SEGMENTED) {
 983                 sr_err("Data source 'Segmented' not yet supported");
 984                 return SR_ERR;
 985         }
 986
 987         devc->analog_frame_size = analog_frame_size(sdi);
 988         devc->digital_frame_size = digital_frame_size(sdi);
 989
 990         switch (devc->model->series->protocol) {
 991         case PROTOCOL_V2:
 992                 if (rigol_ds_config_set(sdi, ":ACQ:MEMD LONG") != SR_OK)
 993                         return SR_ERR;
 994                 break;
 995         case PROTOCOL_V3:
 996                 /* Apparently for the DS2000 the memory
 997                  * depth can only be set in Running state -
 998                  * this matches the behaviour of the UI. */
 999                 if (rigol_ds_config_set(sdi, ":RUN") != SR_OK)
1000                         return SR_ERR;
1001                 if (rigol_ds_config_set(sdi, ":ACQ:MDEP %d",
1002                                         devc->analog_frame_size) != SR_OK)
1003                         return SR_ERR;
1004                 if (rigol_ds_config_set(sdi, ":STOP") != SR_OK)
1005                         return SR_ERR;
1006                 break;
1007         default:
1008                 break;
1009         }
1010
1011         if (devc->data_source == DATA_SOURCE_LIVE)
1012                 if (rigol_ds_config_set(sdi, ":RUN") != SR_OK)
1013                         return SR_ERR;
1014
1015         sr_scpi_source_add(sdi->session, scpi, G_IO_IN, 50,
1016                         rigol_ds_receive, (void *)sdi);
1017
1018         std_session_send_df_header(sdi, LOG_PREFIX);
1019
1020         devc->channel_entry = devc->enabled_channels;
1021
1022         if (rigol_ds_capture_start(sdi) != SR_OK)
1023                 return SR_ERR;
1024
1025         /* Start of first frame. */
1026         packet.type = SR_DF_FRAME_BEGIN;
1027         sr_session_send(sdi, &packet);
1028
1029         return SR_OK;
1030 }
1031
1032 static int dev_acquisition_stop(struct sr_dev_inst *sdi)
1033 {
1034         struct dev_context *devc;
1035         struct sr_scpi_dev_inst *scpi;
1036
1037         devc = sdi->priv;
1038
1039         if (sdi->status != SR_ST_ACTIVE) {
1040                 sr_err("Device inactive, can't stop acquisition.");
1041                 return SR_ERR;
1042         }
1043
1044         std_session_send_df_end(sdi, LOG_PREFIX);
1045
1046         g_slist_free(devc->enabled_channels);
1047         devc->enabled_channels = NULL;
1048         scpi = sdi->conn;
1049         sr_scpi_source_remove(sdi->session, scpi);
1050
1051         return SR_OK;
1052 }
1053
1054 SR_PRIV struct sr_dev_driver rigol_ds_driver_info = {
1055         .name = "rigol-ds",
1056         .longname = "Rigol DS",
1057         .api_version = 1,
1058         .init = std_init,
1059         .cleanup = std_cleanup,
1060         .scan = scan,
1061         .dev_list = std_dev_list,
1062         .dev_clear = dev_clear,
1063         .config_get = config_get,
1064         .config_set = config_set,
1065         .config_list = config_list,
1066         .dev_open = dev_open,
1067         .dev_close = dev_close,
1068         .dev_acquisition_start = dev_acquisition_start,
1069         .dev_acquisition_stop = dev_acquisition_stop,
1070         .context = NULL,
1071 };