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         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 < NUM_VDIV; 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 };