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