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