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