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 *hmo_probe_serial_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, hmo_probe_serial_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 ret, 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         ret = SR_ERR_NA;
 172         model = devc->model_config;
 173         state = devc->model_state;
 174
 175         switch (key) {
 176         case SR_CONF_NUM_HDIV:
 177                 *data = g_variant_new_int32(model->num_xdivs);
 178                 ret = SR_OK;
 179                 break;
 180         case SR_CONF_TIMEBASE:
 181                 *data = g_variant_new("(tt)", (*model->timebases)[state->timebase][0],
 182                                       (*model->timebases)[state->timebase][1]);
 183                 ret = SR_OK;
 184                 break;
 185         case SR_CONF_NUM_VDIV:
 186                 if (cg_type == CG_NONE) {
 187                         return SR_ERR_CHANNEL_GROUP;
 188                 } else if (cg_type == CG_ANALOG) {
 189                         for (i = 0; i < model->analog_channels; i++) {
 190                                 if (cg != devc->analog_groups[i])
 191                                         continue;
 192                                 *data = g_variant_new_int32(model->num_ydivs);
 193                                 ret = SR_OK;
 194                                 break;
 195                         }
 196
 197                 } else {
 198                         ret = SR_ERR_NA;
 199                 }
 200                 break;
 201         case SR_CONF_VDIV:
 202                 if (cg_type == CG_NONE) {
 203                         return SR_ERR_CHANNEL_GROUP;
 204                 } else if (cg_type == CG_ANALOG) {
 205                         for (i = 0; i < model->analog_channels; i++) {
 206                                 if (cg != devc->analog_groups[i])
 207                                         continue;
 208                                 *data = g_variant_new("(tt)",
 209                                                       (*model->vdivs)[state->analog_channels[i].vdiv][0],
 210                                                       (*model->vdivs)[state->analog_channels[i].vdiv][1]);
 211                                 ret = SR_OK;
 212                                 break;
 213                         }
 214
 215                 } else {
 216                         ret = SR_ERR_NA;
 217                 }
 218                 break;
 219         case SR_CONF_TRIGGER_SOURCE:
 220                 *data = g_variant_new_string((*model->trigger_sources)[state->trigger_source]);
 221                 ret = SR_OK;
 222                 break;
 223         case SR_CONF_TRIGGER_SLOPE:
 224                 *data = g_variant_new_string((*model->trigger_slopes)[state->trigger_slope]);
 225                 ret = SR_OK;
 226                 break;
 227         case SR_CONF_HORIZ_TRIGGERPOS:
 228                 *data = g_variant_new_double(state->horiz_triggerpos);
 229                 ret = SR_OK;
 230                 break;
 231         case SR_CONF_COUPLING:
 232                 if (cg_type == CG_NONE) {
 233                         return SR_ERR_CHANNEL_GROUP;
 234                 } else if (cg_type == CG_ANALOG) {
 235                         for (i = 0; i < model->analog_channels; i++) {
 236                                 if (cg != devc->analog_groups[i])
 237                                         continue;
 238                                 *data = g_variant_new_string((*model->coupling_options)[state->analog_channels[i].coupling]);
 239                                 ret = SR_OK;
 240                                 break;
 241                         }
 242
 243                 } else {
 244                         ret = SR_ERR_NA;
 245                 }
 246                 break;
 247         case SR_CONF_SAMPLERATE:
 248                 *data = g_variant_new_uint64(state->sample_rate);
 249                 ret = SR_OK;
 250                 break;
 251         default:
 252                 ret = SR_ERR_NA;
 253         }
 254
 255         return ret;
 256 }
 257
 258 static int config_set(uint32_t key, GVariant *data,
 259         const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
 260 {
 261         int ret, cg_type, idx;
 262         unsigned int i, j;
 263         char command[MAX_COMMAND_SIZE], float_str[30];
 264         struct dev_context *devc;
 265         const struct scope_config *model;
 266         struct scope_state *state;
 267         const char *tmp;
 268         double tmp_d;
 269         gboolean update_sample_rate;
 270
 271         if (!sdi)
 272                 return SR_ERR_ARG;
 273
 274         devc = sdi->priv;
 275
 276         if ((cg_type = check_channel_group(devc, cg)) == CG_INVALID)
 277                 return SR_ERR;
 278
 279         model = devc->model_config;
 280         state = devc->model_state;
 281         update_sample_rate = FALSE;
 282
 283         ret = SR_ERR_NA;
 284
 285         switch (key) {
 286         case SR_CONF_LIMIT_FRAMES:
 287                 devc->frame_limit = g_variant_get_uint64(data);
 288                 ret = SR_OK;
 289                 break;
 290         case SR_CONF_TRIGGER_SOURCE:
 291                 tmp = g_variant_get_string(data, NULL);
 292                 for (i = 0; (*model->trigger_sources)[i]; i++) {
 293                         if (g_strcmp0(tmp, (*model->trigger_sources)[i]) != 0)
 294                                 continue;
 295                         state->trigger_source = i;
 296                         g_snprintf(command, sizeof(command),
 297                                    (*model->scpi_dialect)[SCPI_CMD_SET_TRIGGER_SOURCE],
 298                                    (*model->trigger_sources)[i]);
 299
 300                         ret = sr_scpi_send(sdi->conn, command);
 301                         break;
 302                 }
 303                 break;
 304         case SR_CONF_VDIV:
 305                 if (cg_type == CG_NONE)
 306                         return SR_ERR_CHANNEL_GROUP;
 307                 if ((idx = std_u64_tuple_idx(data, *model->vdivs, model->num_vdivs)) < 0)
 308                         return SR_ERR_ARG;
 309                 for (j = 1; j <= model->analog_channels; j++) {
 310                         if (cg != devc->analog_groups[j - 1])
 311                                 continue;
 312                         state->analog_channels[j - 1].vdiv = idx;
 313                         g_ascii_formatd(float_str, sizeof(float_str), "%E",
 314                                 (float) (*model->vdivs)[idx][0] / (*model->vdivs)[idx][1]);
 315                         g_snprintf(command, sizeof(command),
 316                                    (*model->scpi_dialect)[SCPI_CMD_SET_VERTICAL_DIV],
 317                                    j, float_str);
 318                         if (sr_scpi_send(sdi->conn, command) != SR_OK ||
 319                             sr_scpi_get_opc(sdi->conn) != SR_OK)
 320                                 return SR_ERR;
 321                         break;
 322                 }
 323                 ret = SR_OK;
 324                 break;
 325         case SR_CONF_TIMEBASE:
 326                 if ((idx = std_u64_tuple_idx(data, *model->timebases, model->num_timebases)) < 0)
 327                         return SR_ERR_ARG;
 328                 state->timebase = idx;
 329                 g_ascii_formatd(float_str, sizeof(float_str), "%E",
 330                         (float) (*model->timebases)[idx][0] / (*model->timebases)[idx][1]);
 331                 g_snprintf(command, sizeof(command),
 332                            (*model->scpi_dialect)[SCPI_CMD_SET_TIMEBASE],
 333                            float_str);
 334                 ret = sr_scpi_send(sdi->conn, command);
 335                 update_sample_rate = TRUE;
 336                 break;
 337         case SR_CONF_HORIZ_TRIGGERPOS:
 338                 tmp_d = g_variant_get_double(data);
 339
 340                 if (tmp_d < 0.0 || tmp_d > 1.0)
 341                         return SR_ERR;
 342
 343                 state->horiz_triggerpos = tmp_d;
 344                 tmp_d = -(tmp_d - 0.5) *
 345                         ((double) (*model->timebases)[state->timebase][0] /
 346                         (*model->timebases)[state->timebase][1])
 347                          * model->num_xdivs;
 348
 349                 g_ascii_formatd(float_str, sizeof(float_str), "%E", tmp_d);
 350                 g_snprintf(command, sizeof(command),
 351                            (*model->scpi_dialect)[SCPI_CMD_SET_HORIZ_TRIGGERPOS],
 352                            float_str);
 353
 354                 ret = sr_scpi_send(sdi->conn, command);
 355                 break;
 356         case SR_CONF_TRIGGER_SLOPE:
 357                 tmp = g_variant_get_string(data, NULL);
 358                 for (i = 0; (*model->trigger_slopes)[i]; i++) {
 359                         if (g_strcmp0(tmp, (*model->trigger_slopes)[i]) != 0)
 360                                 continue;
 361                         state->trigger_slope = i;
 362                         g_snprintf(command, sizeof(command),
 363                                    (*model->scpi_dialect)[SCPI_CMD_SET_TRIGGER_SLOPE],
 364                                    (*model->trigger_slopes)[i]);
 365
 366                         ret = sr_scpi_send(sdi->conn, command);
 367                         break;
 368                 }
 369                 break;
 370         case SR_CONF_COUPLING:
 371                 if (cg_type == CG_NONE)
 372                         return SR_ERR_CHANNEL_GROUP;
 373
 374                 tmp = g_variant_get_string(data, NULL);
 375
 376                 for (i = 0; (*model->coupling_options)[i]; i++) {
 377                         if (strcmp(tmp, (*model->coupling_options)[i]) != 0)
 378                                 continue;
 379                         for (j = 1; j <= model->analog_channels; j++) {
 380                                 if (cg != devc->analog_groups[j - 1])
 381                                         continue;
 382                                 state->analog_channels[j-1].coupling = i;
 383
 384                                 g_snprintf(command, sizeof(command),
 385                                            (*model->scpi_dialect)[SCPI_CMD_SET_COUPLING],
 386                                            j, tmp);
 387
 388                                 if (sr_scpi_send(sdi->conn, command) != SR_OK ||
 389                                     sr_scpi_get_opc(sdi->conn) != SR_OK)
 390                                         return SR_ERR;
 391                                 break;
 392                         }
 393
 394                         ret = SR_OK;
 395                         break;
 396                 }
 397                 break;
 398         default:
 399                 ret = SR_ERR_NA;
 400                 break;
 401         }
 402
 403         if (ret == SR_OK)
 404                 ret = sr_scpi_get_opc(sdi->conn);
 405
 406         if (ret == SR_OK && update_sample_rate)
 407                 ret = hmo_update_sample_rate(sdi);
 408
 409         return ret;
 410 }
 411
 412 static int config_list(uint32_t key, GVariant **data,
 413         const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
 414 {
 415         int cg_type = CG_NONE;
 416         struct dev_context *devc = NULL;
 417         const struct scope_config *model = NULL;
 418
 419         if (sdi) {
 420                 devc = sdi->priv;
 421                 if ((cg_type = check_channel_group(devc, cg)) == CG_INVALID)
 422                         return SR_ERR;
 423
 424                 model = devc->model_config;
 425         }
 426
 427         switch (key) {
 428         case SR_CONF_SCAN_OPTIONS:
 429                 *data = std_gvar_array_u32(ARRAY_AND_SIZE(scanopts));
 430                 break;
 431         case SR_CONF_DEVICE_OPTIONS:
 432                 if (cg_type == CG_NONE) {
 433                         if (model)
 434                                 *data = std_gvar_array_u32((const uint32_t *)model->devopts, model->num_devopts);
 435                         else
 436                                 *data = std_gvar_array_u32(ARRAY_AND_SIZE(drvopts));
 437                 } else if (cg_type == CG_ANALOG) {
 438                         *data = std_gvar_array_u32((const uint32_t *)model->devopts_cg_analog, model->num_devopts_cg_analog);
 439                 } else {
 440                         *data = std_gvar_array_u32(NULL, 0);
 441                 }
 442                 break;
 443         case SR_CONF_COUPLING:
 444                 if (cg_type == CG_NONE)
 445                         return SR_ERR_CHANNEL_GROUP;
 446                 *data = g_variant_new_strv(*model->coupling_options,
 447                            g_strv_length((char **)*model->coupling_options));
 448                 break;
 449         case SR_CONF_TRIGGER_SOURCE:
 450                 if (!model)
 451                         return SR_ERR_ARG;
 452                 *data = g_variant_new_strv(*model->trigger_sources,
 453                            g_strv_length((char **)*model->trigger_sources));
 454                 break;
 455         case SR_CONF_TRIGGER_SLOPE:
 456                 if (!model)
 457                         return SR_ERR_ARG;
 458                 *data = g_variant_new_strv(*model->trigger_slopes,
 459                            g_strv_length((char **)*model->trigger_slopes));
 460                 break;
 461         case SR_CONF_TIMEBASE:
 462                 if (!model)
 463                         return SR_ERR_ARG;
 464                 *data = std_gvar_tuple_array(*model->timebases, model->num_timebases);
 465                 break;
 466         case SR_CONF_VDIV:
 467                 if (cg_type == CG_NONE)
 468                         return SR_ERR_CHANNEL_GROUP;
 469                 *data = std_gvar_tuple_array(*model->vdivs, model->num_vdivs);
 470                 break;
 471         default:
 472                 return SR_ERR_NA;
 473         }
 474
 475         return SR_OK;
 476 }
 477
 478 SR_PRIV int hmo_request_data(const struct sr_dev_inst *sdi)
 479 {
 480         char command[MAX_COMMAND_SIZE];
 481         struct sr_channel *ch;
 482         struct dev_context *devc;
 483         const struct scope_config *model;
 484
 485         devc = sdi->priv;
 486         model = devc->model_config;
 487
 488         ch = devc->current_channel->data;
 489
 490         switch (ch->type) {
 491         case SR_CHANNEL_ANALOG:
 492                 g_snprintf(command, sizeof(command),
 493                            (*model->scpi_dialect)[SCPI_CMD_GET_ANALOG_DATA],
 494 #ifdef WORDS_BIGENDIAN
 495                            "MSBF",
 496 #else
 497                            "LSBF",
 498 #endif
 499                            ch->index + 1);
 500                 break;
 501         case SR_CHANNEL_LOGIC:
 502                 g_snprintf(command, sizeof(command),
 503                            (*model->scpi_dialect)[SCPI_CMD_GET_DIG_DATA],
 504                            ch->index < 8 ? 1 : 2);
 505                 break;
 506         default:
 507                 sr_err("Invalid channel type.");
 508                 break;
 509         }
 510
 511         return sr_scpi_send(sdi->conn, command);
 512 }
 513
 514 static int hmo_check_channels(GSList *channels)
 515 {
 516         GSList *l;
 517         struct sr_channel *ch;
 518         gboolean enabled_chan[MAX_ANALOG_CHANNEL_COUNT];
 519         gboolean enabled_pod[MAX_DIGITAL_GROUP_COUNT];
 520         size_t idx;
 521
 522         /* Preset "not enabled" for all channels / pods. */
 523         for (idx = 0; idx < ARRAY_SIZE(enabled_chan); idx++)
 524                 enabled_chan[idx] = FALSE;
 525         for (idx = 0; idx < ARRAY_SIZE(enabled_pod); idx++)
 526                 enabled_pod[idx] = FALSE;
 527
 528         /*
 529          * Determine which channels / pods are required for the caller's
 530          * specified configuration.
 531          */
 532         for (l = channels; l; l = l->next) {
 533                 ch = l->data;
 534                 switch (ch->type) {
 535                 case SR_CHANNEL_ANALOG:
 536                         idx = ch->index;
 537                         if (idx < ARRAY_SIZE(enabled_chan))
 538                                 enabled_chan[idx] = TRUE;
 539                         break;
 540                 case SR_CHANNEL_LOGIC:
 541                         idx = ch->index / 8;
 542                         if (idx < ARRAY_SIZE(enabled_pod))
 543                                 enabled_pod[idx] = TRUE;
 544                         break;
 545                 default:
 546                         return SR_ERR;
 547                 }
 548         }
 549
 550         /*
 551          * Check for resource conflicts. Some channels can be either
 552          * analog or digital, but never both at the same time.
 553          *
 554          * Note that the constraints might depend on the specific model.
 555          * These tests might need some adjustment when support for more
 556          * models gets added to the driver.
 557          */
 558         if (enabled_pod[0] && enabled_chan[2])
 559                 return SR_ERR;
 560         if (enabled_pod[1] && enabled_chan[3])
 561                 return SR_ERR;
 562         return SR_OK;
 563 }
 564
 565 static int hmo_setup_channels(const struct sr_dev_inst *sdi)
 566 {
 567         GSList *l;
 568         unsigned int i;
 569         gboolean *pod_enabled, setup_changed;
 570         char command[MAX_COMMAND_SIZE];
 571         struct scope_state *state;
 572         const struct scope_config *model;
 573         struct sr_channel *ch;
 574         struct dev_context *devc;
 575         struct sr_scpi_dev_inst *scpi;
 576
 577         devc = sdi->priv;
 578         scpi = sdi->conn;
 579         state = devc->model_state;
 580         model = devc->model_config;
 581         setup_changed = FALSE;
 582
 583         pod_enabled = g_try_malloc0(sizeof(gboolean) * model->digital_pods);
 584
 585         for (l = sdi->channels; l; l = l->next) {
 586                 ch = l->data;
 587                 switch (ch->type) {
 588                 case SR_CHANNEL_ANALOG:
 589                         if (ch->enabled == state->analog_channels[ch->index].state)
 590                                 break;
 591                         g_snprintf(command, sizeof(command),
 592                                    (*model->scpi_dialect)[SCPI_CMD_SET_ANALOG_CHAN_STATE],
 593                                    ch->index + 1, ch->enabled);
 594
 595                         if (sr_scpi_send(scpi, command) != SR_OK)
 596                                 return SR_ERR;
 597                         state->analog_channels[ch->index].state = ch->enabled;
 598                         setup_changed = TRUE;
 599                         break;
 600                 case SR_CHANNEL_LOGIC:
 601                         /*
 602                          * A digital POD needs to be enabled for every group of
 603                          * 8 channels.
 604                          */
 605                         if (ch->enabled)
 606                                 pod_enabled[ch->index < 8 ? 0 : 1] = TRUE;
 607
 608                         if (ch->enabled == state->digital_channels[ch->index])
 609                                 break;
 610                         g_snprintf(command, sizeof(command),
 611                                    (*model->scpi_dialect)[SCPI_CMD_SET_DIG_CHAN_STATE],
 612                                    ch->index, ch->enabled);
 613
 614                         if (sr_scpi_send(scpi, command) != SR_OK)
 615                                 return SR_ERR;
 616
 617                         state->digital_channels[ch->index] = ch->enabled;
 618                         setup_changed = TRUE;
 619                         break;
 620                 default:
 621                         return SR_ERR;
 622                 }
 623         }
 624
 625         for (i = 1; i <= model->digital_pods; i++) {
 626                 if (state->digital_pods[i - 1] == pod_enabled[i - 1])
 627                         continue;
 628                 g_snprintf(command, sizeof(command),
 629                            (*model->scpi_dialect)[SCPI_CMD_SET_DIG_POD_STATE],
 630                            i, pod_enabled[i - 1]);
 631                 if (sr_scpi_send(scpi, command) != SR_OK)
 632                         return SR_ERR;
 633                 state->digital_pods[i - 1] = pod_enabled[i - 1];
 634                 setup_changed = TRUE;
 635         }
 636
 637         g_free(pod_enabled);
 638
 639         if (setup_changed && hmo_update_sample_rate(sdi) != SR_OK)
 640                 return SR_ERR;
 641
 642         return SR_OK;
 643 }
 644
 645 static int dev_acquisition_start(const struct sr_dev_inst *sdi)
 646 {
 647         GSList *l;
 648         gboolean digital_added[MAX_DIGITAL_GROUP_COUNT];
 649         size_t group, pod_count;
 650         struct sr_channel *ch;
 651         struct dev_context *devc;
 652         struct sr_scpi_dev_inst *scpi;
 653         int ret;
 654
 655         scpi = sdi->conn;
 656         devc = sdi->priv;
 657
 658         /* Preset empty results. */
 659         for (group = 0; group < ARRAY_SIZE(digital_added); group++)
 660                 digital_added[group] = FALSE;
 661         g_slist_free(devc->enabled_channels);
 662         devc->enabled_channels = NULL;
 663
 664         /*
 665          * Contruct the list of enabled channels. Determine the highest
 666          * number of digital pods involved in the acquisition.
 667          */
 668         pod_count = 0;
 669         for (l = sdi->channels; l; l = l->next) {
 670                 ch = l->data;
 671                 if (!ch->enabled)
 672                         continue;
 673                 /* Only add a single digital channel per group (pod). */
 674                 group = ch->index / 8;
 675                 if (ch->type != SR_CHANNEL_LOGIC || !digital_added[group]) {
 676                         devc->enabled_channels = g_slist_append(
 677                                         devc->enabled_channels, ch);
 678                         if (ch->type == SR_CHANNEL_LOGIC) {
 679                                 digital_added[group] = TRUE;
 680                                 if (pod_count < group + 1)
 681                                         pod_count = group + 1;
 682                         }
 683                 }
 684         }
 685         if (!devc->enabled_channels)
 686                 return SR_ERR;
 687         devc->pod_count = pod_count;
 688         devc->logic_data = NULL;
 689
 690         /*
 691          * Check constraints. Some channels can be either analog or
 692          * digital, but not both at the same time.
 693          */
 694         if (hmo_check_channels(devc->enabled_channels) != SR_OK) {
 695                 sr_err("Invalid channel configuration specified!");
 696                 ret = SR_ERR_NA;
 697                 goto free_enabled;
 698         }
 699
 700         /*
 701          * Configure the analog and digital channels and the
 702          * corresponding digital pods.
 703          */
 704         if (hmo_setup_channels(sdi) != SR_OK) {
 705                 sr_err("Failed to setup channel configuration!");
 706                 ret = SR_ERR;
 707                 goto free_enabled;
 708         }
 709
 710         /*
 711          * Start acquisition on the first enabled channel. The
 712          * receive routine will continue driving the acquisition.
 713          */
 714         sr_scpi_source_add(sdi->session, scpi, G_IO_IN, 50,
 715                         hmo_receive_data, (void *)sdi);
 716
 717         std_session_send_df_header(sdi);
 718
 719         devc->current_channel = devc->enabled_channels;
 720
 721         return hmo_request_data(sdi);
 722
 723 free_enabled:
 724         g_slist_free(devc->enabled_channels);
 725         devc->enabled_channels = NULL;
 726         return ret;
 727 }
 728
 729 static int dev_acquisition_stop(struct sr_dev_inst *sdi)
 730 {
 731         struct dev_context *devc;
 732         struct sr_scpi_dev_inst *scpi;
 733
 734         std_session_send_df_end(sdi);
 735
 736         devc = sdi->priv;
 737
 738         devc->num_frames = 0;
 739         g_slist_free(devc->enabled_channels);
 740         devc->enabled_channels = NULL;
 741         scpi = sdi->conn;
 742         sr_scpi_source_remove(sdi->session, scpi);
 743
 744         return SR_OK;
 745 }
 746
 747 static struct sr_dev_driver hameg_hmo_driver_info = {
 748         .name = "hameg-hmo",
 749         .longname = "Hameg HMO",
 750         .api_version = 1,
 751         .init = std_init,
 752         .cleanup = std_cleanup,
 753         .scan = scan,
 754         .dev_list = std_dev_list,
 755         .dev_clear = dev_clear,
 756         .config_get = config_get,
 757         .config_set = config_set,
 758         .config_list = config_list,
 759         .dev_open = dev_open,
 760         .dev_close = dev_close,
 761         .dev_acquisition_start = dev_acquisition_start,
 762         .dev_acquisition_stop = dev_acquisition_stop,
 763         .context = NULL,
 764 };
 765 SR_REGISTER_DEV_DRIVER(hameg_hmo_driver_info);