hardware/rigol-ds1xx2/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  *
   7  * This program is free software: you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation, either version 3 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #include <fcntl.h>
  22 #include <unistd.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <glib.h>
  26 #include "libsigrok.h"
  27 #include "libsigrok-internal.h"
  28 #include "protocol.h"
  29
  30 #define NUM_TIMEBASE  12
  31 #define NUM_VDIV      8
  32
  33 static const int32_t hwopts[] = {
  34         SR_CONF_CONN,
  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 };
  45
  46 static const int32_t analog_hwcaps[] = {
  47         SR_CONF_NUM_VDIV,
  48         SR_CONF_VDIV,
  49         SR_CONF_COUPLING
  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 };
  89
  90 static const uint64_t vdivs[][2] = {
  91         /* millivolts */
  92         { 2, 1000 },
  93         { 5, 1000 },
  94         { 10, 1000 },
  95         { 20, 1000 },
  96         { 50, 1000 },
  97         { 100, 1000 },
  98         { 200, 1000 },
  99         { 500, 1000 },
 100         /* volts */
 101         { 1, 1 },
 102         { 2, 1 },
 103         { 5, 1 },
 104         { 10, 1 },
 105 };
 106
 107 static const char *trigger_sources[] = {
 108         "CH1",
 109         "CH2",
 110         "EXT",
 111         "AC Line",
 112         "D0",
 113         "D1",
 114         "D2",
 115         "D3",
 116         "D4",
 117         "D5",
 118         "D6",
 119         "D7",
 120         "D8",
 121         "D9",
 122         "D10",
 123         "D11",
 124         "D12",
 125         "D13",
 126         "D14",
 127         "D15",
 128 };
 129
 130 static const char *coupling[] = {
 131         "AC",
 132         "DC",
 133         "GND",
 134 };
 135
 136 static const char *supported_models[] = {
 137         "DS1052E",
 138         "DS1102E",
 139         "DS1152E",
 140         "DS1052D",
 141         "DS1102D",
 142         "DS1152D",
 143 };
 144
 145 SR_PRIV struct sr_dev_driver rigol_ds1xx2_driver_info;
 146 static struct sr_dev_driver *di = &rigol_ds1xx2_driver_info;
 147
 148 static void clear_helper(void *priv)
 149 {
 150         struct dev_context *devc;
 151
 152         for (l = drvc->instances; l; l = l->next) {
 153                 if (!(sdi = l->data))
 154                         continue;
 155
 156                 if (sdi->conn)
 157                         sr_serial_dev_inst_free(sdi->conn);
 158
 159                 g_slist_free(sdi->probe_groups);
 160
 161                 if (!(devc = sdi->priv))
 162                         continue;
 163
 164                 g_free(devc->coupling[0]);
 165                 g_free(devc->coupling[1]);
 166                 g_free(devc->trigger_source);
 167                 g_free(devc->trigger_slope);
 168                 g_slist_free(devc->analog_groups[0].probes);
 169                 g_slist_free(devc->analog_groups[1].probes);
 170                 g_slist_free(devc->digital_group.probes);
 171
 172                 sr_dev_inst_free(sdi);
 173         }
 174
 175         g_free(devc->coupling[0]);
 176         g_free(devc->coupling[1]);
 177         g_free(devc->trigger_source);
 178         g_free(devc->trigger_slope);
 179 }
 180
 181 static int dev_clear(void)
 182 {
 183         return std_dev_clear(di, clear_helper);
 184 }
 185
 186 static int set_cfg(const struct sr_dev_inst *sdi, const char *format, ...)
 187 {
 188         va_list args;
 189         char buf[256];
 190
 191         va_start(args, format);
 192         vsnprintf(buf, 255, format, args);
 193         va_end(args);
 194         if (rigol_ds1xx2_send(sdi, buf) != SR_OK)
 195                 return SR_ERR;
 196
 197         /* When setting a bunch of parameters in a row, the DS1052E scrambles
 198          * some of them unless there is at least 100ms delay in between. */
 199         sr_spew("delay %dms", 100);
 200         g_usleep(100000);
 201
 202         return SR_OK;
 203 }
 204
 205 static int init(struct sr_context *sr_ctx)
 206 {
 207         return std_init(sr_ctx, di, LOG_PREFIX);
 208 }
 209
 210 static int probe_port(const char *port, GSList **devices)
 211 {
 212         struct dev_context *devc;
 213         struct sr_dev_inst *sdi;
 214         struct sr_serial_dev_inst *serial;
 215         struct sr_probe *probe;
 216         unsigned int i;
 217         int len, num_tokens;
 218         gboolean matched, has_digital;
 219         const char *manufacturer, *model, *version;
 220         char buf[256];
 221         gchar **tokens, *channel_name;
 222
 223         *devices = NULL;
 224         if (!(serial = sr_serial_dev_inst_new(port, NULL)))
 225                 return SR_ERR_MALLOC;
 226
 227         if (serial_open(serial, SERIAL_RDWR) != SR_OK)
 228                 return SR_ERR;
 229         len = serial_write(serial, "*IDN?", 5);
 230         len = serial_read(serial, buf, sizeof(buf));
 231         if (serial_close(serial) != SR_OK)
 232                 return SR_ERR;
 233
 234         sr_serial_dev_inst_free(serial);
 235
 236         if (len == 0)
 237                 return SR_ERR_NA;
 238
 239         buf[len] = 0;
 240         tokens = g_strsplit(buf, ",", 0);
 241         sr_dbg("response: %s [%s]", port, buf);
 242
 243         for (num_tokens = 0; tokens[num_tokens] != NULL; num_tokens++);
 244
 245         if (num_tokens < 4) {
 246                 g_strfreev(tokens);
 247                 return SR_ERR_NA;
 248         }
 249
 250         manufacturer = tokens[0];
 251         model = tokens[1];
 252         version = tokens[3];
 253
 254         if (strcmp(manufacturer, "Rigol Technologies")) {
 255                 g_strfreev(tokens);
 256                 return SR_ERR_NA;
 257         }
 258
 259         matched = has_digital = FALSE;
 260         for (i = 0; i < ARRAY_SIZE(supported_models); i++) {
 261                 if (!strcmp(model, supported_models[i])) {
 262                         matched = TRUE;
 263                         has_digital = g_str_has_suffix(model, "D");
 264                         break;
 265                 }
 266         }
 267
 268         if (!matched || !(sdi = sr_dev_inst_new(0, SR_ST_ACTIVE,
 269                 manufacturer, model, version))) {
 270                 g_strfreev(tokens);
 271                 return SR_ERR_NA;
 272         }
 273
 274         g_strfreev(tokens);
 275
 276         if (!(sdi->conn = sr_serial_dev_inst_new(port, NULL)))
 277                 return SR_ERR_MALLOC;
 278         sdi->driver = di;
 279         sdi->inst_type = SR_INST_SERIAL;
 280
 281         if (!(devc = g_try_malloc0(sizeof(struct dev_context))))
 282                 return SR_ERR_MALLOC;
 283         devc->limit_frames = 0;
 284         devc->has_digital = has_digital;
 285
 286         for (i = 0; i < 2; i++) {
 287                 channel_name = (i == 0 ? "CH1" : "CH2");
 288                 if (!(probe = sr_probe_new(i, SR_PROBE_ANALOG, TRUE, channel_name)))
 289                         return SR_ERR_MALLOC;
 290                 sdi->probes = g_slist_append(sdi->probes, probe);
 291                 devc->analog_groups[i].name = channel_name;
 292                 devc->analog_groups[i].probes = g_slist_append(NULL, probe);
 293                 sdi->probe_groups = g_slist_append(sdi->probe_groups,
 294                                 &devc->analog_groups[i]);
 295         }
 296
 297         if (devc->has_digital) {
 298                 for (i = 0; i < 16; i++) {
 299                         if (!(channel_name = g_strdup_printf("D%d", i)))
 300                                 return SR_ERR_MALLOC;
 301                         probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE, channel_name);
 302                         g_free(channel_name);
 303                         if (!probe)
 304                                 return SR_ERR_MALLOC;
 305                         sdi->probes = g_slist_append(sdi->probes, probe);
 306                         devc->digital_group.probes = g_slist_append(
 307                                         devc->digital_group.probes, probe);
 308                         devc->digital_group.name = "LA";
 309                         sdi->probe_groups = g_slist_append(sdi->probe_groups,
 310                                         &devc->digital_group);
 311                 }
 312         }
 313         sdi->priv = devc;
 314
 315         *devices = g_slist_append(NULL, sdi);
 316
 317         return SR_OK;
 318 }
 319
 320 static GSList *scan(GSList *options)
 321 {
 322         struct drv_context *drvc;
 323         struct sr_config *src;
 324         GSList *l, *devices;
 325         GDir *dir;
 326         int ret;
 327         const gchar *dev_name;
 328         gchar *port = NULL;
 329
 330         drvc = di->priv;
 331
 332         for (l = options; l; l = l->next) {
 333                 src = l->data;
 334                 if (src->key == SR_CONF_CONN) {
 335                         port = (char *)g_variant_get_string(src->data, NULL);
 336                         break;
 337                 }
 338         }
 339
 340         devices = NULL;
 341         if (port) {
 342                 if (probe_port(port, &devices) == SR_ERR_MALLOC)
 343                         return NULL;
 344         } else {
 345                 if (!(dir = g_dir_open("/sys/class/usbmisc/", 0, NULL)))
 346                         if (!(dir = g_dir_open("/sys/class/usb/", 0, NULL)))
 347                                 return NULL;
 348                 while ((dev_name = g_dir_read_name(dir))) {
 349                         if (strncmp(dev_name, "usbtmc", 6))
 350                                 continue;
 351                         port = g_strconcat("/dev/", dev_name, NULL);
 352                         ret = probe_port(port, &devices);
 353                         g_free(port);
 354                         if (ret == SR_ERR_MALLOC) {
 355                                 g_dir_close(dir);
 356                                 return NULL;
 357                         }
 358                 }
 359                 g_dir_close(dir);
 360         }
 361
 362         /* Tack a copy of the newly found devices onto the driver list. */
 363         l = g_slist_copy(devices);
 364         drvc->instances = g_slist_concat(drvc->instances, l);
 365
 366         return devices;
 367 }
 368
 369 static GSList *dev_list(void)
 370 {
 371         return ((struct drv_context *)(di->priv))->instances;
 372 }
 373
 374 static int dev_open(struct sr_dev_inst *sdi)
 375 {
 376
 377         if (serial_open(sdi->conn, SERIAL_RDWR) != SR_OK)
 378                 return SR_ERR;
 379
 380         if (rigol_ds1xx2_get_dev_cfg(sdi) != SR_OK)
 381                 return SR_ERR;
 382
 383         sdi->status = SR_ST_ACTIVE;
 384
 385         return SR_OK;
 386 }
 387
 388 static int dev_close(struct sr_dev_inst *sdi)
 389 {
 390         struct sr_serial_dev_inst *serial;
 391
 392         serial = sdi->conn;
 393         if (serial && serial->fd != -1) {
 394                 serial_close(serial);
 395                 sdi->status = SR_ST_INACTIVE;
 396         }
 397
 398         return SR_OK;
 399 }
 400
 401 static int cleanup(void)
 402 {
 403         return dev_clear();
 404 }
 405
 406 static int config_get(int id, GVariant **data, const struct sr_dev_inst *sdi,
 407                 const struct sr_probe_group *probe_group)
 408 {
 409         struct dev_context *devc = sdi->priv;
 410         unsigned int i;
 411
 412         switch (id) {
 413         case SR_CONF_NUM_TIMEBASE:
 414                 *data = g_variant_new_int32(NUM_TIMEBASE);
 415                 break;
 416         case SR_CONF_NUM_VDIV:
 417                 for (i = 0; i < 2; i++) {
 418                         if (probe_group == &devc->analog_groups[i])
 419                         {
 420                                 *data = g_variant_new_int32(NUM_VDIV);
 421                                 return SR_OK;
 422                         }
 423                 }
 424                 return SR_ERR_NA;
 425         default:
 426                 return SR_ERR_NA;
 427         }
 428
 429         return SR_OK;
 430 }
 431
 432 static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi,
 433                 const struct sr_probe_group *probe_group)
 434 {
 435         struct dev_context *devc;
 436         uint64_t tmp_u64, p, q;
 437         double t_dbl;
 438         unsigned int i, j;
 439         int ret;
 440         const char *tmp_str;
 441
 442         devc = sdi->priv;
 443
 444         if (sdi->status != SR_ST_ACTIVE)
 445                 return SR_ERR_DEV_CLOSED;
 446
 447         ret = SR_OK;
 448         switch (id) {
 449         case SR_CONF_LIMIT_FRAMES:
 450                 devc->limit_frames = g_variant_get_uint64(data);
 451                 break;
 452         case SR_CONF_TRIGGER_SLOPE:
 453                 tmp_u64 = g_variant_get_uint64(data);
 454                 if (tmp_u64 != 0 && tmp_u64 != 1)
 455                         return SR_ERR;
 456                 g_free(devc->trigger_slope);
 457                 devc->trigger_slope = g_strdup(tmp_u64 ? "POS" : "NEG");
 458                 ret = set_cfg(sdi, ":TRIG:EDGE:SLOP %s", devc->trigger_slope);
 459                 break;
 460         case SR_CONF_HORIZ_TRIGGERPOS:
 461                 t_dbl = g_variant_get_double(data);
 462                 if (t_dbl < 0.0 || t_dbl > 1.0)
 463                         return SR_ERR;
 464                 devc->horiz_triggerpos = t_dbl;
 465                 /* We have the trigger offset as a percentage of the frame, but
 466                  * need to express this in seconds. */
 467                 t_dbl = -(devc->horiz_triggerpos - 0.5) * devc->timebase * NUM_TIMEBASE;
 468                 ret = set_cfg(sdi, ":TIM:OFFS %.6f", t_dbl);
 469                 break;
 470         case SR_CONF_TIMEBASE:
 471                 g_variant_get(data, "(tt)", &p, &q);
 472                 for (i = 0; i < ARRAY_SIZE(timebases); i++) {
 473                         if (timebases[i][0] == p && timebases[i][1] == q) {
 474                                 devc->timebase = (float)p / q;
 475                                 ret = set_cfg(sdi, ":TIM:SCAL %.9f", devc->timebase);
 476                                 break;
 477                         }
 478                 }
 479                 if (i == ARRAY_SIZE(timebases))
 480                         ret = SR_ERR_ARG;
 481                 break;
 482         case SR_CONF_TRIGGER_SOURCE:
 483                 tmp_str = g_variant_get_string(data, NULL);
 484                 for (i = 0; i < ARRAY_SIZE(trigger_sources); i++) {
 485                         if (!strcmp(trigger_sources[i], tmp_str)) {
 486                                 g_free(devc->trigger_source);
 487                                 devc->trigger_source = g_strdup(trigger_sources[i]);
 488                                 if (!strcmp(devc->trigger_source, "AC Line"))
 489                                         tmp_str = "ACL";
 490                                 else if (!strcmp(devc->trigger_source, "CH1"))
 491                                         tmp_str = "CHAN1";
 492                                 else if (!strcmp(devc->trigger_source, "CH2"))
 493                                         tmp_str = "CHAN2";
 494                                 else
 495                                         tmp_str = (char *)devc->trigger_source;
 496                                 ret = set_cfg(sdi, ":TRIG:EDGE:SOUR %s", tmp_str);
 497                                 break;
 498                         }
 499                 }
 500                 if (i == ARRAY_SIZE(trigger_sources))
 501                         ret = SR_ERR_ARG;
 502                 break;
 503         case SR_CONF_VDIV:
 504                 g_variant_get(data, "(tt)", &p, &q);
 505                 for (i = 0; i < 2; i++) {
 506                         if (probe_group == &devc->analog_groups[i])
 507                         {
 508                                 for (j = 0; j < ARRAY_SIZE(vdivs); j++)
 509                                 {
 510                                         if (vdivs[j][0] != p || vdivs[j][1] != q)
 511                                                 continue;
 512                                         devc->vdiv[i] = (float)p / q;
 513                                         return set_cfg(sdi, ":CHAN%d:SCAL %.3f", i + 1,
 514                                                         devc->vdiv[i]);
 515                                 }
 516                                 return SR_ERR_ARG;
 517                         }
 518                 }
 519                 return SR_ERR_NA;
 520         case SR_CONF_COUPLING:
 521                 tmp_str = g_variant_get_string(data, NULL);
 522                 for (i = 0; i < 2; i++) {
 523                         if (probe_group == &devc->analog_groups[i])
 524                         {
 525                                 for (j = 0; j < ARRAY_SIZE(coupling); j++)
 526                                 {
 527                                         if (!strcmp(tmp_str, coupling[j]))
 528                                         {
 529                                                 g_free(devc->coupling[i]);
 530                                                 devc->coupling[i] = g_strdup(coupling[j]);
 531                                                 return set_cfg(sdi, ":CHAN%d:COUP %s", i + 1,
 532                                                                 devc->coupling[i]);
 533                                         }
 534                                 }
 535                                 return SR_ERR_ARG;
 536                         }
 537                 }
 538                 return SR_ERR_NA;
 539         default:
 540                 ret = SR_ERR_NA;
 541                 break;
 542         }
 543
 544         return ret;
 545 }
 546
 547 static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi,
 548                 const struct sr_probe_group *probe_group)
 549 {
 550         GVariant *tuple, *rational[2];
 551         GVariantBuilder gvb;
 552         unsigned int i;
 553         struct dev_context *devc = sdi->priv;
 554
 555         switch (key) {
 556         case SR_CONF_SCAN_OPTIONS:
 557                 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
 558                                 hwopts, ARRAY_SIZE(hwopts), sizeof(int32_t));
 559                 break;
 560         case SR_CONF_DEVICE_OPTIONS:
 561                 if (probe_group == NULL) {
 562                         *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
 563                                 hwcaps, ARRAY_SIZE(hwcaps), sizeof(int32_t));
 564                         return SR_OK;
 565                 } else if (probe_group == &devc->digital_group) {
 566                         *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
 567                                 NULL, 0, sizeof(int32_t));
 568                         return SR_OK;
 569                 } else {
 570                         for (i = 0; i < 2; i++) {
 571                                 if (probe_group == &devc->analog_groups[i]) {
 572                                         *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
 573                                                 analog_hwcaps, ARRAY_SIZE(analog_hwcaps), sizeof(int32_t));
 574                                         return SR_OK;
 575                                 }
 576                         }
 577                         return SR_ERR_NA;
 578                 }
 579         case SR_CONF_COUPLING:
 580                 for (i = 0; i < 2; i++) {
 581                         if (probe_group == &devc->analog_groups[i]) {
 582                                 *data = g_variant_new_strv(coupling, ARRAY_SIZE(coupling));
 583                                 return SR_OK;
 584                         }
 585                 }
 586                 return SR_ERR_NA;
 587         case SR_CONF_VDIV:
 588                 for (i = 0; i < 2; i++) {
 589                         if (probe_group == &devc->analog_groups[i]) {
 590                                 rational[0] = g_variant_new_uint64(vdivs[i][0]);
 591                                 rational[1] = g_variant_new_uint64(vdivs[i][1]);
 592                                 *data = g_variant_new_tuple(rational, 2);
 593                                 return SR_OK;
 594                         }
 595                 }
 596                 return SR_ERR_NA;
 597         case SR_CONF_TIMEBASE:
 598                 g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
 599                 for (i = 0; i < ARRAY_SIZE(timebases); i++) {
 600                         rational[0] = g_variant_new_uint64(timebases[i][0]);
 601                         rational[1] = g_variant_new_uint64(timebases[i][1]);
 602                         tuple = g_variant_new_tuple(rational, 2);
 603                         g_variant_builder_add_value(&gvb, tuple);
 604                 }
 605                 *data = g_variant_builder_end(&gvb);
 606                 break;
 607         case SR_CONF_TRIGGER_SOURCE:
 608                 if (!sdi || !sdi->priv)
 609                         /* Can't know this until we have the exact model. */
 610                         return SR_ERR_ARG;
 611                 *data = g_variant_new_strv(trigger_sources,
 612                                 devc->has_digital ? ARRAY_SIZE(trigger_sources) : 4);
 613                 break;
 614         default:
 615                 return SR_ERR_NA;
 616         }
 617
 618         return SR_OK;
 619 }
 620
 621 static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
 622 {
 623         struct sr_serial_dev_inst *serial;
 624         struct dev_context *devc;
 625         struct sr_probe *probe;
 626         GSList *l;
 627         char cmd[256];
 628
 629         if (sdi->status != SR_ST_ACTIVE)
 630                 return SR_ERR_DEV_CLOSED;
 631
 632         serial = sdi->conn;
 633         devc = sdi->priv;
 634
 635         for (l = sdi->probes; l; l = l->next) {
 636                 probe = l->data;
 637                 sr_dbg("handling probe %s", probe->name);
 638                 if (probe->type == SR_PROBE_ANALOG) {
 639                         if (probe->enabled)
 640                                 devc->enabled_analog_probes = g_slist_append(
 641                                                 devc->enabled_analog_probes, probe);
 642                         if (probe->enabled != devc->analog_channels[probe->index]) {
 643                                 /* Enabled channel is currently disabled, or vice versa. */
 644                                 sprintf(cmd, ":CHAN%d:DISP %s", probe->index + 1,
 645                                                 probe->enabled ? "ON" : "OFF");
 646                                 if (rigol_ds1xx2_send(sdi, cmd) != SR_OK)
 647                                         return SR_ERR;
 648                         }
 649                 } else if (probe->type == SR_PROBE_LOGIC) {
 650                         if (probe->enabled)
 651                                 devc->enabled_digital_probes = g_slist_append(
 652                                                 devc->enabled_digital_probes, probe);
 653                         if (probe->enabled != devc->digital_channels[probe->index]) {
 654                                 /* Enabled channel is currently disabled, or vice versa. */
 655                                 sprintf(cmd, ":DIG%d:TURN %s", probe->index,
 656                                                 probe->enabled ? "ON" : "OFF");
 657                                 if (rigol_ds1xx2_send(sdi, cmd) != SR_OK)
 658                                         return SR_ERR;
 659                         }
 660                 }
 661         }
 662         if (!devc->enabled_analog_probes && !devc->enabled_digital_probes)
 663                 return SR_ERR;
 664
 665         sr_source_add(serial->fd, G_IO_IN, 50, rigol_ds1xx2_receive, (void *)sdi);
 666
 667         /* Send header packet to the session bus. */
 668         std_session_send_df_header(cb_data, LOG_PREFIX);
 669
 670         /* Fetch the first frame. */
 671         if (devc->enabled_analog_probes) {
 672                 devc->channel_frame = devc->enabled_analog_probes->data;
 673                 if (rigol_ds1xx2_send(sdi, ":WAV:DATA? CHAN%d",
 674                                 devc->channel_frame->index + 1) != SR_OK)
 675                         return SR_ERR;
 676         } else {
 677                 devc->channel_frame = devc->enabled_digital_probes->data;
 678                 if (rigol_ds1xx2_send(sdi, ":WAV:DATA? DIG") != SR_OK)
 679                         return SR_ERR;
 680         }
 681
 682         devc->num_frame_bytes = 0;
 683
 684         return SR_OK;
 685 }
 686
 687 static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
 688 {
 689         struct dev_context *devc;
 690         struct sr_serial_dev_inst *serial;
 691
 692         (void)cb_data;
 693
 694         devc = sdi->priv;
 695
 696         if (sdi->status != SR_ST_ACTIVE) {
 697                 sr_err("Device inactive, can't stop acquisition.");
 698                 return SR_ERR;
 699         }
 700
 701         g_slist_free(devc->enabled_analog_probes);
 702         g_slist_free(devc->enabled_digital_probes);
 703         devc->enabled_analog_probes = NULL;
 704         devc->enabled_digital_probes = NULL;
 705         serial = sdi->conn;
 706         sr_source_remove(serial->fd);
 707
 708         return SR_OK;
 709 }
 710
 711 SR_PRIV struct sr_dev_driver rigol_ds1xx2_driver_info = {
 712         .name = "rigol-ds1xx2",
 713         .longname = "Rigol DS1xx2",
 714         .api_version = 1,
 715         .init = init,
 716         .cleanup = cleanup,
 717         .scan = scan,
 718         .dev_list = dev_list,
 719         .dev_clear = dev_clear,
 720         .config_get = config_get,
 721         .config_set = config_set,
 722         .config_list = config_list,
 723         .dev_open = dev_open,
 724         .dev_close = dev_close,
 725         .dev_acquisition_start = dev_acquisition_start,
 726         .dev_acquisition_stop = dev_acquisition_stop,
 727         .priv = NULL,
 728 };