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 int32_t hwopts[] = {
  33         SR_CONF_CONN,
  34         SR_CONF_SERIALCOMM
  35 };
  36
  37 static const int32_t hwcaps[] = {
  38         SR_CONF_OSCILLOSCOPE,
  39         SR_CONF_TIMEBASE,
  40         SR_CONF_TRIGGER_SOURCE,
  41         SR_CONF_TRIGGER_SLOPE,
  42         SR_CONF_HORIZ_TRIGGERPOS,
  43         SR_CONF_NUM_TIMEBASE,
  44         SR_CONF_LIMIT_FRAMES,
  45         SR_CONF_SAMPLERATE,
  46 };
  47
  48 static const int32_t analog_hwcaps[] = {
  49         SR_CONF_NUM_VDIV,
  50         SR_CONF_VDIV,
  51         SR_CONF_COUPLING,
  52         SR_CONF_DATA_SOURCE,
  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 };
 117
 118 #define NUM_TIMEBASE  ARRAY_SIZE(timebases)
 119 #define NUM_VDIV      ARRAY_SIZE(vdivs)
 120
 121 static const char *trigger_sources[] = {
 122         "CH1",
 123         "CH2",
 124         "CH3",
 125         "CH4",
 126         "EXT",
 127         "AC Line",
 128         "D0",
 129         "D1",
 130         "D2",
 131         "D3",
 132         "D4",
 133         "D5",
 134         "D6",
 135         "D7",
 136         "D8",
 137         "D9",
 138         "D10",
 139         "D11",
 140         "D12",
 141         "D13",
 142         "D14",
 143         "D15",
 144 };
 145
 146 static const char *trigger_slopes[] = {
 147         "r",
 148         "f",
 149 };
 150
 151 static const char *coupling[] = {
 152         "AC",
 153         "DC",
 154         "GND",
 155 };
 156
 157 /* Do not change the order of entries */
 158 static const char *data_sources[] = {
 159         "Live",
 160         "Memory",
 161         "Segmented",
 162 };
 163
 164 enum vendor {
 165         RIGOL,
 166         AGILENT,
 167 };
 168
 169 enum series {
 170         VS5000,
 171         DS1000,
 172         DS2000,
 173         DS2000A,
 174         DSO1000,
 175 };
 176
 177 /* short name, full name */
 178 static const struct rigol_ds_vendor supported_vendors[] = {
 179         [RIGOL] = {"Rigol", "Rigol Technologies"},
 180         [AGILENT] = {"Agilent", "Rigol Technologies"},
 181 };
 182
 183 #define VENDOR(x) &supported_vendors[x]
 184 /* vendor, series, protocol, max timebase, min vdiv, number of horizontal divs,
 185  * live waveform samples, memory buffer samples */
 186 static const struct rigol_ds_series supported_series[] = {
 187         [VS5000] = {VENDOR(RIGOL), "VS5000", PROTOCOL_V1, FORMAT_RAW,
 188                 {50, 1}, {2, 1000}, 14, 2048, 0},
 189         [DS1000] = {VENDOR(RIGOL), "DS1000", PROTOCOL_V2, FORMAT_IEEE488_2,
 190                 {50, 1}, {2, 1000}, 12, 600, 1048576},
 191         [DS2000] = {VENDOR(RIGOL), "DS2000", PROTOCOL_V3, FORMAT_IEEE488_2,
 192                 {500, 1}, {2, 1000}, 14, 1400, 14000},
 193         [DS2000A] = {VENDOR(RIGOL), "DS2000A", PROTOCOL_V3, FORMAT_IEEE488_2,
 194                 {1000, 1}, {500, 1000000}, 14, 1400, 14000},
 195         [DSO1000] = {VENDOR(AGILENT), "DSO1000", PROTOCOL_V3, FORMAT_IEEE488_2,
 196                 {50, 1}, {2, 1000}, 12, 600, 20480},
 197 };
 198
 199 #define SERIES(x) &supported_series[x]
 200 /* series, model, min timebase, analog channels, digital */
 201 static const struct rigol_ds_model supported_models[] = {
 202         {SERIES(VS5000), "VS5022", {20, 1000000000}, 2, false},
 203         {SERIES(VS5000), "VS5042", {10, 1000000000}, 2, false},
 204         {SERIES(VS5000), "VS5062", {5, 1000000000}, 2, false},
 205         {SERIES(VS5000), "VS5102", {2, 1000000000}, 2, false},
 206         {SERIES(VS5000), "VS5202", {2, 1000000000}, 2, false},
 207         {SERIES(VS5000), "VS5022D", {20, 1000000000}, 2, true},
 208         {SERIES(VS5000), "VS5042D", {10, 1000000000}, 2, true},
 209         {SERIES(VS5000), "VS5062D", {5, 1000000000}, 2, true},
 210         {SERIES(VS5000), "VS5102D", {2, 1000000000}, 2, true},
 211         {SERIES(VS5000), "VS5202D", {2, 1000000000}, 2, true},
 212         {SERIES(DS1000), "DS1052E", {5, 1000000000}, 2, false},
 213         {SERIES(DS1000), "DS1102E", {2, 1000000000}, 2, false},
 214         {SERIES(DS1000), "DS1152E", {2, 1000000000}, 2, false},
 215         {SERIES(DS1000), "DS1052D", {5, 1000000000}, 2, true},
 216         {SERIES(DS1000), "DS1102D", {2, 1000000000}, 2, true},
 217         {SERIES(DS1000), "DS1152D", {2, 1000000000}, 2, true},
 218         {SERIES(DS2000), "DS2072", {5, 1000000000}, 2, false},
 219         {SERIES(DS2000), "DS2102", {5, 1000000000}, 2, false},
 220         {SERIES(DS2000), "DS2202", {2, 1000000000}, 2, false},
 221         {SERIES(DS2000), "DS2302", {1, 1000000000}, 2, false},
 222         {SERIES(DS2000A), "DS2072A", {5, 1000000000}, 2, false},
 223         {SERIES(DS2000A), "DS2102A", {5, 1000000000}, 2, false},
 224         {SERIES(DS2000A), "DS2202A", {2, 1000000000}, 2, false},
 225         {SERIES(DS2000A), "DS2302A", {1, 1000000000}, 2, false},
 226         {SERIES(DSO1000), "DSO1002A", {5, 1000000000}, 2, false},
 227         {SERIES(DSO1000), "DSO1004A", {5, 1000000000}, 4, false},
 228         {SERIES(DSO1000), "DSO1012A", {2, 1000000000}, 2, false},
 229         {SERIES(DSO1000), "DSO1014A", {2, 1000000000}, 4, false},
 230         {SERIES(DSO1000), "DSO1022A", {2, 1000000000}, 2, false},
 231         {SERIES(DSO1000), "DSO1024A", {2, 1000000000}, 4, false},
 232 };
 233
 234 SR_PRIV struct sr_dev_driver rigol_ds_driver_info;
 235 static struct sr_dev_driver *di = &rigol_ds_driver_info;
 236
 237 static void clear_helper(void *priv)
 238 {
 239         struct dev_context *devc;
 240
 241         devc = priv;
 242         g_free(devc->data);
 243         g_free(devc->buffer);
 244         g_free(devc->coupling[0]);
 245         g_free(devc->coupling[1]);
 246         g_free(devc->trigger_source);
 247         g_free(devc->trigger_slope);
 248         g_slist_free(devc->analog_groups[0].channels);
 249         g_slist_free(devc->analog_groups[1].channels);
 250         g_slist_free(devc->digital_group.channels);
 251 }
 252
 253 static int dev_clear(void)
 254 {
 255         return std_dev_clear(di, clear_helper);
 256 }
 257
 258 static int init(struct sr_context *sr_ctx)
 259 {
 260         return std_init(sr_ctx, di, LOG_PREFIX);
 261 }
 262
 263 static struct sr_dev_inst *probe_device(struct sr_scpi_dev_inst *scpi)
 264 {
 265         struct dev_context *devc;
 266         struct sr_dev_inst *sdi;
 267         struct sr_scpi_hw_info *hw_info;
 268         struct sr_channel *ch;
 269         long n[3];
 270         unsigned int i;
 271         const struct rigol_ds_model *model = NULL;
 272         gchar *channel_name, **version;
 273
 274         if (sr_scpi_get_hw_id(scpi, &hw_info) != SR_OK) {
 275                 sr_info("Couldn't get IDN response.");
 276                 sr_scpi_close(scpi);
 277                 sr_scpi_free(scpi);
 278                 return NULL;
 279         }
 280
 281         for (i = 0; i < ARRAY_SIZE(supported_models); i++) {
 282                 if (!strcasecmp(hw_info->manufacturer,
 283                                         supported_models[i].series->vendor->full_name) &&
 284                                 !strcmp(hw_info->model, supported_models[i].name)) {
 285                         model = &supported_models[i];
 286                         break;
 287                 }
 288         }
 289
 290         if (!model || !(sdi = sr_dev_inst_new(0, SR_ST_ACTIVE,
 291                                               model->series->vendor->name,
 292                                                   model->name,
 293                                                   hw_info->firmware_version))) {
 294                 sr_scpi_hw_info_free(hw_info);
 295                 sr_scpi_close(scpi);
 296                 sr_scpi_free(scpi);
 297                 return NULL;
 298         }
 299
 300         sr_scpi_close(scpi);
 301
 302         sdi->conn = scpi;
 303
 304         sdi->driver = di;
 305         sdi->inst_type = SR_INST_SCPI;
 306
 307         if (!(devc = g_try_malloc0(sizeof(struct dev_context))))
 308                 return NULL;
 309
 310         devc->limit_frames = 0;
 311         devc->model = model;
 312         devc->format = model->series->format;
 313
 314         /* DS1000 models with firmware before 0.2.4 used the old data format. */
 315         if (model->series == SERIES(DS1000)) {
 316                 version = g_strsplit(hw_info->firmware_version, ".", 0);
 317                 do {
 318                         if (!version[0] || !version[1] || !version[2])
 319                                 break;
 320                         if (version[0][0] == 0 || version[1][0] == 0 || version[2][0] == 0)
 321                                 break;
 322                         for (i = 0; i < 3; i++) {
 323                                 if (sr_atol(version[i], &n[i]) != SR_OK)
 324                                         break;
 325                         }
 326                         if (i != 3)
 327                                 break;
 328                         if (n[0] != 0 || n[1] > 2)
 329                                 break;
 330                         if (n[1] == 2 && n[2] > 3)
 331                                 break;
 332                         sr_dbg("Found DS1000 firmware < 0.2.4, using raw data format.");
 333                         devc->format = FORMAT_RAW;
 334                 } while(0);
 335                 g_strfreev(version);
 336         }
 337
 338         sr_scpi_hw_info_free(hw_info);
 339
 340         for (i = 0; i < model->analog_channels; i++) {
 341                 if (!(channel_name = g_strdup_printf("CH%d", i + 1)))
 342                         return NULL;
 343                 ch = sr_channel_new(i, SR_CHANNEL_ANALOG, TRUE, channel_name);
 344                 sdi->channels = g_slist_append(sdi->channels, ch);
 345                 devc->analog_groups[i].name = channel_name;
 346                 devc->analog_groups[i].channels = g_slist_append(NULL, ch);
 347                 sdi->channel_groups = g_slist_append(sdi->channel_groups,
 348                                 &devc->analog_groups[i]);
 349         }
 350
 351         if (devc->model->has_digital) {
 352                 for (i = 0; i < 16; i++) {
 353                         if (!(channel_name = g_strdup_printf("D%d", i)))
 354                                 return NULL;
 355                         ch = sr_channel_new(i, SR_CHANNEL_LOGIC, TRUE, channel_name);
 356                         g_free(channel_name);
 357                         if (!ch)
 358                                 return NULL;
 359                         sdi->channels = g_slist_append(sdi->channels, ch);
 360                         devc->digital_group.channels = g_slist_append(
 361                                         devc->digital_group.channels, ch);
 362                 }
 363                 devc->digital_group.name = "LA";
 364                 sdi->channel_groups = g_slist_append(sdi->channel_groups,
 365                                 &devc->digital_group);
 366         }
 367
 368         for (i = 0; i < NUM_TIMEBASE; i++) {
 369                 if (!memcmp(&devc->model->min_timebase, &timebases[i], sizeof(uint64_t[2])))
 370                         devc->timebases = &timebases[i];
 371                 if (!memcmp(&devc->model->series->max_timebase, &timebases[i], sizeof(uint64_t[2])))
 372                         devc->num_timebases = &timebases[i] - devc->timebases + 1;
 373         }
 374
 375         for (i = 0; i < NUM_VDIV; i++)
 376                 if (!memcmp(&devc->model->series->min_vdiv, &vdivs[i], sizeof(uint64_t[2])))
 377                         devc->vdivs = &vdivs[i];
 378
 379         if (!(devc->buffer = g_try_malloc(ACQ_BUFFER_SIZE)))
 380                 return NULL;
 381         if (!(devc->data = g_try_malloc(ACQ_BUFFER_SIZE * sizeof(float))))
 382                 return NULL;
 383
 384         devc->data_source = DATA_SOURCE_LIVE;
 385
 386         sdi->priv = devc;
 387
 388         return sdi;
 389 }
 390
 391 static GSList *scan(GSList *options)
 392 {
 393         return sr_scpi_scan(di->priv, options, probe_device);
 394 }
 395
 396 static GSList *dev_list(void)
 397 {
 398         return ((struct drv_context *)(di->priv))->instances;
 399 }
 400
 401 static int dev_open(struct sr_dev_inst *sdi)
 402 {
 403         struct sr_scpi_dev_inst *scpi = sdi->conn;
 404
 405         if (sr_scpi_open(scpi) < 0)
 406                 return SR_ERR;
 407
 408         if (rigol_ds_get_dev_cfg(sdi) != SR_OK)
 409                 return SR_ERR;
 410
 411         sdi->status = SR_ST_ACTIVE;
 412
 413         return SR_OK;
 414 }
 415
 416 static int dev_close(struct sr_dev_inst *sdi)
 417 {
 418         struct sr_scpi_dev_inst *scpi;
 419         struct dev_context *devc;
 420
 421         if (sdi->status != SR_ST_ACTIVE)
 422                 return SR_ERR_DEV_CLOSED;
 423
 424         scpi = sdi->conn;
 425         devc = sdi->priv;
 426
 427         if (devc->model->series->protocol == PROTOCOL_V2)
 428                 rigol_ds_config_set(sdi, ":KEY:LOCK DISABLE");
 429
 430         if (scpi) {
 431                 if (sr_scpi_close(scpi) < 0)
 432                         return SR_ERR;
 433                 sdi->status = SR_ST_INACTIVE;
 434         }
 435
 436         return SR_OK;
 437 }
 438
 439 static int cleanup(void)
 440 {
 441         return dev_clear();
 442 }
 443
 444 static int analog_frame_size(const struct sr_dev_inst *sdi)
 445 {
 446         struct dev_context *devc = sdi->priv;
 447         struct sr_channel *ch;
 448         int analog_channels = 0;
 449         GSList *l;
 450
 451         for (l = sdi->channels; l; l = l->next) {
 452                 ch = l->data;
 453                 if (ch->type == SR_CHANNEL_ANALOG && ch->enabled)
 454                         analog_channels++;
 455         }
 456
 457         if (analog_channels == 0)
 458                 return 0;
 459
 460         switch (devc->data_source) {
 461         case DATA_SOURCE_LIVE:
 462                 return devc->model->series->live_samples;
 463         case DATA_SOURCE_MEMORY:
 464                 return devc->model->series->buffer_samples / analog_channels;
 465         default:
 466                 return 0;
 467         }
 468 }
 469
 470 static int digital_frame_size(const struct sr_dev_inst *sdi)
 471 {
 472         struct dev_context *devc = sdi->priv;
 473
 474         switch (devc->data_source) {
 475         case DATA_SOURCE_LIVE:
 476                 return devc->model->series->live_samples * 2;
 477         case DATA_SOURCE_MEMORY:
 478                 return devc->model->series->buffer_samples * 2;
 479         default:
 480                 return 0;
 481         }
 482 }
 483
 484 static int config_get(int id, GVariant **data, const struct sr_dev_inst *sdi,
 485                 const struct sr_channel_group *cg)
 486 {
 487         struct dev_context *devc;
 488         struct sr_channel *ch;
 489         const char *tmp_str;
 490         uint64_t samplerate;
 491         int analog_channel = -1;
 492         float smallest_diff = 0.0000000001;
 493         int idx = -1;
 494         unsigned i;
 495
 496         if (!sdi || !(devc = sdi->priv))
 497                 return SR_ERR_ARG;
 498
 499         /* If a channel group is specified, it must be a valid one. */
 500         if (cg && !g_slist_find(sdi->channel_groups, cg)) {
 501                 sr_err("Invalid channel group specified.");
 502                 return SR_ERR;
 503         }
 504
 505         if (cg) {
 506                 ch = g_slist_nth_data(cg->channels, 0);
 507                 if (!ch)
 508                         return SR_ERR;
 509                 if (ch->type == SR_CHANNEL_ANALOG) {
 510                         if (ch->name[2] < '1' || ch->name[2] > '4')
 511                                 return SR_ERR;
 512                         analog_channel = ch->name[2] - '1';
 513                 }
 514         }
 515
 516         switch (id) {
 517         case SR_CONF_NUM_TIMEBASE:
 518                 *data = g_variant_new_int32(devc->model->series->num_horizontal_divs);
 519                 break;
 520         case SR_CONF_NUM_VDIV:
 521                 *data = g_variant_new_int32(NUM_VDIV);
 522         case SR_CONF_DATA_SOURCE:
 523                 if (devc->data_source == DATA_SOURCE_LIVE)
 524                         *data = g_variant_new_string("Live");
 525                 else if (devc->data_source == DATA_SOURCE_MEMORY)
 526                         *data = g_variant_new_string("Memory");
 527                 else
 528                         *data = g_variant_new_string("Segmented");
 529                 break;
 530         case SR_CONF_SAMPLERATE:
 531                 if (devc->data_source == DATA_SOURCE_LIVE) {
 532                         samplerate = analog_frame_size(sdi) /
 533                                 (devc->timebase * devc->model->series->num_horizontal_divs);
 534                         *data = g_variant_new_uint64(samplerate);
 535                 } else {
 536                         return SR_ERR_NA;
 537                 }
 538                 break;
 539         case SR_CONF_TRIGGER_SOURCE:
 540                 if (!strcmp(devc->trigger_source, "ACL"))
 541                         tmp_str = "AC Line";
 542                 else if (!strcmp(devc->trigger_source, "CHAN1"))
 543                         tmp_str = "CH1";
 544                 else if (!strcmp(devc->trigger_source, "CHAN2"))
 545                         tmp_str = "CH2";
 546                 else if (!strcmp(devc->trigger_source, "CHAN3"))
 547                         tmp_str = "CH3";
 548                 else if (!strcmp(devc->trigger_source, "CHAN4"))
 549                         tmp_str = "CH4";
 550                 else
 551                         tmp_str = devc->trigger_source;
 552                 *data = g_variant_new_string(tmp_str);
 553                 break;
 554         case SR_CONF_TRIGGER_SLOPE:
 555                 if (!strcmp(devc->trigger_slope, "POS"))
 556                         tmp_str = "r";
 557                 else if (!strcmp(devc->trigger_slope, "NEG"))
 558                         tmp_str = "f";
 559                 else
 560                         return SR_ERR_NA;
 561                 *data = g_variant_new_string(tmp_str);
 562                 break;
 563         case SR_CONF_TIMEBASE:
 564                 for (i = 0; i < devc->num_timebases; i++) {
 565                         float tb = (float)devc->timebases[i][0] / devc->timebases[i][1];
 566                         float diff = fabs(devc->timebase - tb);
 567                         if (diff < smallest_diff) {
 568                                 smallest_diff = diff;
 569                                 idx = i;
 570                         }
 571                 }
 572                 if (idx < 0)
 573                         return SR_ERR_NA;
 574                 *data = g_variant_new("(tt)", devc->timebases[idx][0],
 575                                               devc->timebases[idx][1]);
 576                 break;
 577         case SR_CONF_VDIV:
 578                 if (analog_channel < 0)
 579                         return SR_ERR_NA;
 580                 for (i = 0; i < ARRAY_SIZE(vdivs); i++) {
 581                         float vdiv = (float)vdivs[i][0] / vdivs[i][1];
 582                         float diff = fabs(devc->vdiv[analog_channel] - vdiv);
 583                         if (diff < smallest_diff) {
 584                                 smallest_diff = diff;
 585                                 idx = i;
 586                         }
 587                 }
 588                 if (idx < 0)
 589                         return SR_ERR_NA;
 590                 *data = g_variant_new("(tt)", vdivs[idx][0], vdivs[idx][1]);
 591                 break;
 592         case SR_CONF_COUPLING:
 593                 if (analog_channel < 0)
 594                         return SR_ERR_NA;
 595                 *data = g_variant_new_string(devc->coupling[analog_channel]);
 596                 break;
 597         default:
 598                 return SR_ERR_NA;
 599         }
 600
 601         return SR_OK;
 602 }
 603
 604 static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi,
 605                 const struct sr_channel_group *cg)
 606 {
 607         struct dev_context *devc;
 608         uint64_t p, q;
 609         double t_dbl;
 610         unsigned int i, j;
 611         int ret;
 612         const char *tmp_str;
 613         char buffer[16];
 614
 615         if (!(devc = sdi->priv))
 616                 return SR_ERR_ARG;
 617
 618         if (sdi->status != SR_ST_ACTIVE)
 619                 return SR_ERR_DEV_CLOSED;
 620
 621         /* If a channel group is specified, it must be a valid one. */
 622         if (cg && !g_slist_find(sdi->channel_groups, cg)) {
 623                 sr_err("Invalid channel group specified.");
 624                 return SR_ERR;
 625         }
 626
 627         ret = SR_OK;
 628         switch (id) {
 629         case SR_CONF_LIMIT_FRAMES:
 630                 devc->limit_frames = g_variant_get_uint64(data);
 631                 break;
 632         case SR_CONF_TRIGGER_SLOPE:
 633                 tmp_str = g_variant_get_string(data, NULL);
 634
 635                 if (!tmp_str || !(tmp_str[0] == 'f' || tmp_str[0] == 'r'))
 636                         return SR_ERR_ARG;
 637
 638                 g_free(devc->trigger_slope);
 639                 devc->trigger_slope = g_strdup((tmp_str[0] == 'r') ? "POS" : "NEG");
 640                 ret = rigol_ds_config_set(sdi, ":TRIG:EDGE:SLOP %s", devc->trigger_slope);
 641                 break;
 642         case SR_CONF_HORIZ_TRIGGERPOS:
 643                 t_dbl = g_variant_get_double(data);
 644                 if (t_dbl < 0.0 || t_dbl > 1.0)
 645                         return SR_ERR;
 646                 devc->horiz_triggerpos = t_dbl;
 647                 /* We have the trigger offset as a percentage of the frame, but
 648                  * need to express this in seconds. */
 649                 t_dbl = -(devc->horiz_triggerpos - 0.5) * devc->timebase * devc->num_timebases;
 650                 g_ascii_formatd(buffer, sizeof(buffer), "%.6f", t_dbl);
 651                 ret = rigol_ds_config_set(sdi, ":TIM:OFFS %s", buffer);
 652                 break;
 653         case SR_CONF_TIMEBASE:
 654                 g_variant_get(data, "(tt)", &p, &q);
 655                 for (i = 0; i < devc->num_timebases; i++) {
 656                         if (devc->timebases[i][0] == p && devc->timebases[i][1] == q) {
 657                                 devc->timebase = (float)p / q;
 658                                 g_ascii_formatd(buffer, sizeof(buffer), "%.9f",
 659                                                 devc->timebase);
 660                                 ret = rigol_ds_config_set(sdi, ":TIM:SCAL %s", buffer);
 661                                 break;
 662                         }
 663                 }
 664                 if (i == devc->num_timebases)
 665                         ret = SR_ERR_ARG;
 666                 break;
 667         case SR_CONF_TRIGGER_SOURCE:
 668                 tmp_str = g_variant_get_string(data, NULL);
 669                 for (i = 0; i < ARRAY_SIZE(trigger_sources); i++) {
 670                         if (!strcmp(trigger_sources[i], tmp_str)) {
 671                                 g_free(devc->trigger_source);
 672                                 devc->trigger_source = g_strdup(trigger_sources[i]);
 673                                 if (!strcmp(devc->trigger_source, "AC Line"))
 674                                         tmp_str = "ACL";
 675                                 else if (!strcmp(devc->trigger_source, "CH1"))
 676                                         tmp_str = "CHAN1";
 677                                 else if (!strcmp(devc->trigger_source, "CH2"))
 678                                         tmp_str = "CHAN2";
 679                                 else if (!strcmp(devc->trigger_source, "CH3"))
 680                                         tmp_str = "CHAN3";
 681                                 else if (!strcmp(devc->trigger_source, "CH4"))
 682                                         tmp_str = "CHAN4";
 683                                 else
 684                                         tmp_str = (char *)devc->trigger_source;
 685                                 ret = rigol_ds_config_set(sdi, ":TRIG:EDGE:SOUR %s", tmp_str);
 686                                 break;
 687                         }
 688                 }
 689                 if (i == ARRAY_SIZE(trigger_sources))
 690                         ret = SR_ERR_ARG;
 691                 break;
 692         case SR_CONF_VDIV:
 693                 if (!cg) {
 694                         sr_err("No channel group specified.");
 695                         return SR_ERR_CHANNEL_GROUP;
 696                 }
 697                 g_variant_get(data, "(tt)", &p, &q);
 698                 for (i = 0; i < 2; i++) {
 699                         if (cg == &devc->analog_groups[i]) {
 700                                 for (j = 0; j < ARRAY_SIZE(vdivs); j++) {
 701                                         if (vdivs[j][0] != p || vdivs[j][1] != q)
 702                                                 continue;
 703                                         devc->vdiv[i] = (float)p / q;
 704                                         g_ascii_formatd(buffer, sizeof(buffer), "%.3f",
 705                                                         devc->vdiv[i]);
 706                                         return rigol_ds_config_set(sdi, ":CHAN%d:SCAL %s", i + 1,
 707                                                         buffer);
 708                                 }
 709                                 return SR_ERR_ARG;
 710                         }
 711                 }
 712                 return SR_ERR_NA;
 713         case SR_CONF_COUPLING:
 714                 if (!cg) {
 715                         sr_err("No channel group specified.");
 716                         return SR_ERR_CHANNEL_GROUP;
 717                 }
 718                 tmp_str = g_variant_get_string(data, NULL);
 719                 for (i = 0; i < 2; i++) {
 720                         if (cg == &devc->analog_groups[i]) {
 721                                 for (j = 0; j < ARRAY_SIZE(coupling); j++) {
 722                                         if (!strcmp(tmp_str, coupling[j])) {
 723                                                 g_free(devc->coupling[i]);
 724                                                 devc->coupling[i] = g_strdup(coupling[j]);
 725                                                 return rigol_ds_config_set(sdi, ":CHAN%d:COUP %s", i + 1,
 726                                                                 devc->coupling[i]);
 727                                         }
 728                                 }
 729                                 return SR_ERR_ARG;
 730                         }
 731                 }
 732                 return SR_ERR_NA;
 733         case SR_CONF_DATA_SOURCE:
 734                 tmp_str = g_variant_get_string(data, NULL);
 735                 if (!strcmp(tmp_str, "Live"))
 736                         devc->data_source = DATA_SOURCE_LIVE;
 737                 else if (devc->model->series->protocol >= PROTOCOL_V2
 738                         && !strcmp(tmp_str, "Memory"))
 739                         devc->data_source = DATA_SOURCE_MEMORY;
 740                 else if (devc->model->series->protocol >= PROTOCOL_V3
 741                          && !strcmp(tmp_str, "Segmented"))
 742                         devc->data_source = DATA_SOURCE_SEGMENTED;
 743                 else
 744                         return SR_ERR;
 745                 break;
 746         default:
 747                 ret = SR_ERR_NA;
 748                 break;
 749         }
 750
 751         return ret;
 752 }
 753
 754 static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi,
 755                 const struct sr_channel_group *cg)
 756 {
 757         GVariant *tuple, *rational[2];
 758         GVariantBuilder gvb;
 759         unsigned int i;
 760         struct dev_context *devc = NULL;
 761
 762         if (sdi)
 763                 devc = sdi->priv;
 764
 765         if (key == SR_CONF_SCAN_OPTIONS) {
 766                 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
 767                                 hwopts, ARRAY_SIZE(hwopts), sizeof(int32_t));
 768                 return SR_OK;
 769         } else if (key == SR_CONF_DEVICE_OPTIONS && cg == NULL) {
 770                 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
 771                         hwcaps, ARRAY_SIZE(hwcaps), sizeof(int32_t));
 772                 return SR_OK;
 773         }
 774
 775         /* Every other option requires a valid device instance. */
 776         if (!sdi || !(devc = sdi->priv))
 777                 return SR_ERR_ARG;
 778
 779         /* If a channel group is specified, it must be a valid one. */
 780         if (cg) {
 781                 if (cg != &devc->analog_groups[0]
 782                                 && cg != &devc->analog_groups[1]) {
 783                         sr_err("Invalid channel group specified.");
 784                         return SR_ERR;
 785                 }
 786         }
 787
 788         switch (key) {
 789         case SR_CONF_DEVICE_OPTIONS:
 790                 if (!cg) {
 791                         sr_err("No channel group specified.");
 792                         return SR_ERR_CHANNEL_GROUP;
 793                 }
 794                 if (cg == &devc->digital_group) {
 795                         *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
 796                                 NULL, 0, sizeof(int32_t));
 797                         return SR_OK;
 798                 } else {
 799                         for (i = 0; i < 2; i++) {
 800                                 if (cg == &devc->analog_groups[i]) {
 801                                         *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
 802                                                 analog_hwcaps, ARRAY_SIZE(analog_hwcaps), sizeof(int32_t));
 803                                         return SR_OK;
 804                                 }
 805                         }
 806                         return SR_ERR_NA;
 807                 }
 808                 break;
 809         case SR_CONF_COUPLING:
 810                 if (!cg) {
 811                         sr_err("No channel group specified.");
 812                         return SR_ERR_CHANNEL_GROUP;
 813                 }
 814                 *data = g_variant_new_strv(coupling, ARRAY_SIZE(coupling));
 815                 break;
 816         case SR_CONF_VDIV:
 817                 if (!devc)
 818                         /* Can't know this until we have the exact model. */
 819                         return SR_ERR_ARG;
 820                 if (!cg) {
 821                         sr_err("No channel group specified.");
 822                         return SR_ERR_CHANNEL_GROUP;
 823                 }
 824                 g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
 825                 for (i = 0; i < NUM_VDIV; i++) {
 826                         rational[0] = g_variant_new_uint64(devc->vdivs[i][0]);
 827                         rational[1] = g_variant_new_uint64(devc->vdivs[i][1]);
 828                         tuple = g_variant_new_tuple(rational, 2);
 829                         g_variant_builder_add_value(&gvb, tuple);
 830                 }
 831                 *data = g_variant_builder_end(&gvb);
 832                 break;
 833         case SR_CONF_TIMEBASE:
 834                 if (!devc)
 835                         /* Can't know this until we have the exact model. */
 836                         return SR_ERR_ARG;
 837                 if (devc->num_timebases <= 0)
 838                         return SR_ERR_NA;
 839                 g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
 840                 for (i = 0; i < devc->num_timebases; i++) {
 841                         rational[0] = g_variant_new_uint64(devc->timebases[i][0]);
 842                         rational[1] = g_variant_new_uint64(devc->timebases[i][1]);
 843                         tuple = g_variant_new_tuple(rational, 2);
 844                         g_variant_builder_add_value(&gvb, tuple);
 845                 }
 846                 *data = g_variant_builder_end(&gvb);
 847                 break;
 848         case SR_CONF_TRIGGER_SOURCE:
 849                 if (!devc)
 850                         /* Can't know this until we have the exact model. */
 851                         return SR_ERR_ARG;
 852                 *data = g_variant_new_strv(trigger_sources,
 853                                 devc->model->has_digital ? ARRAY_SIZE(trigger_sources) : 4);
 854                 break;
 855         case SR_CONF_TRIGGER_SLOPE:
 856                 *data = g_variant_new_strv(trigger_slopes, ARRAY_SIZE(trigger_slopes));
 857                 break;
 858         case SR_CONF_DATA_SOURCE:
 859                 if (!devc)
 860                         /* Can't know this until we have the exact model. */
 861                         return SR_ERR_ARG;
 862                 switch (devc->model->series->protocol) {
 863                 case PROTOCOL_V1:
 864                         *data = g_variant_new_strv(data_sources, ARRAY_SIZE(data_sources) - 2);
 865                         break;
 866                 case PROTOCOL_V2:
 867                         *data = g_variant_new_strv(data_sources, ARRAY_SIZE(data_sources) - 1);
 868                         break;
 869                 default:
 870                         *data = g_variant_new_strv(data_sources, ARRAY_SIZE(data_sources));
 871                         break;
 872                 }
 873                 break;
 874         default:
 875                 return SR_ERR_NA;
 876         }
 877
 878         return SR_OK;
 879 }
 880
 881 static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
 882 {
 883         struct sr_scpi_dev_inst *scpi;
 884         struct dev_context *devc;
 885         struct sr_channel *ch;
 886         struct sr_datafeed_packet packet;
 887         GSList *l;
 888
 889         if (sdi->status != SR_ST_ACTIVE)
 890                 return SR_ERR_DEV_CLOSED;
 891
 892         scpi = sdi->conn;
 893         devc = sdi->priv;
 894
 895         devc->num_frames = 0;
 896
 897         for (l = sdi->channels; l; l = l->next) {
 898                 ch = l->data;
 899                 sr_dbg("handling channel %s", ch->name);
 900                 if (ch->type == SR_CHANNEL_ANALOG) {
 901                         if (ch->enabled)
 902                                 devc->enabled_analog_channels = g_slist_append(
 903                                                 devc->enabled_analog_channels, ch);
 904                         if (ch->enabled != devc->analog_channels[ch->index]) {
 905                                 /* Enabled channel is currently disabled, or vice versa. */
 906                                 if (rigol_ds_config_set(sdi, ":CHAN%d:DISP %s", ch->index + 1,
 907                                                 ch->enabled ? "ON" : "OFF") != SR_OK)
 908                                         return SR_ERR;
 909                                 devc->analog_channels[ch->index] = ch->enabled;
 910                         }
 911                 } else if (ch->type == SR_CHANNEL_LOGIC) {
 912                         if (ch->enabled) {
 913                                 devc->enabled_digital_channels = g_slist_append(
 914                                                 devc->enabled_digital_channels, ch);
 915                                 /* Turn on LA module if currently off. */
 916                                 if (!devc->la_enabled) {
 917                                         if (rigol_ds_config_set(sdi, ":LA:DISP ON") != SR_OK)
 918                                                 return SR_ERR;
 919                                         devc->la_enabled = TRUE;
 920                                 }
 921                         }
 922                         if (ch->enabled != devc->digital_channels[ch->index]) {
 923                                 /* Enabled channel is currently disabled, or vice versa. */
 924                                 if (rigol_ds_config_set(sdi, ":DIG%d:TURN %s", ch->index,
 925                                                 ch->enabled ? "ON" : "OFF") != SR_OK)
 926                                         return SR_ERR;
 927                                 devc->digital_channels[ch->index] = ch->enabled;
 928                         }
 929                 }
 930         }
 931
 932         if (!devc->enabled_analog_channels && !devc->enabled_digital_channels)
 933                 return SR_ERR;
 934
 935         /* Turn off LA module if on and no digital channels selected. */
 936         if (devc->la_enabled && !devc->enabled_digital_channels)
 937                 if (rigol_ds_config_set(sdi, ":LA:DISP OFF") != SR_OK)
 938                         return SR_ERR;
 939
 940         /* Set memory mode. */
 941         if (devc->data_source == DATA_SOURCE_SEGMENTED) {
 942                 sr_err("Data source 'Segmented' not yet supported");
 943                 return SR_ERR;
 944         }
 945
 946         devc->analog_frame_size = analog_frame_size(sdi);
 947         devc->digital_frame_size = digital_frame_size(sdi);
 948
 949         switch (devc->model->series->protocol) {
 950         case PROTOCOL_V2:
 951                 if (rigol_ds_config_set(sdi, ":ACQ:MDEP LONG") != SR_OK)
 952                         return SR_ERR;
 953                 break;
 954         case PROTOCOL_V3:
 955                 /* Apparently for the DS2000 the memory
 956                  * depth can only be set in Running state -
 957                  * this matches the behaviour of the UI. */
 958                 if (rigol_ds_config_set(sdi, ":RUN") != SR_OK)
 959                         return SR_ERR;
 960                 if (rigol_ds_config_set(sdi, ":ACQ:MDEP %d",
 961                                         devc->analog_frame_size) != SR_OK)
 962                         return SR_ERR;
 963                 if (rigol_ds_config_set(sdi, ":STOP") != SR_OK)
 964                         return SR_ERR;
 965                 break;
 966         default:
 967                 break;
 968         }
 969
 970         if (devc->data_source == DATA_SOURCE_LIVE)
 971                 if (rigol_ds_config_set(sdi, ":RUN") != SR_OK)
 972                         return SR_ERR;
 973
 974         sr_scpi_source_add(scpi, G_IO_IN, 50, rigol_ds_receive, (void *)sdi);
 975
 976         /* Send header packet to the session bus. */
 977         std_session_send_df_header(cb_data, LOG_PREFIX);
 978
 979         if (devc->enabled_analog_channels)
 980                 devc->channel_entry = devc->enabled_analog_channels;
 981         else
 982                 devc->channel_entry = devc->enabled_digital_channels;
 983
 984         if (rigol_ds_capture_start(sdi) != SR_OK)
 985                 return SR_ERR;
 986
 987         /* Start of first frame. */
 988         packet.type = SR_DF_FRAME_BEGIN;
 989         sr_session_send(cb_data, &packet);
 990
 991         return SR_OK;
 992 }
 993
 994 static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
 995 {
 996         struct dev_context *devc;
 997         struct sr_scpi_dev_inst *scpi;
 998         struct sr_datafeed_packet packet;
 999
1000         (void)cb_data;
1001
1002         devc = sdi->priv;
1003
1004         if (sdi->status != SR_ST_ACTIVE) {
1005                 sr_err("Device inactive, can't stop acquisition.");
1006                 return SR_ERR;
1007         }
1008
1009         /* End of last frame. */
1010         packet.type = SR_DF_END;
1011         sr_session_send(sdi, &packet);
1012
1013         g_slist_free(devc->enabled_analog_channels);
1014         g_slist_free(devc->enabled_digital_channels);
1015         devc->enabled_analog_channels = NULL;
1016         devc->enabled_digital_channels = NULL;
1017         scpi = sdi->conn;
1018         sr_scpi_source_remove(scpi);
1019
1020         return SR_OK;
1021 }
1022
1023 SR_PRIV struct sr_dev_driver rigol_ds_driver_info = {
1024         .name = "rigol-ds",
1025         .longname = "Rigol DS",
1026         .api_version = 1,
1027         .init = init,
1028         .cleanup = cleanup,
1029         .scan = scan,
1030         .dev_list = dev_list,
1031         .dev_clear = dev_clear,
1032         .config_get = config_get,
1033         .config_set = config_set,
1034         .config_list = config_list,
1035         .dev_open = dev_open,
1036         .dev_close = dev_close,
1037         .dev_acquisition_start = dev_acquisition_start,
1038         .dev_acquisition_stop = dev_acquisition_stop,
1039         .priv = NULL,
1040 };