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) {
 822                 for (i = 0; i < devc->model->analog_channels; i++)
 823                         if (cg == devc->analog_groups[i])
 824                                 break;
 825                 if (i >= devc->model->analog_channels) {
 826                         sr_err("Invalid channel group specified.");
 827                         return SR_ERR;
 828                 }
 829         }
 830
 831         switch (key) {
 832         case SR_CONF_DEVICE_OPTIONS:
 833                 if (!cg) {
 834                         sr_err("No channel group specified.");
 835                         return SR_ERR_CHANNEL_GROUP;
 836                 }
 837                 if (cg == devc->digital_group) {
 838                         *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
 839                                 NULL, 0, sizeof(uint32_t));
 840                         return SR_OK;
 841                 } else {
 842                         for (i = 0; i < devc->model->analog_channels; i++) {
 843                                 if (cg == devc->analog_groups[i]) {
 844                                         *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
 845                                                 analog_devopts, ARRAY_SIZE(analog_devopts), sizeof(uint32_t));
 846                                         return SR_OK;
 847                                 }
 848                         }
 849                         return SR_ERR_NA;
 850                 }
 851                 break;
 852         case SR_CONF_COUPLING:
 853                 if (!cg) {
 854                         sr_err("No channel group specified.");
 855                         return SR_ERR_CHANNEL_GROUP;
 856                 }
 857                 *data = g_variant_new_strv(coupling, ARRAY_SIZE(coupling));
 858                 break;
 859         case SR_CONF_VDIV:
 860                 if (!devc)
 861                         /* Can't know this until we have the exact model. */
 862                         return SR_ERR_ARG;
 863                 if (!cg) {
 864                         sr_err("No channel group specified.");
 865                         return SR_ERR_CHANNEL_GROUP;
 866                 }
 867                 g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
 868                 for (i = 0; i < devc->num_vdivs; i++) {
 869                         rational[0] = g_variant_new_uint64(devc->vdivs[i][0]);
 870                         rational[1] = g_variant_new_uint64(devc->vdivs[i][1]);
 871                         tuple = g_variant_new_tuple(rational, 2);
 872                         g_variant_builder_add_value(&gvb, tuple);
 873                 }
 874                 *data = g_variant_builder_end(&gvb);
 875                 break;
 876         case SR_CONF_TIMEBASE:
 877                 if (!devc)
 878                         /* Can't know this until we have the exact model. */
 879                         return SR_ERR_ARG;
 880                 if (devc->num_timebases <= 0)
 881                         return SR_ERR_NA;
 882                 g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
 883                 for (i = 0; i < devc->num_timebases; i++) {
 884                         rational[0] = g_variant_new_uint64(devc->timebases[i][0]);
 885                         rational[1] = g_variant_new_uint64(devc->timebases[i][1]);
 886                         tuple = g_variant_new_tuple(rational, 2);
 887                         g_variant_builder_add_value(&gvb, tuple);
 888                 }
 889                 *data = g_variant_builder_end(&gvb);
 890                 break;
 891         case SR_CONF_TRIGGER_SOURCE:
 892                 if (!devc)
 893                         /* Can't know this until we have the exact model. */
 894                         return SR_ERR_ARG;
 895                 *data = g_variant_new_strv(trigger_sources,
 896                                 devc->model->has_digital ? ARRAY_SIZE(trigger_sources) : 4);
 897                 break;
 898         case SR_CONF_TRIGGER_SLOPE:
 899                 *data = g_variant_new_strv(trigger_slopes, ARRAY_SIZE(trigger_slopes));
 900                 break;
 901         case SR_CONF_DATA_SOURCE:
 902                 if (!devc)
 903                         /* Can't know this until we have the exact model. */
 904                         return SR_ERR_ARG;
 905                 switch (devc->model->series->protocol) {
 906                 case PROTOCOL_V1:
 907                         *data = g_variant_new_strv(data_sources, ARRAY_SIZE(data_sources) - 2);
 908                         break;
 909                 case PROTOCOL_V2:
 910                         *data = g_variant_new_strv(data_sources, ARRAY_SIZE(data_sources) - 1);
 911                         break;
 912                 default:
 913                         *data = g_variant_new_strv(data_sources, ARRAY_SIZE(data_sources));
 914                         break;
 915                 }
 916                 break;
 917         default:
 918                 sr_dbg("Tried to list unknown config key: %d.", key);
 919                 return SR_ERR_NA;
 920         }
 921
 922         return SR_OK;
 923 }
 924
 925 static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
 926 {
 927         struct sr_scpi_dev_inst *scpi;
 928         struct dev_context *devc;
 929         struct sr_channel *ch;
 930         struct sr_datafeed_packet packet;
 931         GSList *l;
 932
 933         if (sdi->status != SR_ST_ACTIVE)
 934                 return SR_ERR_DEV_CLOSED;
 935
 936         scpi = sdi->conn;
 937         devc = sdi->priv;
 938
 939         devc->num_frames = 0;
 940
 941         for (l = sdi->channels; l; l = l->next) {
 942                 ch = l->data;
 943                 sr_dbg("handling channel %s", ch->name);
 944                 if (ch->type == SR_CHANNEL_ANALOG) {
 945                         if (ch->enabled)
 946                                 devc->enabled_analog_channels = g_slist_append(
 947                                                 devc->enabled_analog_channels, ch);
 948                         if (ch->enabled != devc->analog_channels[ch->index]) {
 949                                 /* Enabled channel is currently disabled, or vice versa. */
 950                                 if (rigol_ds_config_set(sdi, ":CHAN%d:DISP %s", ch->index + 1,
 951                                                 ch->enabled ? "ON" : "OFF") != SR_OK)
 952                                         return SR_ERR;
 953                                 devc->analog_channels[ch->index] = ch->enabled;
 954                         }
 955                 } else if (ch->type == SR_CHANNEL_LOGIC) {
 956                         if (ch->enabled) {
 957                                 devc->enabled_digital_channels = g_slist_append(
 958                                                 devc->enabled_digital_channels, ch);
 959                                 /* Turn on LA module if currently off. */
 960                                 if (!devc->la_enabled) {
 961                                         if (rigol_ds_config_set(sdi, ":LA:DISP ON") != SR_OK)
 962                                                 return SR_ERR;
 963                                         devc->la_enabled = TRUE;
 964                                 }
 965                         }
 966                         if (ch->enabled != devc->digital_channels[ch->index]) {
 967                                 /* Enabled channel is currently disabled, or vice versa. */
 968                                 if (rigol_ds_config_set(sdi, ":DIG%d:TURN %s", ch->index,
 969                                                 ch->enabled ? "ON" : "OFF") != SR_OK)
 970                                         return SR_ERR;
 971                                 devc->digital_channels[ch->index] = ch->enabled;
 972                         }
 973                 }
 974         }
 975
 976         if (!devc->enabled_analog_channels && !devc->enabled_digital_channels)
 977                 return SR_ERR;
 978
 979         /* Turn off LA module if on and no digital channels selected. */
 980         if (devc->la_enabled && !devc->enabled_digital_channels)
 981                 if (rigol_ds_config_set(sdi, ":LA:DISP OFF") != SR_OK)
 982                         return SR_ERR;
 983
 984         /* Set memory mode. */
 985         if (devc->data_source == DATA_SOURCE_SEGMENTED) {
 986                 sr_err("Data source 'Segmented' not yet supported");
 987                 return SR_ERR;
 988         }
 989
 990         devc->analog_frame_size = analog_frame_size(sdi);
 991         devc->digital_frame_size = digital_frame_size(sdi);
 992
 993         switch (devc->model->series->protocol) {
 994         case PROTOCOL_V2:
 995                 if (rigol_ds_config_set(sdi, ":ACQ:MEMD LONG") != SR_OK)
 996                         return SR_ERR;
 997                 break;
 998         case PROTOCOL_V3:
 999                 /* Apparently for the DS2000 the memory
1000                  * depth can only be set in Running state -
1001                  * this matches the behaviour of the UI. */
1002                 if (rigol_ds_config_set(sdi, ":RUN") != SR_OK)
1003                         return SR_ERR;
1004                 if (rigol_ds_config_set(sdi, ":ACQ:MDEP %d",
1005                                         devc->analog_frame_size) != SR_OK)
1006                         return SR_ERR;
1007                 if (rigol_ds_config_set(sdi, ":STOP") != SR_OK)
1008                         return SR_ERR;
1009                 break;
1010         default:
1011                 break;
1012         }
1013
1014         if (devc->data_source == DATA_SOURCE_LIVE)
1015                 if (rigol_ds_config_set(sdi, ":RUN") != SR_OK)
1016                         return SR_ERR;
1017
1018         sr_scpi_source_add(sdi->session, scpi, G_IO_IN, 50,
1019                         rigol_ds_receive, (void *)sdi);
1020
1021         /* Send header packet to the session bus. */
1022         std_session_send_df_header(cb_data, LOG_PREFIX);
1023
1024         if (devc->enabled_analog_channels)
1025                 devc->channel_entry = devc->enabled_analog_channels;
1026         else
1027                 devc->channel_entry = devc->enabled_digital_channels;
1028
1029         if (rigol_ds_capture_start(sdi) != SR_OK)
1030                 return SR_ERR;
1031
1032         /* Start of first frame. */
1033         packet.type = SR_DF_FRAME_BEGIN;
1034         sr_session_send(cb_data, &packet);
1035
1036         return SR_OK;
1037 }
1038
1039 static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
1040 {
1041         struct dev_context *devc;
1042         struct sr_scpi_dev_inst *scpi;
1043         struct sr_datafeed_packet packet;
1044
1045         (void)cb_data;
1046
1047         devc = sdi->priv;
1048
1049         if (sdi->status != SR_ST_ACTIVE) {
1050                 sr_err("Device inactive, can't stop acquisition.");
1051                 return SR_ERR;
1052         }
1053
1054         /* End of last frame. */
1055         packet.type = SR_DF_END;
1056         sr_session_send(sdi, &packet);
1057
1058         g_slist_free(devc->enabled_analog_channels);
1059         g_slist_free(devc->enabled_digital_channels);
1060         devc->enabled_analog_channels = NULL;
1061         devc->enabled_digital_channels = NULL;
1062         scpi = sdi->conn;
1063         sr_scpi_source_remove(sdi->session, scpi);
1064
1065         return SR_OK;
1066 }
1067
1068 SR_PRIV struct sr_dev_driver rigol_ds_driver_info = {
1069         .name = "rigol-ds",
1070         .longname = "Rigol DS",
1071         .api_version = 1,
1072         .init = init,
1073         .cleanup = cleanup,
1074         .scan = scan,
1075         .dev_list = dev_list,
1076         .dev_clear = dev_clear,
1077         .config_get = config_get,
1078         .config_set = config_set,
1079         .config_list = config_list,
1080         .dev_open = dev_open,
1081         .dev_close = dev_close,
1082         .dev_acquisition_start = dev_acquisition_start,
1083         .dev_acquisition_stop = dev_acquisition_stop,
1084         .priv = NULL,
1085 };