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}, {500, 1000000}, 14, 1400, 14000},
 196         [DS2000A] = {VENDOR(RIGOL), "DS2000A", PROTOCOL_V3, FORMAT_IEEE488_2,
 197                 {1000, 1}, {500, 1000000}, 14, 1400, 14000},
 198         [DSO1000] = {VENDOR(AGILENT), "DSO1000", PROTOCOL_V3, FORMAT_IEEE488_2,
 199                 {50, 1}, {2, 1000}, 12, 600, 20480},
 200 };
 201
 202 #define SERIES(x) &supported_series[x]
 203 /* series, model, min timebase, analog channels, digital */
 204 static const struct rigol_ds_model supported_models[] = {
 205         {SERIES(VS5000), "VS5022", {20, 1000000000}, 2, false},
 206         {SERIES(VS5000), "VS5042", {10, 1000000000}, 2, false},
 207         {SERIES(VS5000), "VS5062", {5, 1000000000}, 2, false},
 208         {SERIES(VS5000), "VS5102", {2, 1000000000}, 2, false},
 209         {SERIES(VS5000), "VS5202", {2, 1000000000}, 2, false},
 210         {SERIES(VS5000), "VS5022D", {20, 1000000000}, 2, true},
 211         {SERIES(VS5000), "VS5042D", {10, 1000000000}, 2, true},
 212         {SERIES(VS5000), "VS5062D", {5, 1000000000}, 2, true},
 213         {SERIES(VS5000), "VS5102D", {2, 1000000000}, 2, true},
 214         {SERIES(VS5000), "VS5202D", {2, 1000000000}, 2, true},
 215         {SERIES(DS1000), "DS1052E", {5, 1000000000}, 2, false},
 216         {SERIES(DS1000), "DS1102E", {2, 1000000000}, 2, false},
 217         {SERIES(DS1000), "DS1152E", {2, 1000000000}, 2, false},
 218         {SERIES(DS1000), "DS1052D", {5, 1000000000}, 2, true},
 219         {SERIES(DS1000), "DS1102D", {2, 1000000000}, 2, true},
 220         {SERIES(DS1000), "DS1152D", {2, 1000000000}, 2, true},
 221         {SERIES(DS2000), "DS2072", {5, 1000000000}, 2, false},
 222         {SERIES(DS2000), "DS2102", {5, 1000000000}, 2, false},
 223         {SERIES(DS2000), "DS2202", {2, 1000000000}, 2, false},
 224         {SERIES(DS2000), "DS2302", {1, 1000000000}, 2, false},
 225         {SERIES(DS2000A), "DS2072A", {5, 1000000000}, 2, false},
 226         {SERIES(DS2000A), "DS2102A", {5, 1000000000}, 2, false},
 227         {SERIES(DS2000A), "DS2202A", {2, 1000000000}, 2, false},
 228         {SERIES(DS2000A), "DS2302A", {1, 1000000000}, 2, false},
 229         {SERIES(DSO1000), "DSO1002A", {5, 1000000000}, 2, false},
 230         {SERIES(DSO1000), "DSO1004A", {5, 1000000000}, 4, false},
 231         {SERIES(DSO1000), "DSO1012A", {2, 1000000000}, 2, false},
 232         {SERIES(DSO1000), "DSO1014A", {2, 1000000000}, 4, false},
 233         {SERIES(DSO1000), "DSO1022A", {2, 1000000000}, 2, false},
 234         {SERIES(DSO1000), "DSO1024A", {2, 1000000000}, 4, false},
 235 };
 236
 237 SR_PRIV struct sr_dev_driver rigol_ds_driver_info;
 238 static struct sr_dev_driver *di = &rigol_ds_driver_info;
 239
 240 static void clear_helper(void *priv)
 241 {
 242         struct dev_context *devc;
 243         unsigned int i;
 244
 245         devc = priv;
 246         g_free(devc->data);
 247         g_free(devc->buffer);
 248         for (i = 0; i < ARRAY_SIZE(devc->coupling); i++)
 249                 g_free(devc->coupling[i]);
 250         g_free(devc->trigger_source);
 251         g_free(devc->trigger_slope);
 252         g_free(devc->analog_groups);
 253         g_free(devc->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                         devc->num_vdivs = NUM_VDIV - i;
 387                 }
 388
 389         if (!(devc->buffer = g_try_malloc(ACQ_BUFFER_SIZE)))
 390                 return NULL;
 391         if (!(devc->data = g_try_malloc(ACQ_BUFFER_SIZE * sizeof(float))))
 392                 return NULL;
 393
 394         devc->data_source = DATA_SOURCE_LIVE;
 395
 396         sdi->priv = devc;
 397
 398         return sdi;
 399 }
 400
 401 static GSList *scan(GSList *options)
 402 {
 403         return sr_scpi_scan(di->priv, options, probe_device);
 404 }
 405
 406 static GSList *dev_list(void)
 407 {
 408         return ((struct drv_context *)(di->priv))->instances;
 409 }
 410
 411 static int dev_open(struct sr_dev_inst *sdi)
 412 {
 413         int ret;
 414         struct sr_scpi_dev_inst *scpi = sdi->conn;
 415
 416         if ((ret = sr_scpi_open(scpi)) < 0) {
 417                 sr_err("Failed to open SCPI device: %s.", sr_strerror(ret));
 418                 return SR_ERR;
 419         }
 420
 421         if ((ret = rigol_ds_get_dev_cfg(sdi)) < 0) {
 422                 sr_err("Failed to get device config: %s.", sr_strerror(ret));
 423                 return SR_ERR;
 424         }
 425
 426         sdi->status = SR_ST_ACTIVE;
 427
 428         return SR_OK;
 429 }
 430
 431 static int dev_close(struct sr_dev_inst *sdi)
 432 {
 433         struct sr_scpi_dev_inst *scpi;
 434         struct dev_context *devc;
 435
 436         if (sdi->status != SR_ST_ACTIVE)
 437                 return SR_ERR_DEV_CLOSED;
 438
 439         scpi = sdi->conn;
 440         devc = sdi->priv;
 441
 442         if (devc->model->series->protocol == PROTOCOL_V2)
 443                 rigol_ds_config_set(sdi, ":KEY:LOCK DISABLE");
 444
 445         if (scpi) {
 446                 if (sr_scpi_close(scpi) < 0)
 447                         return SR_ERR;
 448                 sdi->status = SR_ST_INACTIVE;
 449         }
 450
 451         return SR_OK;
 452 }
 453
 454 static int cleanup(void)
 455 {
 456         return dev_clear();
 457 }
 458
 459 static int analog_frame_size(const struct sr_dev_inst *sdi)
 460 {
 461         struct dev_context *devc = sdi->priv;
 462         struct sr_channel *ch;
 463         int analog_channels = 0;
 464         GSList *l;
 465
 466         for (l = sdi->channels; l; l = l->next) {
 467                 ch = l->data;
 468                 if (ch->type == SR_CHANNEL_ANALOG && ch->enabled)
 469                         analog_channels++;
 470         }
 471
 472         if (analog_channels == 0)
 473                 return 0;
 474
 475         switch (devc->data_source) {
 476         case DATA_SOURCE_LIVE:
 477                 return devc->model->series->live_samples;
 478         case DATA_SOURCE_MEMORY:
 479                 return devc->model->series->buffer_samples / analog_channels;
 480         default:
 481                 return 0;
 482         }
 483 }
 484
 485 static int digital_frame_size(const struct sr_dev_inst *sdi)
 486 {
 487         struct dev_context *devc = sdi->priv;
 488
 489         switch (devc->data_source) {
 490         case DATA_SOURCE_LIVE:
 491                 return devc->model->series->live_samples * 2;
 492         case DATA_SOURCE_MEMORY:
 493                 return devc->model->series->buffer_samples * 2;
 494         default:
 495                 return 0;
 496         }
 497 }
 498
 499 static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
 500                 const struct sr_channel_group *cg)
 501 {
 502         struct dev_context *devc;
 503         struct sr_channel *ch;
 504         const char *tmp_str;
 505         uint64_t samplerate;
 506         int analog_channel = -1;
 507         float smallest_diff = INFINITY;
 508         int idx = -1;
 509         unsigned i;
 510
 511         if (!sdi || !(devc = sdi->priv))
 512                 return SR_ERR_ARG;
 513
 514         /* If a channel group is specified, it must be a valid one. */
 515         if (cg && !g_slist_find(sdi->channel_groups, cg)) {
 516                 sr_err("Invalid channel group specified.");
 517                 return SR_ERR;
 518         }
 519
 520         if (cg) {
 521                 ch = g_slist_nth_data(cg->channels, 0);
 522                 if (!ch)
 523                         return SR_ERR;
 524                 if (ch->type == SR_CHANNEL_ANALOG) {
 525                         if (ch->name[2] < '1' || ch->name[2] > '4')
 526                                 return SR_ERR;
 527                         analog_channel = ch->name[2] - '1';
 528                 }
 529         }
 530
 531         switch (key) {
 532         case SR_CONF_NUM_TIMEBASE:
 533                 *data = g_variant_new_int32(devc->model->series->num_horizontal_divs);
 534                 break;
 535         case SR_CONF_NUM_VDIV:
 536                 *data = g_variant_new_int32(devc->num_vdivs);
 537                 break;
 538         case SR_CONF_DATA_SOURCE:
 539                 if (devc->data_source == DATA_SOURCE_LIVE)
 540                         *data = g_variant_new_string("Live");
 541                 else if (devc->data_source == DATA_SOURCE_MEMORY)
 542                         *data = g_variant_new_string("Memory");
 543                 else
 544                         *data = g_variant_new_string("Segmented");
 545                 break;
 546         case SR_CONF_SAMPLERATE:
 547                 if (devc->data_source == DATA_SOURCE_LIVE) {
 548                         samplerate = analog_frame_size(sdi) /
 549                                 (devc->timebase * devc->model->series->num_horizontal_divs);
 550                         *data = g_variant_new_uint64(samplerate);
 551                 } else {
 552                         sr_dbg("Unknown data source: %d.", devc->data_source);
 553                         return SR_ERR_NA;
 554                 }
 555                 break;
 556         case SR_CONF_TRIGGER_SOURCE:
 557                 if (!strcmp(devc->trigger_source, "ACL"))
 558                         tmp_str = "AC Line";
 559                 else if (!strcmp(devc->trigger_source, "CHAN1"))
 560                         tmp_str = "CH1";
 561                 else if (!strcmp(devc->trigger_source, "CHAN2"))
 562                         tmp_str = "CH2";
 563                 else if (!strcmp(devc->trigger_source, "CHAN3"))
 564                         tmp_str = "CH3";
 565                 else if (!strcmp(devc->trigger_source, "CHAN4"))
 566                         tmp_str = "CH4";
 567                 else
 568                         tmp_str = devc->trigger_source;
 569                 *data = g_variant_new_string(tmp_str);
 570                 break;
 571         case SR_CONF_TRIGGER_SLOPE:
 572                 if (!strncmp(devc->trigger_slope, "POS", 3)) {
 573                         tmp_str = "r";
 574                 } else if (!strncmp(devc->trigger_slope, "NEG", 3)) {
 575                         tmp_str = "f";
 576                 } else {
 577                         sr_dbg("Unknown trigger slope: '%s'.", devc->trigger_slope);
 578                         return SR_ERR_NA;
 579                 }
 580                 *data = g_variant_new_string(tmp_str);
 581                 break;
 582         case SR_CONF_TIMEBASE:
 583                 for (i = 0; i < devc->num_timebases; i++) {
 584                         float tb = (float)devc->timebases[i][0] / devc->timebases[i][1];
 585                         float diff = fabs(devc->timebase - tb);
 586                         if (diff < smallest_diff) {
 587                                 smallest_diff = diff;
 588                                 idx = i;
 589                         }
 590                 }
 591                 if (idx < 0) {
 592                         sr_dbg("Negative timebase index: %d.", idx);
 593                         return SR_ERR_NA;
 594                 }
 595                 *data = g_variant_new("(tt)", devc->timebases[idx][0],
 596                                               devc->timebases[idx][1]);
 597                 break;
 598         case SR_CONF_VDIV:
 599                 if (analog_channel < 0) {
 600                         sr_dbg("Negative analog channel: %d.", analog_channel);
 601                         return SR_ERR_NA;
 602                 }
 603                 for (i = 0; i < ARRAY_SIZE(vdivs); i++) {
 604                         float vdiv = (float)vdivs[i][0] / vdivs[i][1];
 605                         float diff = fabs(devc->vdiv[analog_channel] - vdiv);
 606                         if (diff < smallest_diff) {
 607                                 smallest_diff = diff;
 608                                 idx = i;
 609                         }
 610                 }
 611                 if (idx < 0) {
 612                         sr_dbg("Negative vdiv index: %d.", idx);
 613                         return SR_ERR_NA;
 614                 }
 615                 *data = g_variant_new("(tt)", vdivs[idx][0], vdivs[idx][1]);
 616                 break;
 617         case SR_CONF_COUPLING:
 618                 if (analog_channel < 0) {
 619                         sr_dbg("Negative analog channel: %d.", analog_channel);
 620                         return SR_ERR_NA;
 621                 }
 622                 *data = g_variant_new_string(devc->coupling[analog_channel]);
 623                 break;
 624         default:
 625                 sr_dbg("Tried to get unknown config key: %d.", key);
 626                 return SR_ERR_NA;
 627         }
 628
 629         return SR_OK;
 630 }
 631
 632 static int config_set(uint32_t key, GVariant *data, const struct sr_dev_inst *sdi,
 633                 const struct sr_channel_group *cg)
 634 {
 635         struct dev_context *devc;
 636         uint64_t p, q;
 637         double t_dbl;
 638         unsigned int i, j;
 639         int ret;
 640         const char *tmp_str;
 641         char buffer[16];
 642
 643         if (!(devc = sdi->priv))
 644                 return SR_ERR_ARG;
 645
 646         if (sdi->status != SR_ST_ACTIVE)
 647                 return SR_ERR_DEV_CLOSED;
 648
 649         /* If a channel group is specified, it must be a valid one. */
 650         if (cg && !g_slist_find(sdi->channel_groups, cg)) {
 651                 sr_err("Invalid channel group specified.");
 652                 return SR_ERR;
 653         }
 654
 655         ret = SR_OK;
 656         switch (key) {
 657         case SR_CONF_LIMIT_FRAMES:
 658                 devc->limit_frames = g_variant_get_uint64(data);
 659                 break;
 660         case SR_CONF_TRIGGER_SLOPE:
 661                 tmp_str = g_variant_get_string(data, NULL);
 662
 663                 if (!tmp_str || !(tmp_str[0] == 'f' || tmp_str[0] == 'r')) {
 664                         sr_err("Unknown trigger slope: '%s'.",
 665                                (tmp_str) ? tmp_str : "NULL");
 666                         return SR_ERR_ARG;
 667                 }
 668
 669                 g_free(devc->trigger_slope);
 670                 devc->trigger_slope = g_strdup((tmp_str[0] == 'r') ? "POS" : "NEG");
 671                 ret = rigol_ds_config_set(sdi, ":TRIG:EDGE:SLOP %s", devc->trigger_slope);
 672                 break;
 673         case SR_CONF_HORIZ_TRIGGERPOS:
 674                 t_dbl = g_variant_get_double(data);
 675                 if (t_dbl < 0.0 || t_dbl > 1.0) {
 676                         sr_err("Invalid horiz. trigger position: %g.", t_dbl);
 677                         return SR_ERR;
 678                 }
 679                 devc->horiz_triggerpos = t_dbl;
 680                 /* We have the trigger offset as a percentage of the frame, but
 681                  * need to express this in seconds. */
 682                 t_dbl = -(devc->horiz_triggerpos - 0.5) * devc->timebase * devc->num_timebases;
 683                 g_ascii_formatd(buffer, sizeof(buffer), "%.6f", t_dbl);
 684                 ret = rigol_ds_config_set(sdi, ":TIM:OFFS %s", buffer);
 685                 break;
 686         case SR_CONF_TIMEBASE:
 687                 g_variant_get(data, "(tt)", &p, &q);
 688                 for (i = 0; i < devc->num_timebases; i++) {
 689                         if (devc->timebases[i][0] == p && devc->timebases[i][1] == q) {
 690                                 devc->timebase = (float)p / q;
 691                                 g_ascii_formatd(buffer, sizeof(buffer), "%.9f",
 692                                                 devc->timebase);
 693                                 ret = rigol_ds_config_set(sdi, ":TIM:SCAL %s", buffer);
 694                                 break;
 695                         }
 696                 }
 697                 if (i == devc->num_timebases) {
 698                         sr_err("Invalid timebase index: %d.", i);
 699                         ret = SR_ERR_ARG;
 700                 }
 701                 break;
 702         case SR_CONF_TRIGGER_SOURCE:
 703                 tmp_str = g_variant_get_string(data, NULL);
 704                 for (i = 0; i < ARRAY_SIZE(trigger_sources); i++) {
 705                         if (!strcmp(trigger_sources[i], tmp_str)) {
 706                                 g_free(devc->trigger_source);
 707                                 devc->trigger_source = g_strdup(trigger_sources[i]);
 708                                 if (!strcmp(devc->trigger_source, "AC Line"))
 709                                         tmp_str = "ACL";
 710                                 else if (!strcmp(devc->trigger_source, "CH1"))
 711                                         tmp_str = "CHAN1";
 712                                 else if (!strcmp(devc->trigger_source, "CH2"))
 713                                         tmp_str = "CHAN2";
 714                                 else if (!strcmp(devc->trigger_source, "CH3"))
 715                                         tmp_str = "CHAN3";
 716                                 else if (!strcmp(devc->trigger_source, "CH4"))
 717                                         tmp_str = "CHAN4";
 718                                 else
 719                                         tmp_str = (char *)devc->trigger_source;
 720                                 ret = rigol_ds_config_set(sdi, ":TRIG:EDGE:SOUR %s", tmp_str);
 721                                 break;
 722                         }
 723                 }
 724                 if (i == ARRAY_SIZE(trigger_sources)) {
 725                         sr_err("Invalid trigger source index: %d.", i);
 726                         ret = SR_ERR_ARG;
 727                 }
 728                 break;
 729         case SR_CONF_VDIV:
 730                 if (!cg) {
 731                         sr_err("No channel group specified.");
 732                         return SR_ERR_CHANNEL_GROUP;
 733                 }
 734                 g_variant_get(data, "(tt)", &p, &q);
 735                 for (i = 0; i < devc->model->analog_channels; i++) {
 736                         if (cg == devc->analog_groups[i]) {
 737                                 for (j = 0; j < ARRAY_SIZE(vdivs); j++) {
 738                                         if (vdivs[j][0] != p || vdivs[j][1] != q)
 739                                                 continue;
 740                                         devc->vdiv[i] = (float)p / q;
 741                                         g_ascii_formatd(buffer, sizeof(buffer), "%.3f",
 742                                                         devc->vdiv[i]);
 743                                         return rigol_ds_config_set(sdi, ":CHAN%d:SCAL %s", i + 1,
 744                                                         buffer);
 745                                 }
 746                                 sr_err("Invalid vdiv index: %d.", j);
 747                                 return SR_ERR_ARG;
 748                         }
 749                 }
 750                 sr_dbg("Didn't set vdiv, unknown channel(group).");
 751                 return SR_ERR_NA;
 752         case SR_CONF_COUPLING:
 753                 if (!cg) {
 754                         sr_err("No channel group specified.");
 755                         return SR_ERR_CHANNEL_GROUP;
 756                 }
 757                 tmp_str = g_variant_get_string(data, NULL);
 758                 for (i = 0; i < devc->model->analog_channels; i++) {
 759                         if (cg == devc->analog_groups[i]) {
 760                                 for (j = 0; j < ARRAY_SIZE(coupling); j++) {
 761                                         if (!strcmp(tmp_str, coupling[j])) {
 762                                                 g_free(devc->coupling[i]);
 763                                                 devc->coupling[i] = g_strdup(coupling[j]);
 764                                                 return rigol_ds_config_set(sdi, ":CHAN%d:COUP %s", i + 1,
 765                                                                 devc->coupling[i]);
 766                                         }
 767                                 }
 768                                 sr_err("Invalid coupling index: %d.", j);
 769                                 return SR_ERR_ARG;
 770                         }
 771                 }
 772                 sr_dbg("Didn't set coupling, unknown channel(group).");
 773                 return SR_ERR_NA;
 774         case SR_CONF_DATA_SOURCE:
 775                 tmp_str = g_variant_get_string(data, NULL);
 776                 if (!strcmp(tmp_str, "Live"))
 777                         devc->data_source = DATA_SOURCE_LIVE;
 778                 else if (devc->model->series->protocol >= PROTOCOL_V2
 779                         && !strcmp(tmp_str, "Memory"))
 780                         devc->data_source = DATA_SOURCE_MEMORY;
 781                 else if (devc->model->series->protocol >= PROTOCOL_V3
 782                          && !strcmp(tmp_str, "Segmented"))
 783                         devc->data_source = DATA_SOURCE_SEGMENTED;
 784                 else {
 785                         sr_err("Unknown data source: '%s'.", tmp_str);
 786                         return SR_ERR;
 787                 }
 788                 break;
 789         default:
 790                 sr_dbg("Tried to set unknown config key: %d.", key);
 791                 ret = SR_ERR_NA;
 792                 break;
 793         }
 794
 795         return ret;
 796 }
 797
 798 static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
 799                 const struct sr_channel_group *cg)
 800 {
 801         GVariant *tuple, *rational[2];
 802         GVariantBuilder gvb;
 803         unsigned int i;
 804         struct dev_context *devc = NULL;
 805
 806         if (sdi)
 807                 devc = sdi->priv;
 808
 809         if (key == SR_CONF_SCAN_OPTIONS) {
 810                 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
 811                                 scanopts, ARRAY_SIZE(scanopts), sizeof(uint32_t));
 812                 return SR_OK;
 813         } else if (key == SR_CONF_DEVICE_OPTIONS && cg == NULL) {
 814                 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
 815                                 devopts, ARRAY_SIZE(devopts), sizeof(uint32_t));
 816                 return SR_OK;
 817         }
 818
 819         /* Every other option requires a valid device instance. */
 820         if (!sdi || !(devc = sdi->priv))
 821                 return SR_ERR_ARG;
 822
 823         /* If a channel group is specified, it must be a valid one. */
 824         if (cg) {
 825                 for (i = 0; i < devc->model->analog_channels; i++)
 826                         if (cg == devc->analog_groups[i])
 827                                 break;
 828                 if (i >= devc->model->analog_channels) {
 829                         sr_err("Invalid channel group specified.");
 830                         return SR_ERR;
 831                 }
 832         }
 833
 834         switch (key) {
 835         case SR_CONF_DEVICE_OPTIONS:
 836                 if (!cg) {
 837                         sr_err("No channel group specified.");
 838                         return SR_ERR_CHANNEL_GROUP;
 839                 }
 840                 if (cg == devc->digital_group) {
 841                         *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
 842                                 NULL, 0, sizeof(uint32_t));
 843                         return SR_OK;
 844                 } else {
 845                         for (i = 0; i < devc->model->analog_channels; i++) {
 846                                 if (cg == devc->analog_groups[i]) {
 847                                         *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
 848                                                 analog_devopts, ARRAY_SIZE(analog_devopts), sizeof(uint32_t));
 849                                         return SR_OK;
 850                                 }
 851                         }
 852                         return SR_ERR_NA;
 853                 }
 854                 break;
 855         case SR_CONF_COUPLING:
 856                 if (!cg) {
 857                         sr_err("No channel group specified.");
 858                         return SR_ERR_CHANNEL_GROUP;
 859                 }
 860                 *data = g_variant_new_strv(coupling, ARRAY_SIZE(coupling));
 861                 break;
 862         case SR_CONF_VDIV:
 863                 if (!devc)
 864                         /* Can't know this until we have the exact model. */
 865                         return SR_ERR_ARG;
 866                 if (!cg) {
 867                         sr_err("No channel group specified.");
 868                         return SR_ERR_CHANNEL_GROUP;
 869                 }
 870                 g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
 871                 for (i = 0; i < devc->num_vdivs; i++) {
 872                         rational[0] = g_variant_new_uint64(devc->vdivs[i][0]);
 873                         rational[1] = g_variant_new_uint64(devc->vdivs[i][1]);
 874                         tuple = g_variant_new_tuple(rational, 2);
 875                         g_variant_builder_add_value(&gvb, tuple);
 876                 }
 877                 *data = g_variant_builder_end(&gvb);
 878                 break;
 879         case SR_CONF_TIMEBASE:
 880                 if (!devc)
 881                         /* Can't know this until we have the exact model. */
 882                         return SR_ERR_ARG;
 883                 if (devc->num_timebases <= 0)
 884                         return SR_ERR_NA;
 885                 g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
 886                 for (i = 0; i < devc->num_timebases; i++) {
 887                         rational[0] = g_variant_new_uint64(devc->timebases[i][0]);
 888                         rational[1] = g_variant_new_uint64(devc->timebases[i][1]);
 889                         tuple = g_variant_new_tuple(rational, 2);
 890                         g_variant_builder_add_value(&gvb, tuple);
 891                 }
 892                 *data = g_variant_builder_end(&gvb);
 893                 break;
 894         case SR_CONF_TRIGGER_SOURCE:
 895                 if (!devc)
 896                         /* Can't know this until we have the exact model. */
 897                         return SR_ERR_ARG;
 898                 *data = g_variant_new_strv(trigger_sources,
 899                                 devc->model->has_digital ? ARRAY_SIZE(trigger_sources) : 4);
 900                 break;
 901         case SR_CONF_TRIGGER_SLOPE:
 902                 *data = g_variant_new_strv(trigger_slopes, ARRAY_SIZE(trigger_slopes));
 903                 break;
 904         case SR_CONF_DATA_SOURCE:
 905                 if (!devc)
 906                         /* Can't know this until we have the exact model. */
 907                         return SR_ERR_ARG;
 908                 switch (devc->model->series->protocol) {
 909                 case PROTOCOL_V1:
 910                         *data = g_variant_new_strv(data_sources, ARRAY_SIZE(data_sources) - 2);
 911                         break;
 912                 case PROTOCOL_V2:
 913                         *data = g_variant_new_strv(data_sources, ARRAY_SIZE(data_sources) - 1);
 914                         break;
 915                 default:
 916                         *data = g_variant_new_strv(data_sources, ARRAY_SIZE(data_sources));
 917                         break;
 918                 }
 919                 break;
 920         default:
 921                 sr_dbg("Tried to list unknown config key: %d.", key);
 922                 return SR_ERR_NA;
 923         }
 924
 925         return SR_OK;
 926 }
 927
 928 static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
 929 {
 930         struct sr_scpi_dev_inst *scpi;
 931         struct dev_context *devc;
 932         struct sr_channel *ch;
 933         struct sr_datafeed_packet packet;
 934         GSList *l;
 935
 936         if (sdi->status != SR_ST_ACTIVE)
 937                 return SR_ERR_DEV_CLOSED;
 938
 939         scpi = sdi->conn;
 940         devc = sdi->priv;
 941
 942         devc->num_frames = 0;
 943
 944         for (l = sdi->channels; l; l = l->next) {
 945                 ch = l->data;
 946                 sr_dbg("handling channel %s", ch->name);
 947                 if (ch->type == SR_CHANNEL_ANALOG) {
 948                         if (ch->enabled)
 949                                 devc->enabled_analog_channels = g_slist_append(
 950                                                 devc->enabled_analog_channels, ch);
 951                         if (ch->enabled != devc->analog_channels[ch->index]) {
 952                                 /* Enabled channel is currently disabled, or vice versa. */
 953                                 if (rigol_ds_config_set(sdi, ":CHAN%d:DISP %s", ch->index + 1,
 954                                                 ch->enabled ? "ON" : "OFF") != SR_OK)
 955                                         return SR_ERR;
 956                                 devc->analog_channels[ch->index] = ch->enabled;
 957                         }
 958                 } else if (ch->type == SR_CHANNEL_LOGIC) {
 959                         if (ch->enabled) {
 960                                 devc->enabled_digital_channels = g_slist_append(
 961                                                 devc->enabled_digital_channels, ch);
 962                                 /* Turn on LA module if currently off. */
 963                                 if (!devc->la_enabled) {
 964                                         if (rigol_ds_config_set(sdi, ":LA:DISP ON") != SR_OK)
 965                                                 return SR_ERR;
 966                                         devc->la_enabled = TRUE;
 967                                 }
 968                         }
 969                         if (ch->enabled != devc->digital_channels[ch->index]) {
 970                                 /* Enabled channel is currently disabled, or vice versa. */
 971                                 if (rigol_ds_config_set(sdi, ":DIG%d:TURN %s", ch->index,
 972                                                 ch->enabled ? "ON" : "OFF") != SR_OK)
 973                                         return SR_ERR;
 974                                 devc->digital_channels[ch->index] = ch->enabled;
 975                         }
 976                 }
 977         }
 978
 979         if (!devc->enabled_analog_channels && !devc->enabled_digital_channels)
 980                 return SR_ERR;
 981
 982         /* Turn off LA module if on and no digital channels selected. */
 983         if (devc->la_enabled && !devc->enabled_digital_channels)
 984                 if (rigol_ds_config_set(sdi, ":LA:DISP OFF") != SR_OK)
 985                         return SR_ERR;
 986
 987         /* Set memory mode. */
 988         if (devc->data_source == DATA_SOURCE_SEGMENTED) {
 989                 sr_err("Data source 'Segmented' not yet supported");
 990                 return SR_ERR;
 991         }
 992
 993         devc->analog_frame_size = analog_frame_size(sdi);
 994         devc->digital_frame_size = digital_frame_size(sdi);
 995
 996         switch (devc->model->series->protocol) {
 997         case PROTOCOL_V2:
 998                 if (rigol_ds_config_set(sdi, ":ACQ:MEMD LONG") != SR_OK)
 999                         return SR_ERR;
1000                 break;
1001         case PROTOCOL_V3:
1002                 /* Apparently for the DS2000 the memory
1003                  * depth can only be set in Running state -
1004                  * this matches the behaviour of the UI. */
1005                 if (rigol_ds_config_set(sdi, ":RUN") != SR_OK)
1006                         return SR_ERR;
1007                 if (rigol_ds_config_set(sdi, ":ACQ:MDEP %d",
1008                                         devc->analog_frame_size) != SR_OK)
1009                         return SR_ERR;
1010                 if (rigol_ds_config_set(sdi, ":STOP") != SR_OK)
1011                         return SR_ERR;
1012                 break;
1013         default:
1014                 break;
1015         }
1016
1017         if (devc->data_source == DATA_SOURCE_LIVE)
1018                 if (rigol_ds_config_set(sdi, ":RUN") != SR_OK)
1019                         return SR_ERR;
1020
1021         sr_scpi_source_add(sdi->session, scpi, G_IO_IN, 50,
1022                         rigol_ds_receive, (void *)sdi);
1023
1024         /* Send header packet to the session bus. */
1025         std_session_send_df_header(cb_data, LOG_PREFIX);
1026
1027         if (devc->enabled_analog_channels)
1028                 devc->channel_entry = devc->enabled_analog_channels;
1029         else
1030                 devc->channel_entry = devc->enabled_digital_channels;
1031
1032         if (rigol_ds_capture_start(sdi) != SR_OK)
1033                 return SR_ERR;
1034
1035         /* Start of first frame. */
1036         packet.type = SR_DF_FRAME_BEGIN;
1037         sr_session_send(cb_data, &packet);
1038
1039         return SR_OK;
1040 }
1041
1042 static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
1043 {
1044         struct dev_context *devc;
1045         struct sr_scpi_dev_inst *scpi;
1046         struct sr_datafeed_packet packet;
1047
1048         (void)cb_data;
1049
1050         devc = sdi->priv;
1051
1052         if (sdi->status != SR_ST_ACTIVE) {
1053                 sr_err("Device inactive, can't stop acquisition.");
1054                 return SR_ERR;
1055         }
1056
1057         /* End of last frame. */
1058         packet.type = SR_DF_END;
1059         sr_session_send(sdi, &packet);
1060
1061         g_slist_free(devc->enabled_analog_channels);
1062         g_slist_free(devc->enabled_digital_channels);
1063         devc->enabled_analog_channels = NULL;
1064         devc->enabled_digital_channels = NULL;
1065         scpi = sdi->conn;
1066         sr_scpi_source_remove(sdi->session, scpi);
1067
1068         return SR_OK;
1069 }
1070
1071 SR_PRIV struct sr_dev_driver rigol_ds_driver_info = {
1072         .name = "rigol-ds",
1073         .longname = "Rigol DS",
1074         .api_version = 1,
1075         .init = init,
1076         .cleanup = cleanup,
1077         .scan = scan,
1078         .dev_list = dev_list,
1079         .dev_clear = dev_clear,
1080         .config_get = config_get,
1081         .config_set = config_set,
1082         .config_list = config_list,
1083         .dev_open = dev_open,
1084         .dev_close = dev_close,
1085         .dev_acquisition_start = dev_acquisition_start,
1086         .dev_acquisition_stop = dev_acquisition_stop,
1087         .priv = NULL,
1088 };