src/hardware/rigol-ds/api.c

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