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