src/hardware/hameg-hmo/api.c

   1 /*
   2  * This file is part of the libsigrok project.
   3  *
   4  * Copyright (C) 2013 poljar (Damir Jelić) <poljarinho@gmail.com>
   5  *
   6  * This program is free software: you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation, either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <config.h>
  21 #include <stdlib.h>
  22 #include "scpi.h"
  23 #include "protocol.h"
  24
  25 #define SERIALCOMM "115200/8n1/flow=1"
  26
  27 static struct sr_dev_driver hameg_hmo_driver_info;
  28
  29 static const char *manufacturers[] = {
  30         "HAMEG",
  31         "Rohde&Schwarz",
  32 };
  33
  34 static const uint32_t scanopts[] = {
  35         SR_CONF_CONN,
  36         SR_CONF_SERIALCOMM,
  37 };
  38
  39 static const uint32_t drvopts[] = {
  40         SR_CONF_OSCILLOSCOPE,
  41 };
  42
  43 enum {
  44         CG_INVALID = -1,
  45         CG_NONE,
  46         CG_ANALOG,
  47         CG_DIGITAL,
  48 };
  49
  50 static struct sr_dev_inst *probe_device(struct sr_scpi_dev_inst *scpi)
  51 {
  52         struct sr_dev_inst *sdi;
  53         struct dev_context *devc;
  54         struct sr_scpi_hw_info *hw_info;
  55
  56         sdi = NULL;
  57         devc = NULL;
  58         hw_info = NULL;
  59
  60         if (sr_scpi_get_hw_id(scpi, &hw_info) != SR_OK) {
  61                 sr_info("Couldn't get IDN response.");
  62                 goto fail;
  63         }
  64
  65         if (std_str_idx_s(hw_info->manufacturer, ARRAY_AND_SIZE(manufacturers)) < 0)
  66                 goto fail;
  67
  68         sdi = g_malloc0(sizeof(struct sr_dev_inst));
  69         sdi->vendor = g_strdup(hw_info->manufacturer);
  70         sdi->model = g_strdup(hw_info->model);
  71         sdi->version = g_strdup(hw_info->firmware_version);
  72         sdi->serial_num = g_strdup(hw_info->serial_number);
  73         sdi->driver = &hameg_hmo_driver_info;
  74         sdi->inst_type = SR_INST_SCPI;
  75         sdi->conn = scpi;
  76
  77         sr_scpi_hw_info_free(hw_info);
  78         hw_info = NULL;
  79
  80         devc = g_malloc0(sizeof(struct dev_context));
  81
  82         sdi->priv = devc;
  83
  84         if (hmo_init_device(sdi) != SR_OK)
  85                 goto fail;
  86
  87         return sdi;
  88
  89 fail:
  90         sr_scpi_hw_info_free(hw_info);
  91         sr_dev_inst_free(sdi);
  92         g_free(devc);
  93
  94         return NULL;
  95 }
  96
  97 static GSList *scan(struct sr_dev_driver *di, GSList *options)
  98 {
  99         return sr_scpi_scan(di->context, options, probe_device);
 100 }
 101
 102 static void clear_helper(struct dev_context *devc)
 103 {
 104         hmo_scope_state_free(devc->model_state);
 105         g_free(devc->analog_groups);
 106         g_free(devc->digital_groups);
 107 }
 108
 109 static int dev_clear(const struct sr_dev_driver *di)
 110 {
 111         return std_dev_clear_with_callback(di, (std_dev_clear_callback)clear_helper);
 112 }
 113
 114 static int dev_open(struct sr_dev_inst *sdi)
 115 {
 116         if (sr_scpi_open(sdi->conn) != SR_OK)
 117                 return SR_ERR;
 118
 119         if (hmo_scope_state_get(sdi) != SR_OK)
 120                 return SR_ERR;
 121
 122         return SR_OK;
 123 }
 124
 125 static int dev_close(struct sr_dev_inst *sdi)
 126 {
 127         return sr_scpi_close(sdi->conn);
 128 }
 129
 130 static int check_channel_group(struct dev_context *devc,
 131                              const struct sr_channel_group *cg)
 132 {
 133         unsigned int i;
 134         const struct scope_config *model;
 135
 136         model = devc->model_config;
 137
 138         if (!cg)
 139                 return CG_NONE;
 140
 141         for (i = 0; i < model->analog_channels; i++)
 142                 if (cg == devc->analog_groups[i])
 143                         return CG_ANALOG;
 144
 145         for (i = 0; i < model->digital_pods; i++)
 146                 if (cg == devc->digital_groups[i])
 147                         return CG_DIGITAL;
 148
 149         sr_err("Invalid channel group specified.");
 150
 151         return CG_INVALID;
 152 }
 153
 154 static int config_get(uint32_t key, GVariant **data,
 155         const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
 156 {
 157         int cg_type;
 158         unsigned int i;
 159         struct dev_context *devc;
 160         const struct scope_config *model;
 161         struct scope_state *state;
 162
 163         if (!sdi)
 164                 return SR_ERR_ARG;
 165
 166         devc = sdi->priv;
 167
 168         if ((cg_type = check_channel_group(devc, cg)) == CG_INVALID)
 169                 return SR_ERR;
 170
 171         model = devc->model_config;
 172         state = devc->model_state;
 173
 174         switch (key) {
 175         case SR_CONF_NUM_HDIV:
 176                 *data = g_variant_new_int32(model->num_xdivs);
 177                 break;
 178         case SR_CONF_TIMEBASE:
 179                 *data = g_variant_new("(tt)", (*model->timebases)[state->timebase][0],
 180                                       (*model->timebases)[state->timebase][1]);
 181                 break;
 182         case SR_CONF_NUM_VDIV:
 183                 if (cg_type == CG_NONE) {
 184                         return SR_ERR_CHANNEL_GROUP;
 185                 } else if (cg_type == CG_ANALOG) {
 186                         for (i = 0; i < model->analog_channels; i++) {
 187                                 if (cg != devc->analog_groups[i])
 188                                         continue;
 189                                 *data = g_variant_new_int32(model->num_ydivs);
 190                                 break;
 191                         }
 192                 } else {
 193                         return SR_ERR_NA;
 194                 }
 195                 break;
 196         case SR_CONF_VDIV:
 197                 if (cg_type == CG_NONE) {
 198                         return SR_ERR_CHANNEL_GROUP;
 199                 } else if (cg_type == CG_ANALOG) {
 200                         for (i = 0; i < model->analog_channels; i++) {
 201                                 if (cg != devc->analog_groups[i])
 202                                         continue;
 203                                 *data = g_variant_new("(tt)",
 204                                                       (*model->vdivs)[state->analog_channels[i].vdiv][0],
 205                                                       (*model->vdivs)[state->analog_channels[i].vdiv][1]);
 206                                 break;
 207                         }
 208                 } else {
 209                         return SR_ERR_NA;
 210                 }
 211                 break;
 212         case SR_CONF_TRIGGER_SOURCE:
 213                 *data = g_variant_new_string((*model->trigger_sources)[state->trigger_source]);
 214                 break;
 215         case SR_CONF_TRIGGER_SLOPE:
 216                 *data = g_variant_new_string((*model->trigger_slopes)[state->trigger_slope]);
 217                 break;
 218         case SR_CONF_HORIZ_TRIGGERPOS:
 219                 *data = g_variant_new_double(state->horiz_triggerpos);
 220                 break;
 221         case SR_CONF_COUPLING:
 222                 if (cg_type == CG_NONE) {
 223                         return SR_ERR_CHANNEL_GROUP;
 224                 } else if (cg_type == CG_ANALOG) {
 225                         for (i = 0; i < model->analog_channels; i++) {
 226                                 if (cg != devc->analog_groups[i])
 227                                         continue;
 228                                 *data = g_variant_new_string((*model->coupling_options)[state->analog_channels[i].coupling]);
 229                                 break;
 230                         }
 231                 } else {
 232                         return SR_ERR_NA;
 233                 }
 234                 break;
 235         case SR_CONF_SAMPLERATE:
 236                 *data = g_variant_new_uint64(state->sample_rate);
 237                 break;
 238         default:
 239                 return SR_ERR_NA;
 240         }
 241
 242         return SR_OK;
 243 }
 244
 245 static int config_set(uint32_t key, GVariant *data,
 246         const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
 247 {
 248         int ret, cg_type, idx;
 249         unsigned int j;
 250         char command[MAX_COMMAND_SIZE], float_str[30];
 251         struct dev_context *devc;
 252         const struct scope_config *model;
 253         struct scope_state *state;
 254         double tmp_d;
 255         gboolean update_sample_rate;
 256
 257         if (!sdi)
 258                 return SR_ERR_ARG;
 259
 260         devc = sdi->priv;
 261
 262         if ((cg_type = check_channel_group(devc, cg)) == CG_INVALID)
 263                 return SR_ERR;
 264
 265         model = devc->model_config;
 266         state = devc->model_state;
 267         update_sample_rate = FALSE;
 268
 269         ret = SR_ERR_NA;
 270
 271         switch (key) {
 272         case SR_CONF_LIMIT_FRAMES:
 273                 devc->frame_limit = g_variant_get_uint64(data);
 274                 ret = SR_OK;
 275                 break;
 276         case SR_CONF_TRIGGER_SOURCE:
 277                 if ((idx = std_str_idx(data, *model->trigger_sources, model->num_trigger_sources)) < 0)
 278                         return SR_ERR_ARG;
 279                 state->trigger_source = idx;
 280                 g_snprintf(command, sizeof(command),
 281                            (*model->scpi_dialect)[SCPI_CMD_SET_TRIGGER_SOURCE],
 282                            (*model->trigger_sources)[idx]);
 283                 ret = sr_scpi_send(sdi->conn, command);
 284                 break;
 285         case SR_CONF_VDIV:
 286                 if (cg_type == CG_NONE)
 287                         return SR_ERR_CHANNEL_GROUP;
 288                 if ((idx = std_u64_tuple_idx(data, *model->vdivs, model->num_vdivs)) < 0)
 289                         return SR_ERR_ARG;
 290                 for (j = 0; j < model->analog_channels; j++) {
 291                         if (cg != devc->analog_groups[j])
 292                                 continue;
 293                         state->analog_channels[j].vdiv = idx;
 294                         g_ascii_formatd(float_str, sizeof(float_str), "%E",
 295                                 (float) (*model->vdivs)[idx][0] / (*model->vdivs)[idx][1]);
 296                         g_snprintf(command, sizeof(command),
 297                                    (*model->scpi_dialect)[SCPI_CMD_SET_VERTICAL_DIV],
 298                                    j + 1, float_str);
 299                         if (sr_scpi_send(sdi->conn, command) != SR_OK ||
 300                             sr_scpi_get_opc(sdi->conn) != SR_OK)
 301                                 return SR_ERR;
 302                         break;
 303                 }
 304                 ret = SR_OK;
 305                 break;
 306         case SR_CONF_TIMEBASE:
 307                 if ((idx = std_u64_tuple_idx(data, *model->timebases, model->num_timebases)) < 0)
 308                         return SR_ERR_ARG;
 309                 state->timebase = idx;
 310                 g_ascii_formatd(float_str, sizeof(float_str), "%E",
 311                         (float) (*model->timebases)[idx][0] / (*model->timebases)[idx][1]);
 312                 g_snprintf(command, sizeof(command),
 313                            (*model->scpi_dialect)[SCPI_CMD_SET_TIMEBASE],
 314                            float_str);
 315                 ret = sr_scpi_send(sdi->conn, command);
 316                 update_sample_rate = TRUE;
 317                 break;
 318         case SR_CONF_HORIZ_TRIGGERPOS:
 319                 tmp_d = g_variant_get_double(data);
 320                 if (tmp_d < 0.0 || tmp_d > 1.0)
 321                         return SR_ERR;
 322                 state->horiz_triggerpos = tmp_d;
 323                 tmp_d = -(tmp_d - 0.5) *
 324                         ((double) (*model->timebases)[state->timebase][0] /
 325                         (*model->timebases)[state->timebase][1])
 326                          * model->num_xdivs;
 327                 g_ascii_formatd(float_str, sizeof(float_str), "%E", tmp_d);
 328                 g_snprintf(command, sizeof(command),
 329                            (*model->scpi_dialect)[SCPI_CMD_SET_HORIZ_TRIGGERPOS],
 330                            float_str);
 331                 ret = sr_scpi_send(sdi->conn, command);
 332                 break;
 333         case SR_CONF_TRIGGER_SLOPE:
 334                 if ((idx = std_str_idx(data, *model->trigger_slopes, model->num_trigger_slopes)) < 0)
 335                         return SR_ERR_ARG;
 336                 state->trigger_slope = idx;
 337                 g_snprintf(command, sizeof(command),
 338                            (*model->scpi_dialect)[SCPI_CMD_SET_TRIGGER_SLOPE],
 339                            (*model->trigger_slopes)[idx]);
 340                 ret = sr_scpi_send(sdi->conn, command);
 341                 break;
 342         case SR_CONF_COUPLING:
 343                 if (cg_type == CG_NONE)
 344                         return SR_ERR_CHANNEL_GROUP;
 345                 if ((idx = std_str_idx(data, *model->coupling_options, model->num_coupling_options)) < 0)
 346                         return SR_ERR_ARG;
 347                 for (j = 0; j <= model->analog_channels; j++) {
 348                         if (cg != devc->analog_groups[j])
 349                                 continue;
 350                         state->analog_channels[j].coupling = idx;
 351                         g_snprintf(command, sizeof(command),
 352                                    (*model->scpi_dialect)[SCPI_CMD_SET_COUPLING],
 353                                    j + 1, (*model->coupling_options)[idx]);
 354                         if (sr_scpi_send(sdi->conn, command) != SR_OK ||
 355                             sr_scpi_get_opc(sdi->conn) != SR_OK)
 356                                 return SR_ERR;
 357                         break;
 358                 }
 359                 ret = SR_OK;
 360                 break;
 361         default:
 362                 ret = SR_ERR_NA;
 363                 break;
 364         }
 365
 366         if (ret == SR_OK)
 367                 ret = sr_scpi_get_opc(sdi->conn);
 368
 369         if (ret == SR_OK && update_sample_rate)
 370                 ret = hmo_update_sample_rate(sdi);
 371
 372         return ret;
 373 }
 374
 375 static int config_list(uint32_t key, GVariant **data,
 376         const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
 377 {
 378         int cg_type = CG_NONE;
 379         struct dev_context *devc = NULL;
 380         const struct scope_config *model = NULL;
 381
 382         if (sdi) {
 383                 devc = sdi->priv;
 384                 if ((cg_type = check_channel_group(devc, cg)) == CG_INVALID)
 385                         return SR_ERR;
 386
 387                 model = devc->model_config;
 388         }
 389
 390         switch (key) {
 391         case SR_CONF_SCAN_OPTIONS:
 392                 *data = std_gvar_array_u32(ARRAY_AND_SIZE(scanopts));
 393                 break;
 394         case SR_CONF_DEVICE_OPTIONS:
 395                 if (cg_type == CG_NONE) {
 396                         if (model)
 397                                 *data = std_gvar_array_u32((const uint32_t *)model->devopts, model->num_devopts);
 398                         else
 399                                 *data = std_gvar_array_u32(ARRAY_AND_SIZE(drvopts));
 400                 } else if (cg_type == CG_ANALOG) {
 401                         *data = std_gvar_array_u32((const uint32_t *)model->devopts_cg_analog, model->num_devopts_cg_analog);
 402                 } else {
 403                         *data = std_gvar_array_u32(NULL, 0);
 404                 }
 405                 break;
 406         case SR_CONF_COUPLING:
 407                 if (cg_type == CG_NONE)
 408                         return SR_ERR_CHANNEL_GROUP;
 409                 *data = g_variant_new_strv(*model->coupling_options, model->num_coupling_options);
 410                 break;
 411         case SR_CONF_TRIGGER_SOURCE:
 412                 if (!model)
 413                         return SR_ERR_ARG;
 414                 *data = g_variant_new_strv(*model->trigger_sources, model->num_trigger_sources);
 415                 break;
 416         case SR_CONF_TRIGGER_SLOPE:
 417                 if (!model)
 418                         return SR_ERR_ARG;
 419                 *data = g_variant_new_strv(*model->trigger_slopes, model->num_trigger_slopes);
 420                 break;
 421         case SR_CONF_TIMEBASE:
 422                 if (!model)
 423                         return SR_ERR_ARG;
 424                 *data = std_gvar_tuple_array(*model->timebases, model->num_timebases);
 425                 break;
 426         case SR_CONF_VDIV:
 427                 if (cg_type == CG_NONE)
 428                         return SR_ERR_CHANNEL_GROUP;
 429                 *data = std_gvar_tuple_array(*model->vdivs, model->num_vdivs);
 430                 break;
 431         default:
 432                 return SR_ERR_NA;
 433         }
 434
 435         return SR_OK;
 436 }
 437
 438 SR_PRIV int hmo_request_data(const struct sr_dev_inst *sdi)
 439 {
 440         char command[MAX_COMMAND_SIZE];
 441         struct sr_channel *ch;
 442         struct dev_context *devc;
 443         const struct scope_config *model;
 444
 445         devc = sdi->priv;
 446         model = devc->model_config;
 447
 448         ch = devc->current_channel->data;
 449
 450         switch (ch->type) {
 451         case SR_CHANNEL_ANALOG:
 452                 g_snprintf(command, sizeof(command),
 453                            (*model->scpi_dialect)[SCPI_CMD_GET_ANALOG_DATA],
 454 #ifdef WORDS_BIGENDIAN
 455                            "MSBF",
 456 #else
 457                            "LSBF",
 458 #endif
 459                            ch->index + 1);
 460                 break;
 461         case SR_CHANNEL_LOGIC:
 462                 g_snprintf(command, sizeof(command),
 463                            (*model->scpi_dialect)[SCPI_CMD_GET_DIG_DATA],
 464                            ch->index < 8 ? 1 : 2);
 465                 break;
 466         default:
 467                 sr_err("Invalid channel type.");
 468                 break;
 469         }
 470
 471         return sr_scpi_send(sdi->conn, command);
 472 }
 473
 474 static int hmo_check_channels(GSList *channels)
 475 {
 476         GSList *l;
 477         struct sr_channel *ch;
 478         gboolean enabled_chan[MAX_ANALOG_CHANNEL_COUNT];
 479         gboolean enabled_pod[MAX_DIGITAL_GROUP_COUNT];
 480         size_t idx;
 481
 482         /* Preset "not enabled" for all channels / pods. */
 483         for (idx = 0; idx < ARRAY_SIZE(enabled_chan); idx++)
 484                 enabled_chan[idx] = FALSE;
 485         for (idx = 0; idx < ARRAY_SIZE(enabled_pod); idx++)
 486                 enabled_pod[idx] = FALSE;
 487
 488         /*
 489          * Determine which channels / pods are required for the caller's
 490          * specified configuration.
 491          */
 492         for (l = channels; l; l = l->next) {
 493                 ch = l->data;
 494                 switch (ch->type) {
 495                 case SR_CHANNEL_ANALOG:
 496                         idx = ch->index;
 497                         if (idx < ARRAY_SIZE(enabled_chan))
 498                                 enabled_chan[idx] = TRUE;
 499                         break;
 500                 case SR_CHANNEL_LOGIC:
 501                         idx = ch->index / 8;
 502                         if (idx < ARRAY_SIZE(enabled_pod))
 503                                 enabled_pod[idx] = TRUE;
 504                         break;
 505                 default:
 506                         return SR_ERR;
 507                 }
 508         }
 509
 510         /*
 511          * Check for resource conflicts. Some channels can be either
 512          * analog or digital, but never both at the same time.
 513          *
 514          * Note that the constraints might depend on the specific model.
 515          * These tests might need some adjustment when support for more
 516          * models gets added to the driver.
 517          */
 518         if (enabled_pod[0] && enabled_chan[2])
 519                 return SR_ERR;
 520         if (enabled_pod[1] && enabled_chan[3])
 521                 return SR_ERR;
 522         return SR_OK;
 523 }
 524
 525 static int hmo_setup_channels(const struct sr_dev_inst *sdi)
 526 {
 527         GSList *l;
 528         unsigned int i;
 529         gboolean *pod_enabled, setup_changed;
 530         char command[MAX_COMMAND_SIZE];
 531         struct scope_state *state;
 532         const struct scope_config *model;
 533         struct sr_channel *ch;
 534         struct dev_context *devc;
 535         struct sr_scpi_dev_inst *scpi;
 536
 537         devc = sdi->priv;
 538         scpi = sdi->conn;
 539         state = devc->model_state;
 540         model = devc->model_config;
 541         setup_changed = FALSE;
 542
 543         pod_enabled = g_try_malloc0(sizeof(gboolean) * model->digital_pods);
 544
 545         for (l = sdi->channels; l; l = l->next) {
 546                 ch = l->data;
 547                 switch (ch->type) {
 548                 case SR_CHANNEL_ANALOG:
 549                         if (ch->enabled == state->analog_channels[ch->index].state)
 550                                 break;
 551                         g_snprintf(command, sizeof(command),
 552                                    (*model->scpi_dialect)[SCPI_CMD_SET_ANALOG_CHAN_STATE],
 553                                    ch->index + 1, ch->enabled);
 554
 555                         if (sr_scpi_send(scpi, command) != SR_OK)
 556                                 return SR_ERR;
 557                         state->analog_channels[ch->index].state = ch->enabled;
 558                         setup_changed = TRUE;
 559                         break;
 560                 case SR_CHANNEL_LOGIC:
 561                         /*
 562                          * A digital POD needs to be enabled for every group of
 563                          * 8 channels.
 564                          */
 565                         if (ch->enabled)
 566                                 pod_enabled[ch->index < 8 ? 0 : 1] = TRUE;
 567
 568                         if (ch->enabled == state->digital_channels[ch->index])
 569                                 break;
 570                         g_snprintf(command, sizeof(command),
 571                                    (*model->scpi_dialect)[SCPI_CMD_SET_DIG_CHAN_STATE],
 572                                    ch->index, ch->enabled);
 573
 574                         if (sr_scpi_send(scpi, command) != SR_OK)
 575                                 return SR_ERR;
 576
 577                         state->digital_channels[ch->index] = ch->enabled;
 578                         setup_changed = TRUE;
 579                         break;
 580                 default:
 581                         return SR_ERR;
 582                 }
 583         }
 584
 585         for (i = 0; i < model->digital_pods; i++) {
 586                 if (state->digital_pods[i] == pod_enabled[i])
 587                         continue;
 588                 g_snprintf(command, sizeof(command),
 589                            (*model->scpi_dialect)[SCPI_CMD_SET_DIG_POD_STATE],
 590                            i + 1, pod_enabled[i]);
 591                 if (sr_scpi_send(scpi, command) != SR_OK)
 592                         return SR_ERR;
 593                 state->digital_pods[i] = pod_enabled[i];
 594                 setup_changed = TRUE;
 595         }
 596
 597         g_free(pod_enabled);
 598
 599         if (setup_changed && hmo_update_sample_rate(sdi) != SR_OK)
 600                 return SR_ERR;
 601
 602         return SR_OK;
 603 }
 604
 605 static int dev_acquisition_start(const struct sr_dev_inst *sdi)
 606 {
 607         GSList *l;
 608         gboolean digital_added[MAX_DIGITAL_GROUP_COUNT];
 609         size_t group, pod_count;
 610         struct sr_channel *ch;
 611         struct dev_context *devc;
 612         struct sr_scpi_dev_inst *scpi;
 613         int ret;
 614
 615         scpi = sdi->conn;
 616         devc = sdi->priv;
 617
 618         /* Preset empty results. */
 619         for (group = 0; group < ARRAY_SIZE(digital_added); group++)
 620                 digital_added[group] = FALSE;
 621         g_slist_free(devc->enabled_channels);
 622         devc->enabled_channels = NULL;
 623
 624         /*
 625          * Contruct the list of enabled channels. Determine the highest
 626          * number of digital pods involved in the acquisition.
 627          */
 628         pod_count = 0;
 629         for (l = sdi->channels; l; l = l->next) {
 630                 ch = l->data;
 631                 if (!ch->enabled)
 632                         continue;
 633                 /* Only add a single digital channel per group (pod). */
 634                 group = ch->index / 8;
 635                 if (ch->type != SR_CHANNEL_LOGIC || !digital_added[group]) {
 636                         devc->enabled_channels = g_slist_append(
 637                                         devc->enabled_channels, ch);
 638                         if (ch->type == SR_CHANNEL_LOGIC) {
 639                                 digital_added[group] = TRUE;
 640                                 if (pod_count < group + 1)
 641                                         pod_count = group + 1;
 642                         }
 643                 }
 644         }
 645         if (!devc->enabled_channels)
 646                 return SR_ERR;
 647         devc->pod_count = pod_count;
 648         devc->logic_data = NULL;
 649
 650         /*
 651          * Check constraints. Some channels can be either analog or
 652          * digital, but not both at the same time.
 653          */
 654         if (hmo_check_channels(devc->enabled_channels) != SR_OK) {
 655                 sr_err("Invalid channel configuration specified!");
 656                 ret = SR_ERR_NA;
 657                 goto free_enabled;
 658         }
 659
 660         /*
 661          * Configure the analog and digital channels and the
 662          * corresponding digital pods.
 663          */
 664         if (hmo_setup_channels(sdi) != SR_OK) {
 665                 sr_err("Failed to setup channel configuration!");
 666                 ret = SR_ERR;
 667                 goto free_enabled;
 668         }
 669
 670         /*
 671          * Start acquisition on the first enabled channel. The
 672          * receive routine will continue driving the acquisition.
 673          */
 674         sr_scpi_source_add(sdi->session, scpi, G_IO_IN, 50,
 675                         hmo_receive_data, (void *)sdi);
 676
 677         std_session_send_df_header(sdi);
 678
 679         devc->current_channel = devc->enabled_channels;
 680
 681         return hmo_request_data(sdi);
 682
 683 free_enabled:
 684         g_slist_free(devc->enabled_channels);
 685         devc->enabled_channels = NULL;
 686         return ret;
 687 }
 688
 689 static int dev_acquisition_stop(struct sr_dev_inst *sdi)
 690 {
 691         struct dev_context *devc;
 692         struct sr_scpi_dev_inst *scpi;
 693
 694         std_session_send_df_end(sdi);
 695
 696         devc = sdi->priv;
 697
 698         devc->num_frames = 0;
 699         g_slist_free(devc->enabled_channels);
 700         devc->enabled_channels = NULL;
 701         scpi = sdi->conn;
 702         sr_scpi_source_remove(sdi->session, scpi);
 703
 704         return SR_OK;
 705 }
 706
 707 static struct sr_dev_driver hameg_hmo_driver_info = {
 708         .name = "hameg-hmo",
 709         .longname = "Hameg HMO",
 710         .api_version = 1,
 711         .init = std_init,
 712         .cleanup = std_cleanup,
 713         .scan = scan,
 714         .dev_list = std_dev_list,
 715         .dev_clear = dev_clear,
 716         .config_get = config_get,
 717         .config_set = config_set,
 718         .config_list = config_list,
 719         .dev_open = dev_open,
 720         .dev_close = dev_close,
 721         .dev_acquisition_start = dev_acquisition_start,
 722         .dev_acquisition_stop = dev_acquisition_stop,
 723         .context = NULL,
 724 };
 725 SR_REGISTER_DEV_DRIVER(hameg_hmo_driver_info);