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 <glib.h>
  27 #include "libsigrok.h"
  28 #include "libsigrok-internal.h"
  29 #include "protocol.h"
  30
  31 static const int32_t hwopts[] = {
  32         SR_CONF_CONN,
  33         SR_CONF_SERIALCOMM
  34 };
  35
  36 static const int32_t hwcaps[] = {
  37         SR_CONF_OSCILLOSCOPE,
  38         SR_CONF_TIMEBASE,
  39         SR_CONF_TRIGGER_SOURCE,
  40         SR_CONF_TRIGGER_SLOPE,
  41         SR_CONF_HORIZ_TRIGGERPOS,
  42         SR_CONF_NUM_TIMEBASE,
  43 };
  44
  45 static const int32_t analog_hwcaps[] = {
  46         SR_CONF_NUM_VDIV,
  47         SR_CONF_VDIV,
  48         SR_CONF_COUPLING,
  49         SR_CONF_DATA_SOURCE,
  50 };
  51
  52 static const uint64_t timebases[][2] = {
  53         /* nanoseconds */
  54         { 2, 1000000000 },
  55         { 5, 1000000000 },
  56         { 10, 1000000000 },
  57         { 20, 1000000000 },
  58         { 50, 1000000000 },
  59         { 100, 1000000000 },
  60         { 500, 1000000000 },
  61         /* microseconds */
  62         { 1, 1000000 },
  63         { 2, 1000000 },
  64         { 5, 1000000 },
  65         { 10, 1000000 },
  66         { 20, 1000000 },
  67         { 50, 1000000 },
  68         { 100, 1000000 },
  69         { 200, 1000000 },
  70         { 500, 1000000 },
  71         /* milliseconds */
  72         { 1, 1000 },
  73         { 2, 1000 },
  74         { 5, 1000 },
  75         { 10, 1000 },
  76         { 20, 1000 },
  77         { 50, 1000 },
  78         { 100, 1000 },
  79         { 200, 1000 },
  80         { 500, 1000 },
  81         /* seconds */
  82         { 1, 1 },
  83         { 2, 1 },
  84         { 5, 1 },
  85         { 10, 1 },
  86         { 20, 1 },
  87         { 50, 1 },
  88         { 100, 1 },
  89         { 200, 1 },
  90         { 500, 1 },
  91         /* { 1000, 1 }, Confuses other code? */
  92 };
  93
  94 static const uint64_t vdivs[][2] = {
  95         /* microvolts */
  96         { 500, 1000000 },
  97         /* millivolts */
  98         { 1, 1000 },
  99         { 2, 1000 },
 100         { 5, 1000 },
 101         { 10, 1000 },
 102         { 20, 1000 },
 103         { 50, 1000 },
 104         { 100, 1000 },
 105         { 200, 1000 },
 106         { 500, 1000 },
 107         /* volts */
 108         { 1, 1 },
 109         { 2, 1 },
 110         { 5, 1 },
 111         { 10, 1 },
 112 };
 113
 114 #define NUM_TIMEBASE  ARRAY_SIZE(timebases)
 115 #define NUM_VDIV      ARRAY_SIZE(vdivs)
 116
 117 static const char *trigger_sources[] = {
 118         "CH1",
 119         "CH2",
 120         "CH3",
 121         "CH4",
 122         "EXT",
 123         "AC Line",
 124         "D0",
 125         "D1",
 126         "D2",
 127         "D3",
 128         "D4",
 129         "D5",
 130         "D6",
 131         "D7",
 132         "D8",
 133         "D9",
 134         "D10",
 135         "D11",
 136         "D12",
 137         "D13",
 138         "D14",
 139         "D15",
 140 };
 141
 142 static const char *coupling[] = {
 143         "AC",
 144         "DC",
 145         "GND",
 146 };
 147
 148 /* Do not change the order of entries */
 149 static const char *data_sources[] = {
 150         "Live",
 151         "Memory",
 152         "Segmented",
 153 };
 154
 155 /*
 156  * name, series, protocol flavor, min timebase, max timebase, min vdiv,
 157  * digital channels, number of horizontal divs
 158  */
 159
 160 #define RIGOL "Rigol Technologies"
 161 #define AGILENT "Agilent Technologies"
 162
 163 static const struct rigol_ds_model supported_models[] = {
 164         {RIGOL, "DS1052E", RIGOL_DS1000, PROTOCOL_LEGACY, {5, 1000000000}, {50, 1}, {2, 1000}, 2, false, 12},
 165         {RIGOL, "DS1102E", RIGOL_DS1000, PROTOCOL_LEGACY, {2, 1000000000}, {50, 1}, {2, 1000}, 2, false, 12},
 166         {RIGOL, "DS1152E", RIGOL_DS1000, PROTOCOL_LEGACY, {2, 1000000000}, {50, 1}, {2, 1000}, 2, false, 12},
 167         {RIGOL, "DS1052D", RIGOL_DS1000, PROTOCOL_LEGACY, {5, 1000000000}, {50, 1}, {2, 1000}, 2, true, 12},
 168         {RIGOL, "DS1102D", RIGOL_DS1000, PROTOCOL_LEGACY, {2, 1000000000}, {50, 1}, {2, 1000}, 2, true, 12},
 169         {RIGOL, "DS1152D", RIGOL_DS1000, PROTOCOL_LEGACY, {2, 1000000000}, {50, 1}, {2, 1000}, 2, true, 12},
 170         {RIGOL, "DS2072", RIGOL_DS2000, PROTOCOL_IEEE488_2, {5, 1000000000}, {500, 1}, {500, 1000000}, 2, false, 14},
 171         {RIGOL, "DS2102", RIGOL_DS2000, PROTOCOL_IEEE488_2, {5, 1000000000}, {500, 1}, {500, 1000000}, 2, false, 14},
 172         {RIGOL, "DS2202", RIGOL_DS2000, PROTOCOL_IEEE488_2, {2, 1000000000}, {500, 1}, {500, 1000000}, 2, false, 14},
 173         {RIGOL, "VS5022", RIGOL_VS5000, PROTOCOL_LEGACY, {20, 1000000000}, {50, 1}, {2, 1000}, 2, false, 14},
 174         {RIGOL, "VS5022D", RIGOL_VS5000, PROTOCOL_LEGACY, {20, 1000000000}, {50, 1}, {2, 1000}, 2, true, 14},
 175         {RIGOL, "VS5042", RIGOL_VS5000, PROTOCOL_LEGACY, {10, 1000000000}, {50, 1}, {2, 1000}, 2, false, 14},
 176         {RIGOL, "VS5042D", RIGOL_VS5000, PROTOCOL_LEGACY, {10, 1000000000}, {50, 1}, {2, 1000}, 2, true, 14},
 177         {RIGOL, "VS5062", RIGOL_VS5000, PROTOCOL_LEGACY, {5, 1000000000}, {50, 1}, {2, 1000}, 2, false, 14},
 178         {RIGOL, "VS5062D", RIGOL_VS5000, PROTOCOL_LEGACY, {5, 1000000000}, {50, 1}, {2, 1000}, 2, true, 14},
 179         {RIGOL, "VS5102", RIGOL_VS5000, PROTOCOL_LEGACY, {2, 1000000000}, {50, 1}, {2, 1000}, 2, false, 14},
 180         {RIGOL, "VS5102D", RIGOL_VS5000, PROTOCOL_LEGACY, {2, 1000000000}, {50, 1}, {2, 1000}, 2, true, 14},
 181         {RIGOL, "VS5202", RIGOL_VS5000, PROTOCOL_LEGACY, {2, 1000000000}, {50, 1}, {2, 1000}, 2, false, 14},
 182         {RIGOL, "VS5202D", RIGOL_VS5000, PROTOCOL_LEGACY, {2, 1000000000}, {50, 1}, {2, 1000}, 2, true, 14},
 183         {AGILENT, "DSO1014A", AGILENT_DSO1000, PROTOCOL_IEEE488_2, {2, 1000000000}, {50, 1}, {2, 1000}, 4, false, 12},
 184 };
 185
 186 SR_PRIV struct sr_dev_driver rigol_ds_driver_info;
 187 static struct sr_dev_driver *di = &rigol_ds_driver_info;
 188
 189 static void clear_helper(void *priv)
 190 {
 191         struct dev_context *devc;
 192
 193         devc = priv;
 194         g_free(devc->data);
 195         g_free(devc->buffer);
 196         g_free(devc->coupling[0]);
 197         g_free(devc->coupling[1]);
 198         g_free(devc->trigger_source);
 199         g_free(devc->trigger_slope);
 200         g_slist_free(devc->analog_groups[0].probes);
 201         g_slist_free(devc->analog_groups[1].probes);
 202         g_slist_free(devc->digital_group.probes);
 203 }
 204
 205 static int dev_clear(void)
 206 {
 207         return std_dev_clear(di, clear_helper);
 208 }
 209
 210 static int set_cfg(const struct sr_dev_inst *sdi, const char *format, ...)
 211 {
 212         va_list args;
 213         int ret;
 214
 215         va_start(args, format);
 216         ret = sr_scpi_send_variadic(sdi->conn, format, args);
 217         va_end(args);
 218
 219         if (ret != SR_OK)
 220                 return SR_ERR;
 221
 222         /* When setting a bunch of parameters in a row, the DS1052E scrambles
 223          * some of them unless there is at least 100ms delay in between. */
 224         sr_spew("delay %dms", 100);
 225         g_usleep(100000);
 226
 227         return SR_OK;
 228 }
 229
 230 static int init(struct sr_context *sr_ctx)
 231 {
 232         return std_init(sr_ctx, di, LOG_PREFIX);
 233 }
 234
 235 static int probe_port(const char *resource, const char *serialcomm, GSList **devices)
 236 {
 237         struct dev_context *devc;
 238         struct sr_dev_inst *sdi;
 239         const char *usbtmc_prefix = "/dev/usbtmc";
 240         const char *tcp_prefix = "tcp/";
 241         gchar **tokens, *address, *port;
 242         struct sr_scpi_dev_inst *scpi;
 243         struct sr_scpi_hw_info *hw_info;
 244         struct sr_probe *probe;
 245         unsigned int i;
 246         const struct rigol_ds_model *model = NULL;
 247         gchar *channel_name;
 248
 249         *devices = NULL;
 250
 251         if (strncmp(resource, usbtmc_prefix, strlen(usbtmc_prefix)) == 0) {
 252                 sr_dbg("Opening USBTMC device %s.", resource);
 253                 if (!(scpi = scpi_usbtmc_dev_inst_new(resource)))
 254                         return SR_ERR_MALLOC;
 255         } else if (strncmp(resource, tcp_prefix, strlen(tcp_prefix)) == 0) {
 256                 sr_dbg("Opening TCP connection %s.", resource);
 257                 tokens = g_strsplit(resource + strlen(tcp_prefix), "/", 0);
 258                 address = tokens[0];
 259                 port = tokens[1];
 260                 if (!address || !port || tokens[2]) {
 261                         sr_err("Invalid parameters.");
 262                         g_strfreev(tokens);
 263                         return SR_ERR_ARG;
 264                 }
 265                 scpi = scpi_tcp_dev_inst_new(address, port);
 266                 g_strfreev(tokens);
 267                 if (!scpi)
 268                         return SR_ERR_MALLOC;
 269         } else {
 270                 sr_dbg("Opening serial device %s.", resource);
 271                 if (!(scpi = scpi_serial_dev_inst_new(resource, serialcomm)))
 272                         return SR_ERR_MALLOC;
 273         }
 274
 275         if (sr_scpi_open(scpi) != SR_OK) {
 276                 sr_info("Couldn't open SCPI device.");
 277                 sr_scpi_free(scpi);
 278                 return SR_ERR;
 279         };
 280
 281         if (sr_scpi_get_hw_id(scpi, &hw_info) != SR_OK) {
 282                 sr_info("Couldn't get IDN response.");
 283                 sr_scpi_close(scpi);
 284                 sr_scpi_free(scpi);
 285                 return SR_ERR;
 286         }
 287
 288         for (i = 0; i < ARRAY_SIZE(supported_models); i++) {
 289                 if (!strcasecmp(hw_info->manufacturer, supported_models[i].vendor) &&
 290                                 !strcmp(hw_info->model, supported_models[i].name)) {
 291                         model = &supported_models[i];
 292                         break;
 293                 }
 294         }
 295
 296         if (!model || !(sdi = sr_dev_inst_new(0, SR_ST_ACTIVE,
 297                                               hw_info->manufacturer, hw_info->model,
 298                                                   hw_info->firmware_version))) {
 299                 sr_scpi_hw_info_free(hw_info);
 300                 sr_scpi_close(scpi);
 301                 sr_scpi_free(scpi);
 302                 return SR_ERR_NA;
 303         }
 304
 305         sr_scpi_hw_info_free(hw_info);
 306         sr_scpi_close(scpi);
 307
 308         sdi->conn = scpi;
 309
 310         sdi->driver = di;
 311         sdi->inst_type = SR_INST_SCPI;
 312
 313         if (!(devc = g_try_malloc0(sizeof(struct dev_context))))
 314                 return SR_ERR_MALLOC;
 315
 316         devc->limit_frames = 0;
 317         devc->model = model;
 318
 319         for (i = 0; i < model->analog_channels; i++) {
 320                 if (!(channel_name = g_strdup_printf("CH%d", i + 1)))
 321                         return SR_ERR_MALLOC;
 322                 probe = sr_probe_new(i, SR_PROBE_ANALOG, TRUE, channel_name);
 323                 sdi->probes = g_slist_append(sdi->probes, probe);
 324                 devc->analog_groups[i].name = channel_name;
 325                 devc->analog_groups[i].probes = g_slist_append(NULL, probe);
 326                 sdi->probe_groups = g_slist_append(sdi->probe_groups,
 327                                 &devc->analog_groups[i]);
 328         }
 329
 330         if (devc->model->has_digital) {
 331                 for (i = 0; i < 16; i++) {
 332                         if (!(channel_name = g_strdup_printf("D%d", i)))
 333                                 return SR_ERR_MALLOC;
 334                         probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE, channel_name);
 335                         g_free(channel_name);
 336                         if (!probe)
 337                                 return SR_ERR_MALLOC;
 338                         sdi->probes = g_slist_append(sdi->probes, probe);
 339                         devc->digital_group.probes = g_slist_append(
 340                                         devc->digital_group.probes, probe);
 341                 }
 342                 devc->digital_group.name = "LA";
 343                 sdi->probe_groups = g_slist_append(sdi->probe_groups,
 344                                 &devc->digital_group);
 345         }
 346
 347         for (i = 0; i < NUM_TIMEBASE; i++) {
 348                 if (!memcmp(&devc->model->min_timebase, &timebases[i], sizeof(uint64_t[2])))
 349                         devc->timebases = &timebases[i];
 350                 if (!memcmp(&devc->model->max_timebase, &timebases[i], sizeof(uint64_t[2])))
 351                         devc->num_timebases = &timebases[i] - devc->timebases + 1;
 352         }
 353
 354         for (i = 0; i < NUM_VDIV; i++) {
 355                 if (!memcmp(&devc->model->min_vdiv, &vdivs[i], sizeof(uint64_t[2]))) {
 356                         devc->vdivs = &vdivs[i];
 357                         devc->num_vdivs = NUM_VDIV - (&vdivs[i] - &vdivs[0]);
 358                 }
 359         }
 360
 361         if (!(devc->buffer = g_try_malloc(ACQ_BUFFER_SIZE)))
 362                 return SR_ERR_MALLOC;
 363         if (!(devc->data = g_try_malloc(ACQ_BUFFER_SIZE * sizeof(float))))
 364                 return SR_ERR_MALLOC;
 365
 366         devc->data_source = DATA_SOURCE_LIVE;
 367
 368         sdi->priv = devc;
 369
 370         *devices = g_slist_append(NULL, sdi);
 371
 372         return SR_OK;
 373 }
 374
 375 static GSList *scan(GSList *options)
 376 {
 377         struct drv_context *drvc;
 378         struct sr_config *src;
 379         GSList *l, *devices;
 380         GDir *dir;
 381         int ret;
 382         const gchar *dev_name;
 383         gchar *port = NULL;
 384         gchar *serialcomm = NULL;
 385
 386         drvc = di->priv;
 387
 388         for (l = options; l; l = l->next) {
 389                 src = l->data;
 390                 switch (src->key) {
 391                 case SR_CONF_CONN:
 392                         port = (char *)g_variant_get_string(src->data, NULL);
 393                         break;
 394                 case SR_CONF_SERIALCOMM:
 395                         serialcomm = (char *)g_variant_get_string(src->data, NULL);
 396                         break;
 397                 }
 398         }
 399
 400         devices = NULL;
 401         if (port) {
 402                 if (probe_port(port, serialcomm, &devices) == SR_ERR_MALLOC) {
 403                         g_free(port);
 404                         if (serialcomm)
 405                                 g_free(serialcomm);
 406                         return NULL;
 407                 }
 408         } else {
 409                 if (!(dir = g_dir_open("/sys/class/usbmisc/", 0, NULL)))
 410                         if (!(dir = g_dir_open("/sys/class/usb/", 0, NULL)))
 411                                 return NULL;
 412                 while ((dev_name = g_dir_read_name(dir))) {
 413                         if (strncmp(dev_name, "usbtmc", 6))
 414                                 continue;
 415                         port = g_strconcat("/dev/", dev_name, NULL);
 416                         ret = probe_port(port, serialcomm, &devices);
 417                         g_free(port);
 418                         if (serialcomm)
 419                                 g_free(serialcomm);
 420                         if (ret == SR_ERR_MALLOC) {
 421                                 g_dir_close(dir);
 422                                 return NULL;
 423                         }
 424                 }
 425                 g_dir_close(dir);
 426         }
 427
 428         /* Tack a copy of the newly found devices onto the driver list. */
 429         l = g_slist_copy(devices);
 430         drvc->instances = g_slist_concat(drvc->instances, l);
 431
 432         return devices;
 433 }
 434
 435 static GSList *dev_list(void)
 436 {
 437         return ((struct drv_context *)(di->priv))->instances;
 438 }
 439
 440 static int dev_open(struct sr_dev_inst *sdi)
 441 {
 442         struct sr_scpi_dev_inst *scpi = sdi->conn;
 443
 444         if (sr_scpi_open(scpi) < 0)
 445                 return SR_ERR;
 446
 447         if (rigol_ds_get_dev_cfg(sdi) != SR_OK)
 448                 return SR_ERR;
 449
 450         sdi->status = SR_ST_ACTIVE;
 451
 452         return SR_OK;
 453 }
 454
 455 static int dev_close(struct sr_dev_inst *sdi)
 456 {
 457         struct sr_scpi_dev_inst *scpi;
 458
 459         scpi = sdi->conn;
 460
 461         if (scpi) {
 462                 if (sr_scpi_close(scpi) < 0)
 463                         return SR_ERR;
 464                 sdi->status = SR_ST_INACTIVE;
 465         }
 466
 467         return SR_OK;
 468 }
 469
 470 static int cleanup(void)
 471 {
 472         return dev_clear();
 473 }
 474
 475 static int config_get(int id, GVariant **data, const struct sr_dev_inst *sdi,
 476                 const struct sr_probe_group *probe_group)
 477 {
 478         struct dev_context *devc;
 479         unsigned int i;
 480
 481         if (!sdi || !(devc = sdi->priv))
 482                 return SR_ERR_ARG;
 483
 484         /* If a probe group is specified, it must be a valid one. */
 485         if (probe_group) {
 486                 if (probe_group != &devc->analog_groups[0]
 487                                 && probe_group != &devc->analog_groups[1]) {
 488                         sr_err("Invalid probe group specified.");
 489                         return SR_ERR;
 490                 }
 491         }
 492
 493         switch (id) {
 494         case SR_CONF_NUM_TIMEBASE:
 495                 *data = g_variant_new_int32(devc->num_timebases);
 496                 break;
 497         case SR_CONF_NUM_VDIV:
 498                 if (!probe_group) {
 499                         sr_err("No probe group specified.");
 500                         return SR_ERR_PROBE_GROUP;
 501                 }
 502                 for (i = 0; i < 2; i++) {
 503                         if (probe_group == &devc->analog_groups[i]) {
 504                                 *data = g_variant_new_int32(devc->num_vdivs);
 505                                 return SR_OK;
 506                         }
 507                 }
 508                 return SR_ERR_NA;
 509         case SR_CONF_DATA_SOURCE:
 510                 if (devc->data_source == DATA_SOURCE_LIVE)
 511                         *data = g_variant_new_string("Live");
 512                 else if (devc->data_source == DATA_SOURCE_MEMORY)
 513                         *data = g_variant_new_string("Memory");
 514                 else
 515                         *data = g_variant_new_string("Segmented");
 516                 break;
 517         default:
 518                 return SR_ERR_NA;
 519         }
 520
 521         return SR_OK;
 522 }
 523
 524 static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi,
 525                 const struct sr_probe_group *probe_group)
 526 {
 527         struct dev_context *devc;
 528         uint64_t tmp_u64, p, q;
 529         double t_dbl;
 530         unsigned int i, j;
 531         int ret;
 532         const char *tmp_str;
 533
 534         if (!(devc = sdi->priv))
 535                 return SR_ERR_ARG;
 536
 537         if (sdi->status != SR_ST_ACTIVE)
 538                 return SR_ERR_DEV_CLOSED;
 539
 540         /* If a probe group is specified, it must be a valid one. */
 541         if (probe_group) {
 542                 if (probe_group != &devc->analog_groups[0]
 543                                 && probe_group != &devc->analog_groups[1]) {
 544                         sr_err("Invalid probe group specified.");
 545                         return SR_ERR;
 546                 }
 547         }
 548
 549         ret = SR_OK;
 550         switch (id) {
 551         case SR_CONF_LIMIT_FRAMES:
 552                 devc->limit_frames = g_variant_get_uint64(data);
 553                 break;
 554         case SR_CONF_TRIGGER_SLOPE:
 555                 tmp_u64 = g_variant_get_uint64(data);
 556                 if (tmp_u64 != 0 && tmp_u64 != 1)
 557                         return SR_ERR;
 558                 g_free(devc->trigger_slope);
 559                 devc->trigger_slope = g_strdup(tmp_u64 ? "POS" : "NEG");
 560                 ret = set_cfg(sdi, ":TRIG:EDGE:SLOP %s", devc->trigger_slope);
 561                 break;
 562         case SR_CONF_HORIZ_TRIGGERPOS:
 563                 t_dbl = g_variant_get_double(data);
 564                 if (t_dbl < 0.0 || t_dbl > 1.0)
 565                         return SR_ERR;
 566                 devc->horiz_triggerpos = t_dbl;
 567                 /* We have the trigger offset as a percentage of the frame, but
 568                  * need to express this in seconds. */
 569                 t_dbl = -(devc->horiz_triggerpos - 0.5) * devc->timebase * devc->num_timebases;
 570                 ret = set_cfg(sdi, ":TIM:OFFS %.6f", t_dbl);
 571                 break;
 572         case SR_CONF_TIMEBASE:
 573                 g_variant_get(data, "(tt)", &p, &q);
 574                 for (i = 0; i < devc->num_timebases; i++) {
 575                         if (devc->timebases[i][0] == p && devc->timebases[i][1] == q) {
 576                                 devc->timebase = (float)p / q;
 577                                 ret = set_cfg(sdi, ":TIM:SCAL %.9f", devc->timebase);
 578                                 break;
 579                         }
 580                 }
 581                 if (i == devc->num_timebases)
 582                         ret = SR_ERR_ARG;
 583                 break;
 584         case SR_CONF_TRIGGER_SOURCE:
 585                 tmp_str = g_variant_get_string(data, NULL);
 586                 for (i = 0; i < ARRAY_SIZE(trigger_sources); i++) {
 587                         if (!strcmp(trigger_sources[i], tmp_str)) {
 588                                 g_free(devc->trigger_source);
 589                                 devc->trigger_source = g_strdup(trigger_sources[i]);
 590                                 if (!strcmp(devc->trigger_source, "AC Line"))
 591                                         tmp_str = "ACL";
 592                                 else if (!strcmp(devc->trigger_source, "CH1"))
 593                                         tmp_str = "CHAN1";
 594                                 else if (!strcmp(devc->trigger_source, "CH2"))
 595                                         tmp_str = "CHAN2";
 596                                 else if (!strcmp(devc->trigger_source, "CH3"))
 597                                         tmp_str = "CHAN3";
 598                                 else if (!strcmp(devc->trigger_source, "CH4"))
 599                                         tmp_str = "CHAN4";
 600                                 else
 601                                         tmp_str = (char *)devc->trigger_source;
 602                                 ret = set_cfg(sdi, ":TRIG:EDGE:SOUR %s", tmp_str);
 603                                 break;
 604                         }
 605                 }
 606                 if (i == ARRAY_SIZE(trigger_sources))
 607                         ret = SR_ERR_ARG;
 608                 break;
 609         case SR_CONF_VDIV:
 610                 if (!probe_group) {
 611                         sr_err("No probe group specified.");
 612                         return SR_ERR_PROBE_GROUP;
 613                 }
 614                 g_variant_get(data, "(tt)", &p, &q);
 615                 for (i = 0; i < 2; i++) {
 616                         if (probe_group == &devc->analog_groups[i]) {
 617                                 for (j = 0; j < ARRAY_SIZE(vdivs); j++) {
 618                                         if (vdivs[j][0] != p || vdivs[j][1] != q)
 619                                                 continue;
 620                                         devc->vdiv[i] = (float)p / q;
 621                                         return set_cfg(sdi, ":CHAN%d:SCAL %.3f", i + 1,
 622                                                         devc->vdiv[i]);
 623                                 }
 624                                 return SR_ERR_ARG;
 625                         }
 626                 }
 627                 return SR_ERR_NA;
 628         case SR_CONF_COUPLING:
 629                 if (!probe_group) {
 630                         sr_err("No probe group specified.");
 631                         return SR_ERR_PROBE_GROUP;
 632                 }
 633                 tmp_str = g_variant_get_string(data, NULL);
 634                 for (i = 0; i < 2; i++) {
 635                         if (probe_group == &devc->analog_groups[i]) {
 636                                 for (j = 0; j < ARRAY_SIZE(coupling); j++) {
 637                                         if (!strcmp(tmp_str, coupling[j])) {
 638                                                 g_free(devc->coupling[i]);
 639                                                 devc->coupling[i] = g_strdup(coupling[j]);
 640                                                 return set_cfg(sdi, ":CHAN%d:COUP %s", i + 1,
 641                                                                 devc->coupling[i]);
 642                                         }
 643                                 }
 644                                 return SR_ERR_ARG;
 645                         }
 646                 }
 647                 return SR_ERR_NA;
 648         case SR_CONF_DATA_SOURCE:
 649                 tmp_str = g_variant_get_string(data, NULL);
 650                 if (!strcmp(tmp_str, "Live"))
 651                         devc->data_source = DATA_SOURCE_LIVE;
 652                 else if (!strcmp(tmp_str, "Memory"))
 653                         devc->data_source = DATA_SOURCE_MEMORY;
 654                 else if (devc->model->protocol == PROTOCOL_IEEE488_2
 655                          && !strcmp(tmp_str, "Segmented"))
 656                         devc->data_source = DATA_SOURCE_SEGMENTED;
 657                 else
 658                         return SR_ERR;
 659                 break;
 660         default:
 661                 ret = SR_ERR_NA;
 662                 break;
 663         }
 664
 665         return ret;
 666 }
 667
 668 static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi,
 669                 const struct sr_probe_group *probe_group)
 670 {
 671         GVariant *tuple, *rational[2];
 672         GVariantBuilder gvb;
 673         unsigned int i;
 674         struct dev_context *devc = NULL;
 675
 676         if (sdi)
 677                 devc = sdi->priv;
 678
 679         if (key == SR_CONF_SCAN_OPTIONS) {
 680                 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
 681                                 hwopts, ARRAY_SIZE(hwopts), sizeof(int32_t));
 682                 return SR_OK;
 683         } else if (key == SR_CONF_DEVICE_OPTIONS && probe_group == NULL) {
 684                 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
 685                         hwcaps, ARRAY_SIZE(hwcaps), sizeof(int32_t));
 686                 return SR_OK;
 687         }
 688
 689         /* Every other option requires a valid device instance. */
 690         if (!sdi || !(devc = sdi->priv))
 691                 return SR_ERR_ARG;
 692
 693         /* If a probe group is specified, it must be a valid one. */
 694         if (probe_group) {
 695                 if (probe_group != &devc->analog_groups[0]
 696                                 && probe_group != &devc->analog_groups[1]) {
 697                         sr_err("Invalid probe group specified.");
 698                         return SR_ERR;
 699                 }
 700         }
 701
 702         switch (key) {
 703                 break;
 704         case SR_CONF_DEVICE_OPTIONS:
 705                 if (!probe_group) {
 706                         sr_err("No probe group specified.");
 707                         return SR_ERR_PROBE_GROUP;
 708                 }
 709                 if (probe_group == &devc->digital_group) {
 710                         *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
 711                                 NULL, 0, sizeof(int32_t));
 712                         return SR_OK;
 713                 } else {
 714                         for (i = 0; i < 2; i++) {
 715                                 if (probe_group == &devc->analog_groups[i]) {
 716                                         *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
 717                                                 analog_hwcaps, ARRAY_SIZE(analog_hwcaps), sizeof(int32_t));
 718                                         return SR_OK;
 719                                 }
 720                         }
 721                         return SR_ERR_NA;
 722                 }
 723                 break;
 724         case SR_CONF_COUPLING:
 725                 if (!probe_group) {
 726                         sr_err("No probe group specified.");
 727                         return SR_ERR_PROBE_GROUP;
 728                 }
 729                 *data = g_variant_new_strv(coupling, ARRAY_SIZE(coupling));
 730                 break;
 731         case SR_CONF_VDIV:
 732                 if (!devc)
 733                         /* Can't know this until we have the exact model. */
 734                         return SR_ERR_ARG;
 735                 if (!probe_group) {
 736                         sr_err("No probe group specified.");
 737                         return SR_ERR_PROBE_GROUP;
 738                 }
 739                 g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
 740                 for (i = 0; i < devc->num_vdivs; i++) {
 741                         rational[0] = g_variant_new_uint64(devc->vdivs[i][0]);
 742                         rational[1] = g_variant_new_uint64(devc->vdivs[i][1]);
 743                         tuple = g_variant_new_tuple(rational, 2);
 744                         g_variant_builder_add_value(&gvb, tuple);
 745                 }
 746                 *data = g_variant_builder_end(&gvb);
 747                 break;
 748         case SR_CONF_TIMEBASE:
 749                 if (!devc)
 750                         /* Can't know this until we have the exact model. */
 751                         return SR_ERR_ARG;
 752                 g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
 753                 for (i = 0; i < devc->num_timebases; i++) {
 754                         rational[0] = g_variant_new_uint64(devc->timebases[i][0]);
 755                         rational[1] = g_variant_new_uint64(devc->timebases[i][1]);
 756                         tuple = g_variant_new_tuple(rational, 2);
 757                         g_variant_builder_add_value(&gvb, tuple);
 758                 }
 759                 *data = g_variant_builder_end(&gvb);
 760                 break;
 761         case SR_CONF_TRIGGER_SOURCE:
 762                 if (!devc)
 763                         /* Can't know this until we have the exact model. */
 764                         return SR_ERR_ARG;
 765                 *data = g_variant_new_strv(trigger_sources,
 766                                 devc->model->has_digital ? ARRAY_SIZE(trigger_sources) : 4);
 767                 break;
 768         case SR_CONF_DATA_SOURCE:
 769                 if (!devc)
 770                         /* Can't know this until we have the exact model. */
 771                         return SR_ERR_ARG;
 772                 /* This needs tweaking by series/model! */
 773                 if (devc->model->series == RIGOL_DS2000)
 774                         *data = g_variant_new_strv(data_sources, ARRAY_SIZE(data_sources));
 775                 else
 776                         *data = g_variant_new_strv(data_sources, ARRAY_SIZE(data_sources) - 1);
 777                 break;
 778         default:
 779                 return SR_ERR_NA;
 780         }
 781
 782         return SR_OK;
 783 }
 784
 785 static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
 786 {
 787         struct sr_scpi_dev_inst *scpi;
 788         struct dev_context *devc;
 789         struct sr_probe *probe;
 790         GSList *l;
 791
 792         if (sdi->status != SR_ST_ACTIVE)
 793                 return SR_ERR_DEV_CLOSED;
 794
 795         scpi = sdi->conn;
 796         devc = sdi->priv;
 797
 798         for (l = sdi->probes; l; l = l->next) {
 799                 probe = l->data;
 800                 sr_dbg("handling probe %s", probe->name);
 801                 if (probe->type == SR_PROBE_ANALOG) {
 802                         if (probe->enabled)
 803                                 devc->enabled_analog_probes = g_slist_append(
 804                                                 devc->enabled_analog_probes, probe);
 805                         if (probe->enabled != devc->analog_channels[probe->index]) {
 806                                 /* Enabled channel is currently disabled, or vice versa. */
 807                                 if (set_cfg(sdi, ":CHAN%d:DISP %s", probe->index + 1,
 808                                                 probe->enabled ? "ON" : "OFF") != SR_OK)
 809                                         return SR_ERR;
 810                         }
 811                 } else if (probe->type == SR_PROBE_LOGIC) {
 812                         if (probe->enabled)
 813                                 devc->enabled_digital_probes = g_slist_append(
 814                                                 devc->enabled_digital_probes, probe);
 815                         if (probe->enabled != devc->digital_channels[probe->index]) {
 816                                 /* Enabled channel is currently disabled, or vice versa. */
 817                                 if (set_cfg(sdi, ":DIG%d:TURN %s", probe->index,
 818                                                 probe->enabled ? "ON" : "OFF") != SR_OK)
 819                                         return SR_ERR;
 820                         }
 821                 }
 822         }
 823
 824         if (!devc->enabled_analog_probes && !devc->enabled_digital_probes)
 825                 return SR_ERR;
 826
 827         if (devc->data_source == DATA_SOURCE_LIVE) {
 828                 if (set_cfg(sdi, ":RUN") != SR_OK)
 829                         return SR_ERR;
 830         } else if (devc->data_source == DATA_SOURCE_MEMORY) {
 831                 if (devc->model->series != RIGOL_DS2000) {
 832                         sr_err("Data source 'Memory' not supported for this device");
 833                         return SR_ERR;
 834                 }
 835         } else if (devc->data_source == DATA_SOURCE_SEGMENTED) {
 836                 sr_err("Data source 'Segmented' not yet supported");
 837                 return SR_ERR;
 838         }
 839
 840         sr_scpi_source_add(scpi, G_IO_IN, 50, rigol_ds_receive, (void *)sdi);
 841
 842         /* Send header packet to the session bus. */
 843         std_session_send_df_header(cb_data, LOG_PREFIX);
 844
 845         if (devc->enabled_analog_probes)
 846                 devc->channel_entry = devc->enabled_analog_probes;
 847         else
 848                 devc->channel_entry = devc->enabled_digital_probes;
 849
 850         if (devc->model->protocol == PROTOCOL_LEGACY) {
 851                 devc->analog_frame_size = (devc->model->series == RIGOL_VS5000 ?
 852                                 VS5000_ANALOG_LIVE_WAVEFORM_SIZE :
 853                                 DS1000_ANALOG_LIVE_WAVEFORM_SIZE);
 854                 /* Fetch the first frame. */
 855                 if (rigol_ds_channel_start(sdi) != SR_OK)
 856                         return SR_ERR;
 857         } else {
 858                 if (devc->enabled_analog_probes) {
 859                         if (devc->data_source == DATA_SOURCE_MEMORY)
 860                         {
 861                                 if (g_slist_length(devc->enabled_analog_probes) == 1)
 862                                         devc->analog_frame_size = DS2000_ANALOG_MEM_WAVEFORM_SIZE_1C;
 863                                 else
 864                                         devc->analog_frame_size = DS2000_ANALOG_MEM_WAVEFORM_SIZE_2C;
 865                                 /* Apparently for the DS2000 the memory
 866                                  * depth can only be set in Running state -
 867                                  * this matches the behaviour of the UI. */
 868                                 if (set_cfg(sdi, ":RUN") != SR_OK)
 869                                         return SR_ERR;
 870                                 if (set_cfg(sdi, "ACQ:MDEP %d", devc->analog_frame_size) != SR_OK)
 871                                         return SR_ERR;
 872                                 if (set_cfg(sdi, ":STOP") != SR_OK)
 873                                         return SR_ERR;
 874                         } else {
 875                                 if (devc->model->series == AGILENT_DSO1000)
 876                                         devc->analog_frame_size = DSO1000_ANALOG_LIVE_WAVEFORM_SIZE;
 877                                 else
 878                                         devc->analog_frame_size = DS2000_ANALOG_LIVE_WAVEFORM_SIZE;
 879                         }
 880                         if (rigol_ds_capture_start(sdi) != SR_OK)
 881                                 return SR_ERR;
 882                 }
 883         }
 884
 885         return SR_OK;
 886 }
 887
 888 static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
 889 {
 890         struct dev_context *devc;
 891         struct sr_scpi_dev_inst *scpi;
 892
 893         (void)cb_data;
 894
 895         devc = sdi->priv;
 896
 897         if (sdi->status != SR_ST_ACTIVE) {
 898                 sr_err("Device inactive, can't stop acquisition.");
 899                 return SR_ERR;
 900         }
 901
 902         g_slist_free(devc->enabled_analog_probes);
 903         g_slist_free(devc->enabled_digital_probes);
 904         devc->enabled_analog_probes = NULL;
 905         devc->enabled_digital_probes = NULL;
 906         scpi = sdi->conn;
 907         sr_scpi_source_remove(scpi);
 908
 909         return SR_OK;
 910 }
 911
 912 SR_PRIV struct sr_dev_driver rigol_ds_driver_info = {
 913         .name = "rigol-ds",
 914         .longname = "Rigol DS",
 915         .api_version = 1,
 916         .init = init,
 917         .cleanup = cleanup,
 918         .scan = scan,
 919         .dev_list = dev_list,
 920         .dev_clear = dev_clear,
 921         .config_get = config_get,
 922         .config_set = config_set,
 923         .config_list = config_list,
 924         .dev_open = dev_open,
 925         .dev_close = dev_close,
 926         .dev_acquisition_start = dev_acquisition_start,
 927         .dev_acquisition_stop = dev_acquisition_stop,
 928         .priv = NULL,
 929 };