src/hardware/hameg-hmo/protocol.c

   1 /*
   2  * This file is part of the libsigrok project.
   3  *
   4  * Copyright (C) 2013 poljar (Damir Jelić) <poljarinho@gmail.com>
   5  * Copyright (C) 2018 Guido Trentalancia <guido@trentalancia.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 <config.h>
  22 #include <math.h>
  23 #include <stdlib.h>
  24 #include "scpi.h"
  25 #include "protocol.h"
  26
  27 SR_PRIV void hmo_queue_logic_data(struct dev_context *devc,
  28                                   size_t group, GByteArray *pod_data);
  29 SR_PRIV void hmo_send_logic_packet(struct sr_dev_inst *sdi,
  30                                    struct dev_context *devc);
  31 SR_PRIV void hmo_cleanup_logic_data(struct dev_context *devc);
  32
  33 static const char *hameg_scpi_dialect[] = {
  34         [SCPI_CMD_GET_DIG_DATA]               = ":FORM UINT,8;:POD%d:DATA?",
  35         [SCPI_CMD_GET_TIMEBASE]               = ":TIM:SCAL?",
  36         [SCPI_CMD_SET_TIMEBASE]               = ":TIM:SCAL %s",
  37         [SCPI_CMD_GET_COUPLING]               = ":CHAN%d:COUP?",
  38         [SCPI_CMD_SET_COUPLING]               = ":CHAN%d:COUP %s",
  39         [SCPI_CMD_GET_SAMPLE_RATE]            = ":ACQ:SRAT?",
  40         [SCPI_CMD_GET_SAMPLE_RATE_LIVE]       = ":%s:DATA:POINTS?",
  41         [SCPI_CMD_GET_ANALOG_DATA]            = ":FORM:BORD %s;" \
  42                                                 ":FORM REAL,32;:CHAN%d:DATA?",
  43         [SCPI_CMD_GET_VERTICAL_DIV]           = ":CHAN%d:SCAL?",
  44         [SCPI_CMD_SET_VERTICAL_DIV]           = ":CHAN%d:SCAL %s",
  45         [SCPI_CMD_GET_DIG_POD_STATE]          = ":POD%d:STAT?",
  46         [SCPI_CMD_SET_DIG_POD_STATE]          = ":POD%d:STAT %d",
  47         [SCPI_CMD_GET_TRIGGER_SLOPE]          = ":TRIG:A:EDGE:SLOP?",
  48         [SCPI_CMD_SET_TRIGGER_SLOPE]          = ":TRIG:A:TYPE EDGE;:TRIG:A:EDGE:SLOP %s",
  49         [SCPI_CMD_GET_TRIGGER_SOURCE]         = ":TRIG:A:SOUR?",
  50         [SCPI_CMD_SET_TRIGGER_SOURCE]         = ":TRIG:A:SOUR %s",
  51         [SCPI_CMD_GET_DIG_CHAN_STATE]         = ":LOG%d:STAT?",
  52         [SCPI_CMD_SET_DIG_CHAN_STATE]         = ":LOG%d:STAT %d",
  53         [SCPI_CMD_GET_VERTICAL_OFFSET]        = ":CHAN%d:POS?",
  54         [SCPI_CMD_GET_HORIZ_TRIGGERPOS]       = ":TIM:POS?",
  55         [SCPI_CMD_SET_HORIZ_TRIGGERPOS]       = ":TIM:POS %s",
  56         [SCPI_CMD_GET_ANALOG_CHAN_STATE]      = ":CHAN%d:STAT?",
  57         [SCPI_CMD_SET_ANALOG_CHAN_STATE]      = ":CHAN%d:STAT %d",
  58         [SCPI_CMD_GET_PROBE_UNIT]             = ":PROB%d:SET:ATT:UNIT?",
  59         [SCPI_CMD_GET_DIG_POD_THRESHOLD]      = ":POD%d:THR?",
  60         [SCPI_CMD_SET_DIG_POD_THRESHOLD]      = ":POD%d:THR %s",
  61         [SCPI_CMD_GET_DIG_POD_USER_THRESHOLD] = ":POD%d:THR:UDL%d?",
  62         [SCPI_CMD_SET_DIG_POD_USER_THRESHOLD] = ":POD%d:THR:UDL%d %s",
  63 };
  64
  65 static const uint32_t devopts[] = {
  66         SR_CONF_OSCILLOSCOPE,
  67         SR_CONF_LIMIT_SAMPLES | SR_CONF_GET | SR_CONF_SET,
  68         SR_CONF_LIMIT_FRAMES | SR_CONF_GET | SR_CONF_SET,
  69         SR_CONF_SAMPLERATE | SR_CONF_GET,
  70         SR_CONF_TIMEBASE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  71         SR_CONF_NUM_HDIV | SR_CONF_GET,
  72         SR_CONF_HORIZ_TRIGGERPOS | SR_CONF_GET | SR_CONF_SET,
  73         SR_CONF_TRIGGER_SOURCE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  74         SR_CONF_TRIGGER_SLOPE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  75 };
  76
  77 static const uint32_t devopts_cg_analog[] = {
  78         SR_CONF_NUM_VDIV | SR_CONF_GET,
  79         SR_CONF_VDIV | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  80         SR_CONF_COUPLING | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  81 };
  82
  83 static const uint32_t devopts_cg_digital[] = {
  84         SR_CONF_LOGIC_THRESHOLD | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  85         SR_CONF_LOGIC_THRESHOLD_CUSTOM | SR_CONF_GET | SR_CONF_SET,
  86 };
  87
  88 static const char *coupling_options[] = {
  89         "AC",  // AC with 50 Ohm termination (152x, 202x, 30xx, 1202)
  90         "ACL", // AC with 1 MOhm termination
  91         "DC",  // DC with 50 Ohm termination
  92         "DCL", // DC with 1 MOhm termination
  93         "GND",
  94 };
  95
  96 static const char *scope_trigger_slopes[] = {
  97         "POS",
  98         "NEG",
  99         "EITH",
 100 };
 101
 102 /* Predefined logic thresholds. */
 103 static const char *logic_threshold[] = {
 104         "TTL",
 105         "ECL",
 106         "CMOS",
 107         "USER1",
 108         "USER2", // overwritten by logic_threshold_custom, use USER1 for permanent setting
 109 };
 110
 111 /* RTC1002, HMO Compact2 and HMO1002/HMO1202 */
 112 static const char *an2_dig8_trigger_sources[] = {
 113         "CH1", "CH2",
 114         "LINE", "EXT", "PATT", "BUS1", "BUS2",
 115         "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
 116 };
 117
 118 /* HMO3xx2 */
 119 static const char *an2_dig16_trigger_sources[] = {
 120         "CH1", "CH2",
 121         "LINE", "EXT", "PATT", "BUS1", "BUS2",
 122         "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
 123         "D8", "D9", "D10", "D11", "D12", "D13", "D14", "D15",
 124 };
 125
 126 /* HMO Compact4 */
 127 static const char *an4_dig8_trigger_sources[] = {
 128         "CH1", "CH2", "CH3", "CH4",
 129         "LINE", "EXT", "PATT", "BUS1", "BUS2",
 130         "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
 131 };
 132
 133 /* HMO3xx4 and HMO2524 */
 134 static const char *an4_dig16_trigger_sources[] = {
 135         "CH1", "CH2", "CH3", "CH4",
 136         "LINE", "EXT", "PATT", "BUS1", "BUS2",
 137         "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
 138         "D8", "D9", "D10", "D11", "D12", "D13", "D14", "D15",
 139 };
 140
 141 static const uint64_t timebases[][2] = {
 142         /* nanoseconds */
 143         { 2, 1000000000 },
 144         { 5, 1000000000 },
 145         { 10, 1000000000 },
 146         { 20, 1000000000 },
 147         { 50, 1000000000 },
 148         { 100, 1000000000 },
 149         { 200, 1000000000 },
 150         { 500, 1000000000 },
 151         /* microseconds */
 152         { 1, 1000000 },
 153         { 2, 1000000 },
 154         { 5, 1000000 },
 155         { 10, 1000000 },
 156         { 20, 1000000 },
 157         { 50, 1000000 },
 158         { 100, 1000000 },
 159         { 200, 1000000 },
 160         { 500, 1000000 },
 161         /* milliseconds */
 162         { 1, 1000 },
 163         { 2, 1000 },
 164         { 5, 1000 },
 165         { 10, 1000 },
 166         { 20, 1000 },
 167         { 50, 1000 },
 168         { 100, 1000 },
 169         { 200, 1000 },
 170         { 500, 1000 },
 171         /* seconds */
 172         { 1, 1 },
 173         { 2, 1 },
 174         { 5, 1 },
 175         { 10, 1 },
 176         { 20, 1 },
 177         { 50, 1 },
 178 };
 179
 180 static const uint64_t vdivs[][2] = {
 181         /* millivolts */
 182         { 1, 1000 },
 183         { 2, 1000 },
 184         { 5, 1000 },
 185         { 10, 1000 },
 186         { 20, 1000 },
 187         { 50, 1000 },
 188         { 100, 1000 },
 189         { 200, 1000 },
 190         { 500, 1000 },
 191         /* volts */
 192         { 1, 1 },
 193         { 2, 1 },
 194         { 5, 1 },
 195         { 10, 1 },
 196         { 20, 1 },
 197         { 50, 1 },
 198 };
 199
 200 static const char *scope_analog_channel_names[] = {
 201         "CH1", "CH2", "CH3", "CH4",
 202 };
 203
 204 static const char *scope_digital_channel_names[] = {
 205         "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
 206         "D8", "D9", "D10", "D11", "D12", "D13", "D14", "D15",
 207 };
 208
 209 static const struct scope_config scope_models[] = {
 210         {
 211                 /* RTC1002 and HMO722/1002/1022/1202/1522/2022 support only 8 digital channels. */
 212                 .name = {"RTC1002", "HMO722", "HMO1002", "HMO1022", "HMO1202", "HMO1522", "HMO2022", NULL},
 213                 .analog_channels = 2,
 214                 .digital_channels = 8,
 215                 .digital_pods = 1,
 216
 217                 .analog_names = &scope_analog_channel_names,
 218                 .digital_names = &scope_digital_channel_names,
 219
 220                 .devopts = &devopts,
 221                 .num_devopts = ARRAY_SIZE(devopts),
 222
 223                 .devopts_cg_analog = &devopts_cg_analog,
 224                 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
 225
 226                 .devopts_cg_digital = &devopts_cg_digital,
 227                 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
 228
 229                 .coupling_options = &coupling_options,
 230                 .num_coupling_options = ARRAY_SIZE(coupling_options),
 231
 232                 .logic_threshold = &logic_threshold,
 233                 .num_logic_threshold = ARRAY_SIZE(logic_threshold),
 234
 235                 .trigger_sources = &an2_dig8_trigger_sources,
 236                 .num_trigger_sources = ARRAY_SIZE(an2_dig8_trigger_sources),
 237
 238                 .trigger_slopes = &scope_trigger_slopes,
 239                 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
 240
 241                 .timebases = &timebases,
 242                 .num_timebases = ARRAY_SIZE(timebases),
 243
 244                 .vdivs = &vdivs,
 245                 .num_vdivs = ARRAY_SIZE(vdivs),
 246
 247                 .num_xdivs = 12,
 248                 .num_ydivs = 8,
 249
 250                 .scpi_dialect = &hameg_scpi_dialect,
 251         },
 252         {
 253                 /* HMO3032/3042/3052/3522 support 16 digital channels. */
 254                 .name = {"HMO3032", "HMO3042", "HMO3052", "HMO3522", NULL},
 255                 .analog_channels = 2,
 256                 .digital_channels = 16,
 257                 .digital_pods = 2,
 258
 259                 .analog_names = &scope_analog_channel_names,
 260                 .digital_names = &scope_digital_channel_names,
 261
 262                 .devopts = &devopts,
 263                 .num_devopts = ARRAY_SIZE(devopts),
 264
 265                 .devopts_cg_analog = &devopts_cg_analog,
 266                 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
 267
 268                 .devopts_cg_digital = &devopts_cg_digital,
 269                 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
 270
 271                 .coupling_options = &coupling_options,
 272                 .num_coupling_options = ARRAY_SIZE(coupling_options),
 273
 274                 .logic_threshold = &logic_threshold,
 275                 .num_logic_threshold = ARRAY_SIZE(logic_threshold),
 276
 277                 .trigger_sources = &an2_dig16_trigger_sources,
 278                 .num_trigger_sources = ARRAY_SIZE(an2_dig16_trigger_sources),
 279
 280                 .trigger_slopes = &scope_trigger_slopes,
 281                 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
 282
 283                 .timebases = &timebases,
 284                 .num_timebases = ARRAY_SIZE(timebases),
 285
 286                 .vdivs = &vdivs,
 287                 .num_vdivs = ARRAY_SIZE(vdivs),
 288
 289                 .num_xdivs = 12,
 290                 .num_ydivs = 8,
 291
 292                 .scpi_dialect = &hameg_scpi_dialect,
 293         },
 294         {
 295                 .name = {"HMO724", "HMO1024", "HMO1524", "HMO2024", NULL},
 296                 .analog_channels = 4,
 297                 .digital_channels = 8,
 298                 .digital_pods = 1,
 299
 300                 .analog_names = &scope_analog_channel_names,
 301                 .digital_names = &scope_digital_channel_names,
 302
 303                 .devopts = &devopts,
 304                 .num_devopts = ARRAY_SIZE(devopts),
 305
 306                 .devopts_cg_analog = &devopts_cg_analog,
 307                 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
 308
 309                 .devopts_cg_digital = &devopts_cg_digital,
 310                 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
 311
 312                 .coupling_options = &coupling_options,
 313                 .num_coupling_options = ARRAY_SIZE(coupling_options),
 314
 315                 .logic_threshold = &logic_threshold,
 316                 .num_logic_threshold = ARRAY_SIZE(logic_threshold),
 317
 318                 .trigger_sources = &an4_dig8_trigger_sources,
 319                 .num_trigger_sources = ARRAY_SIZE(an4_dig8_trigger_sources),
 320
 321                 .trigger_slopes = &scope_trigger_slopes,
 322                 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
 323
 324                 .timebases = &timebases,
 325                 .num_timebases = ARRAY_SIZE(timebases),
 326
 327                 .vdivs = &vdivs,
 328                 .num_vdivs = ARRAY_SIZE(vdivs),
 329
 330                 .num_xdivs = 12,
 331                 .num_ydivs = 8,
 332
 333                 .scpi_dialect = &hameg_scpi_dialect,
 334         },
 335         {
 336                 .name = {"HMO2524", "HMO3034", "HMO3044", "HMO3054", "HMO3524", NULL},
 337                 .analog_channels = 4,
 338                 .digital_channels = 16,
 339                 .digital_pods = 2,
 340
 341                 .analog_names = &scope_analog_channel_names,
 342                 .digital_names = &scope_digital_channel_names,
 343
 344                 .devopts = &devopts,
 345                 .num_devopts = ARRAY_SIZE(devopts),
 346
 347                 .devopts_cg_analog = &devopts_cg_analog,
 348                 .num_devopts_cg_analog = ARRAY_SIZE(devopts_cg_analog),
 349
 350                 .devopts_cg_digital = &devopts_cg_digital,
 351                 .num_devopts_cg_digital = ARRAY_SIZE(devopts_cg_digital),
 352
 353                 .coupling_options = &coupling_options,
 354                 .num_coupling_options = ARRAY_SIZE(coupling_options),
 355
 356                 .logic_threshold = &logic_threshold,
 357                 .num_logic_threshold = ARRAY_SIZE(logic_threshold),
 358
 359                 .trigger_sources = &an4_dig16_trigger_sources,
 360                 .num_trigger_sources = ARRAY_SIZE(an4_dig16_trigger_sources),
 361
 362                 .trigger_slopes = &scope_trigger_slopes,
 363                 .num_trigger_slopes = ARRAY_SIZE(scope_trigger_slopes),
 364
 365                 .timebases = &timebases,
 366                 .num_timebases = ARRAY_SIZE(timebases),
 367
 368                 .vdivs = &vdivs,
 369                 .num_vdivs = ARRAY_SIZE(vdivs),
 370
 371                 .num_xdivs = 12,
 372                 .num_ydivs = 8,
 373
 374                 .scpi_dialect = &hameg_scpi_dialect,
 375         },
 376 };
 377
 378 static void scope_state_dump(const struct scope_config *config,
 379                              struct scope_state *state)
 380 {
 381         unsigned int i;
 382         char *tmp;
 383
 384         for (i = 0; i < config->analog_channels; i++) {
 385                 tmp = sr_voltage_string((*config->vdivs)[state->analog_channels[i].vdiv][0],
 386                                              (*config->vdivs)[state->analog_channels[i].vdiv][1]);
 387                 sr_info("State of analog channel %d -> %s : %s (coupling) %s (vdiv) %2.2e (offset)",
 388                         i + 1, state->analog_channels[i].state ? "On" : "Off",
 389                         (*config->coupling_options)[state->analog_channels[i].coupling],
 390                         tmp, state->analog_channels[i].vertical_offset);
 391         }
 392
 393         for (i = 0; i < config->digital_channels; i++) {
 394                 sr_info("State of digital channel %d -> %s", i,
 395                         state->digital_channels[i] ? "On" : "Off");
 396         }
 397
 398         for (i = 0; i < config->digital_pods; i++) {
 399                 if (strncmp("USER", (*config->logic_threshold)[state->digital_pods[i].threshold], 4))
 400                         sr_info("State of digital POD %d -> %s : %s (threshold)", i,
 401                                 state->digital_pods[i].state ? "On" : "Off",
 402                                 (*config->logic_threshold)[state->digital_pods[i].threshold]);
 403                 else // user-defined or custom logic threshold
 404                         sr_info("State of digital POD %d -> %s : %E (threshold)", i,
 405                                 state->digital_pods[i].state ? "On" : "Off",
 406                                 state->digital_pods[i].user_threshold);
 407         }
 408
 409         tmp = sr_period_string((*config->timebases)[state->timebase][0],
 410                                (*config->timebases)[state->timebase][1]);
 411         sr_info("Current timebase: %s", tmp);
 412         g_free(tmp);
 413
 414         tmp = sr_samplerate_string(state->sample_rate);
 415         sr_info("Current samplerate: %s", tmp);
 416         g_free(tmp);
 417
 418         sr_info("Current trigger: %s (source), %s (slope) %.2f (offset)",
 419                 (*config->trigger_sources)[state->trigger_source],
 420                 (*config->trigger_slopes)[state->trigger_slope],
 421                 state->horiz_triggerpos);
 422 }
 423
 424 static int scope_state_get_array_option(struct sr_scpi_dev_inst *scpi,
 425                 const char *command, const char *(*array)[], unsigned int n, int *result)
 426 {
 427         char *tmp;
 428         int idx;
 429
 430         if (sr_scpi_get_string(scpi, command, &tmp) != SR_OK) {
 431                 g_free(tmp);
 432                 return SR_ERR;
 433         }
 434
 435         if ((idx = std_str_idx_s(tmp, *array, n)) < 0) {
 436                 g_free(tmp);
 437                 return SR_ERR_ARG;
 438         }
 439
 440         *result = idx;
 441
 442         g_free(tmp);
 443
 444         return SR_OK;
 445 }
 446
 447 /**
 448  * This function takes a value of the form "2.000E-03" and returns the index
 449  * of an array where a matching pair was found.
 450  *
 451  * @param value The string to be parsed.
 452  * @param array The array of s/f pairs.
 453  * @param array_len The number of pairs in the array.
 454  * @param result The index at which a matching pair was found.
 455  *
 456  * @return SR_ERR on any parsing error, SR_OK otherwise.
 457  */
 458 static int array_float_get(gchar *value, const uint64_t array[][2],
 459                 int array_len, unsigned int *result)
 460 {
 461         struct sr_rational rval;
 462         struct sr_rational aval;
 463
 464         if (sr_parse_rational(value, &rval) != SR_OK)
 465                 return SR_ERR;
 466
 467         for (int i = 0; i < array_len; i++) {
 468                 sr_rational_set(&aval, array[i][0], array[i][1]);
 469                 if (sr_rational_eq(&rval, &aval)) {
 470                         *result = i;
 471                         return SR_OK;
 472                 }
 473         }
 474
 475         return SR_ERR;
 476 }
 477
 478 static struct sr_channel *get_channel_by_index_and_type(GSList *channel_lhead,
 479                                                         int index, int type)
 480 {
 481         while (channel_lhead) {
 482                 struct sr_channel *ch = channel_lhead->data;
 483                 if (ch->index == index && ch->type == type)
 484                         return ch;
 485
 486                 channel_lhead = channel_lhead->next;
 487         }
 488
 489         return 0;
 490 }
 491
 492 static int analog_channel_state_get(struct sr_dev_inst *sdi,
 493                                     const struct scope_config *config,
 494                                     struct scope_state *state)
 495 {
 496         unsigned int i, j;
 497         char command[MAX_COMMAND_SIZE];
 498         char *tmp_str;
 499         struct sr_channel *ch;
 500         struct sr_scpi_dev_inst *scpi = sdi->conn;
 501
 502         for (i = 0; i < config->analog_channels; i++) {
 503                 g_snprintf(command, sizeof(command),
 504                            (*config->scpi_dialect)[SCPI_CMD_GET_ANALOG_CHAN_STATE],
 505                            i + 1);
 506
 507                 if (sr_scpi_get_bool(scpi, command,
 508                                      &state->analog_channels[i].state) != SR_OK)
 509                         return SR_ERR;
 510
 511                 ch = get_channel_by_index_and_type(sdi->channels, i, SR_CHANNEL_ANALOG);
 512                 if (ch)
 513                         ch->enabled = state->analog_channels[i].state;
 514
 515                 g_snprintf(command, sizeof(command),
 516                            (*config->scpi_dialect)[SCPI_CMD_GET_VERTICAL_DIV],
 517                            i + 1);
 518
 519                 if (sr_scpi_get_string(scpi, command, &tmp_str) != SR_OK)
 520                         return SR_ERR;
 521
 522                 if (array_float_get(tmp_str, ARRAY_AND_SIZE(vdivs), &j) != SR_OK) {
 523                         g_free(tmp_str);
 524                         sr_err("Could not determine array index for vertical div scale.");
 525                         return SR_ERR;
 526                 }
 527
 528                 g_free(tmp_str);
 529                 state->analog_channels[i].vdiv = j;
 530
 531                 g_snprintf(command, sizeof(command),
 532                            (*config->scpi_dialect)[SCPI_CMD_GET_VERTICAL_OFFSET],
 533                            i + 1);
 534
 535                 if (sr_scpi_get_float(scpi, command,
 536                                      &state->analog_channels[i].vertical_offset) != SR_OK)
 537                         return SR_ERR;
 538
 539                 g_snprintf(command, sizeof(command),
 540                            (*config->scpi_dialect)[SCPI_CMD_GET_COUPLING],
 541                            i + 1);
 542
 543                 if (scope_state_get_array_option(scpi, command, config->coupling_options,
 544                                          config->num_coupling_options,
 545                                          &state->analog_channels[i].coupling) != SR_OK)
 546                         return SR_ERR;
 547
 548                 g_snprintf(command, sizeof(command),
 549                            (*config->scpi_dialect)[SCPI_CMD_GET_PROBE_UNIT],
 550                            i + 1);
 551
 552                 if (sr_scpi_get_string(scpi, command, &tmp_str) != SR_OK)
 553                         return SR_ERR;
 554
 555                 if (tmp_str[0] == 'A')
 556                         state->analog_channels[i].probe_unit = 'A';
 557                 else
 558                         state->analog_channels[i].probe_unit = 'V';
 559                 g_free(tmp_str);
 560         }
 561
 562         return SR_OK;
 563 }
 564
 565 static int digital_channel_state_get(struct sr_dev_inst *sdi,
 566                                      const struct scope_config *config,
 567                                      struct scope_state *state)
 568 {
 569         unsigned int i;
 570         int result = SR_ERR;
 571         static char *logic_threshold_short[] = {};
 572         char command[MAX_COMMAND_SIZE];
 573         struct sr_channel *ch;
 574         struct sr_scpi_dev_inst *scpi = sdi->conn;
 575
 576         for (i = 0; i < config->digital_channels; i++) {
 577                 g_snprintf(command, sizeof(command),
 578                            (*config->scpi_dialect)[SCPI_CMD_GET_DIG_CHAN_STATE],
 579                            i);
 580
 581                 if (sr_scpi_get_bool(scpi, command,
 582                                      &state->digital_channels[i]) != SR_OK)
 583                         return SR_ERR;
 584
 585                 ch = get_channel_by_index_and_type(sdi->channels, i, SR_CHANNEL_LOGIC);
 586                 if (ch)
 587                         ch->enabled = state->digital_channels[i];
 588         }
 589
 590         /* According to the SCPI standard, the response to the command
 591          * SCPI_CMD_GET_DIG_POD_THRESHOLD might return "USER" instead of
 592          * "USER1".
 593          *
 594          * This makes more difficult to validate the response when the logic
 595          * threshold is set to "USER1" and therefore we need to prevent device
 596          * opening failures in such configuration case...
 597          */
 598         for (i = 0; i < config->num_logic_threshold; i++) {
 599                 logic_threshold_short[i] = g_strdup((*config->logic_threshold)[i]);
 600                 if (!strcmp("USER1", (*config->logic_threshold)[i]))
 601                         g_strlcpy(logic_threshold_short[i],
 602                                   (*config->logic_threshold)[i], strlen((*config->logic_threshold)[i]));
 603         }
 604
 605         for (i = 0; i < config->digital_pods; i++) {
 606                 g_snprintf(command, sizeof(command),
 607                            (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_STATE],
 608                            i + 1);
 609
 610                 if (sr_scpi_get_bool(scpi, command,
 611                                      &state->digital_pods[i].state) != SR_OK)
 612                         goto exit;
 613
 614                 g_snprintf(command, sizeof(command),
 615                            (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_THRESHOLD],
 616                            i + 1);
 617
 618                 /* Check for both standard and shortened responses. */
 619                 if (scope_state_get_array_option(scpi, command, config->logic_threshold,
 620                                                  config->num_logic_threshold,
 621                                                  &state->digital_pods[i].threshold) != SR_OK)
 622                         if (scope_state_get_array_option(scpi, command, (const char * (*)[]) &logic_threshold_short,
 623                                                          config->num_logic_threshold,
 624                                                          &state->digital_pods[i].threshold) != SR_OK)
 625                                 goto exit;
 626
 627                 if (!strcmp("USER1", (*config->logic_threshold)[state->digital_pods[i].threshold]))
 628                         g_snprintf(command, sizeof(command),
 629                                    (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_USER_THRESHOLD],
 630                                    i + 1, 1); // USER1 logic threshold setting
 631
 632                 if (!strcmp("USER2", (*config->logic_threshold)[state->digital_pods[i].threshold]))
 633                         g_snprintf(command, sizeof(command),
 634                                    (*config->scpi_dialect)[SCPI_CMD_GET_DIG_POD_USER_THRESHOLD],
 635                                    i + 1, 2); // USER2 for custom logic_threshold setting
 636
 637                 if (!strcmp("USER1", (*config->logic_threshold)[state->digital_pods[i].threshold]) ||
 638                     !strcmp("USER2", (*config->logic_threshold)[state->digital_pods[i].threshold]))
 639                         if (sr_scpi_get_float(scpi, command,
 640                             &state->digital_pods[i].user_threshold) != SR_OK)
 641                                 goto exit;
 642         }
 643
 644         result = SR_OK;
 645
 646 exit:
 647         for (i = 0; i < config->num_logic_threshold; i++)
 648                 g_free(logic_threshold_short[i]);
 649
 650         return result;
 651 }
 652
 653 SR_PRIV int hmo_update_sample_rate(const struct sr_dev_inst *sdi)
 654 {
 655         struct dev_context *devc;
 656         struct scope_state *state;
 657         const struct scope_config *config;
 658         int tmp;
 659         unsigned int i;
 660         float tmp_float;
 661         gboolean channel_found;
 662         char tmp_str[MAX_COMMAND_SIZE];
 663         char chan_name[20];
 664
 665         devc = sdi->priv;
 666         config = devc->model_config;
 667         state = devc->model_state;
 668         channel_found = FALSE;
 669
 670         for (i = 0; i < config->analog_channels; i++) {
 671                 if (!state->analog_channels[i].state)
 672                         continue;
 673                 g_snprintf(chan_name, sizeof(chan_name), "CHAN%d", i + 1);
 674                 g_snprintf(tmp_str, sizeof(tmp_str),
 675                            (*config->scpi_dialect)[SCPI_CMD_GET_SAMPLE_RATE_LIVE],
 676                            chan_name);
 677                 channel_found = TRUE;
 678                 break;
 679         }
 680
 681         if (!channel_found) {
 682                 for (i = 0; i < config->digital_pods; i++) {
 683                         if (!state->digital_pods[i].state)
 684                                 continue;
 685                         g_snprintf(chan_name, sizeof(chan_name), "POD%d", i);
 686                         g_snprintf(tmp_str, sizeof(tmp_str),
 687                                    (*config->scpi_dialect)[SCPI_CMD_GET_SAMPLE_RATE_LIVE],
 688                                    chan_name);
 689                         channel_found = TRUE;
 690                         break;
 691                 }
 692         }
 693
 694         /* No channel is active, ask the instrument for the sample rate
 695          * in single shot mode */
 696         if (!channel_found) {
 697                 if (sr_scpi_get_float(sdi->conn,
 698                                       (*config->scpi_dialect)[SCPI_CMD_GET_SAMPLE_RATE],
 699                                       &tmp_float) != SR_OK)
 700                         return SR_ERR;
 701
 702                 state->sample_rate = tmp_float;
 703         } else {
 704                 if (sr_scpi_get_int(sdi->conn, tmp_str, &tmp) != SR_OK)
 705                         return SR_ERR;
 706                 state->sample_rate = tmp / (((float) (*config->timebases)[state->timebase][0] /
 707                                              (*config->timebases)[state->timebase][1]) *
 708                                             config->num_xdivs);
 709         }
 710
 711         return SR_OK;
 712 }
 713
 714 SR_PRIV int hmo_scope_state_get(struct sr_dev_inst *sdi)
 715 {
 716         struct dev_context *devc;
 717         struct scope_state *state;
 718         const struct scope_config *config;
 719         float tmp_float;
 720         unsigned int i;
 721         char *tmp_str;
 722
 723         devc = sdi->priv;
 724         config = devc->model_config;
 725         state = devc->model_state;
 726
 727         sr_info("Fetching scope state");
 728
 729         if (analog_channel_state_get(sdi, config, state) != SR_OK)
 730                 return SR_ERR;
 731
 732         if (digital_channel_state_get(sdi, config, state) != SR_OK)
 733                 return SR_ERR;
 734
 735         if (sr_scpi_get_float(sdi->conn,
 736                         (*config->scpi_dialect)[SCPI_CMD_GET_TIMEBASE],
 737                         &tmp_float) != SR_OK)
 738                 return SR_ERR;
 739
 740         if (sr_scpi_get_string(sdi->conn,
 741                         (*config->scpi_dialect)[SCPI_CMD_GET_TIMEBASE],
 742                         &tmp_str) != SR_OK)
 743                 return SR_ERR;
 744
 745         if (array_float_get(tmp_str, ARRAY_AND_SIZE(timebases), &i) != SR_OK) {
 746                 g_free(tmp_str);
 747                 sr_err("Could not determine array index for time base.");
 748                 return SR_ERR;
 749         }
 750         g_free(tmp_str);
 751
 752         state->timebase = i;
 753
 754         if (sr_scpi_get_float(sdi->conn,
 755                         (*config->scpi_dialect)[SCPI_CMD_GET_HORIZ_TRIGGERPOS],
 756                         &tmp_float) != SR_OK)
 757                 return SR_ERR;
 758         state->horiz_triggerpos = tmp_float /
 759                 (((double) (*config->timebases)[state->timebase][0] /
 760                   (*config->timebases)[state->timebase][1]) * config->num_xdivs);
 761         state->horiz_triggerpos -= 0.5;
 762         state->horiz_triggerpos *= -1;
 763
 764         if (scope_state_get_array_option(sdi->conn,
 765                         (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_SOURCE],
 766                         config->trigger_sources, config->num_trigger_sources,
 767                         &state->trigger_source) != SR_OK)
 768                 return SR_ERR;
 769
 770         if (scope_state_get_array_option(sdi->conn,
 771                         (*config->scpi_dialect)[SCPI_CMD_GET_TRIGGER_SLOPE],
 772                         config->trigger_slopes, config->num_trigger_slopes,
 773                         &state->trigger_slope) != SR_OK)
 774                 return SR_ERR;
 775
 776         if (hmo_update_sample_rate(sdi) != SR_OK)
 777                 return SR_ERR;
 778
 779         sr_info("Fetching finished.");
 780
 781         scope_state_dump(config, state);
 782
 783         return SR_OK;
 784 }
 785
 786 static struct scope_state *scope_state_new(const struct scope_config *config)
 787 {
 788         struct scope_state *state;
 789
 790         state = g_malloc0(sizeof(struct scope_state));
 791         state->analog_channels = g_malloc0_n(config->analog_channels,
 792                         sizeof(struct analog_channel_state));
 793         state->digital_channels = g_malloc0_n(
 794                         config->digital_channels, sizeof(gboolean));
 795         state->digital_pods = g_malloc0_n(config->digital_pods,
 796                         sizeof(struct digital_pod_state));
 797
 798         return state;
 799 }
 800
 801 SR_PRIV void hmo_scope_state_free(struct scope_state *state)
 802 {
 803         g_free(state->analog_channels);
 804         g_free(state->digital_channels);
 805         g_free(state->digital_pods);
 806         g_free(state);
 807 }
 808
 809 SR_PRIV int hmo_init_device(struct sr_dev_inst *sdi)
 810 {
 811         int model_index;
 812         unsigned int i, j, group;
 813         struct sr_channel *ch;
 814         struct dev_context *devc;
 815         int ret;
 816
 817         devc = sdi->priv;
 818         model_index = -1;
 819
 820         /* Find the exact model. */
 821         for (i = 0; i < ARRAY_SIZE(scope_models); i++) {
 822                 for (j = 0; scope_models[i].name[j]; j++) {
 823                         if (!strcmp(sdi->model, scope_models[i].name[j])) {
 824                                 model_index = i;
 825                                 break;
 826                         }
 827                 }
 828                 if (model_index != -1)
 829                         break;
 830         }
 831
 832         if (model_index == -1) {
 833                 sr_dbg("Unsupported device.");
 834                 return SR_ERR_NA;
 835         }
 836
 837         devc->analog_groups = g_malloc0(sizeof(struct sr_channel_group*) *
 838                                         scope_models[model_index].analog_channels);
 839         devc->digital_groups = g_malloc0(sizeof(struct sr_channel_group*) *
 840                                          scope_models[model_index].digital_pods);
 841         if (!devc->analog_groups || !devc->digital_groups) {
 842                 g_free(devc->analog_groups);
 843                 g_free(devc->digital_groups);
 844                 return SR_ERR_MALLOC;
 845         }
 846
 847         /* Add analog channels. */
 848         for (i = 0; i < scope_models[model_index].analog_channels; i++) {
 849                 ch = sr_channel_new(sdi, i, SR_CHANNEL_ANALOG, TRUE,
 850                            (*scope_models[model_index].analog_names)[i]);
 851
 852                 devc->analog_groups[i] = g_malloc0(sizeof(struct sr_channel_group));
 853
 854                 devc->analog_groups[i]->name = g_strdup(
 855                         (char *)(*scope_models[model_index].analog_names)[i]);
 856                 devc->analog_groups[i]->channels = g_slist_append(NULL, ch);
 857
 858                 sdi->channel_groups = g_slist_append(sdi->channel_groups,
 859                                                    devc->analog_groups[i]);
 860         }
 861
 862         /* Add digital channel groups. */
 863         ret = SR_OK;
 864         for (i = 0; i < scope_models[model_index].digital_pods; i++) {
 865                 devc->digital_groups[i] = g_malloc0(sizeof(struct sr_channel_group));
 866                 if (!devc->digital_groups[i]) {
 867                         ret = SR_ERR_MALLOC;
 868                         break;
 869                 }
 870                 devc->digital_groups[i]->name = g_strdup_printf("POD%d", i);
 871                 sdi->channel_groups = g_slist_append(sdi->channel_groups,
 872                                    devc->digital_groups[i]);
 873         }
 874         if (ret != SR_OK)
 875                 return ret;
 876
 877         /* Add digital channels. */
 878         for (i = 0; i < scope_models[model_index].digital_channels; i++) {
 879                 ch = sr_channel_new(sdi, i, SR_CHANNEL_LOGIC, TRUE,
 880                            (*scope_models[model_index].digital_names)[i]);
 881
 882                 group = i / 8;
 883                 devc->digital_groups[group]->channels = g_slist_append(
 884                         devc->digital_groups[group]->channels, ch);
 885         }
 886
 887         devc->model_config = &scope_models[model_index];
 888         devc->samples_limit = 0;
 889         devc->frame_limit = 0;
 890
 891         if (!(devc->model_state = scope_state_new(devc->model_config)))
 892                 return SR_ERR_MALLOC;
 893
 894         return SR_OK;
 895 }
 896
 897 /* Queue data of one channel group, for later submission. */
 898 SR_PRIV void hmo_queue_logic_data(struct dev_context *devc,
 899                                   size_t group, GByteArray *pod_data)
 900 {
 901         size_t size;
 902         GByteArray *store;
 903         uint8_t *logic_data;
 904         size_t idx, logic_step;
 905
 906         /*
 907          * Upon first invocation, allocate the array which can hold the
 908          * combined logic data for all channels. Assume that each channel
 909          * will yield an identical number of samples per receive call.
 910          *
 911          * As a poor man's safety measure: (Silently) skip processing
 912          * for unexpected sample counts, and ignore samples for
 913          * unexpected channel groups. Don't bother with complicated
 914          * resize logic, considering that many models only support one
 915          * pod, and the most capable supported models have two pods of
 916          * identical size. We haven't yet seen any "odd" configuration.
 917          */
 918         if (!devc->logic_data) {
 919                 size = pod_data->len * devc->pod_count;
 920                 store = g_byte_array_sized_new(size);
 921                 memset(store->data, 0, size);
 922                 store = g_byte_array_set_size(store, size);
 923                 devc->logic_data = store;
 924         } else {
 925                 store = devc->logic_data;
 926                 size = store->len / devc->pod_count;
 927                 if (group >= devc->pod_count)
 928                         return;
 929         }
 930
 931         /*
 932          * Fold the data of the most recently received channel group into
 933          * the storage, where data resides for all channels combined.
 934          */
 935         logic_data = store->data;
 936         logic_data += group;
 937         logic_step = devc->pod_count;
 938         for (idx = 0; idx < pod_data->len; idx++) {
 939                 *logic_data = pod_data->data[idx];
 940                 logic_data += logic_step;
 941         }
 942
 943         /* Truncate acquisition if a smaller number of samples has been requested. */
 944         if (devc->samples_limit > 0 && devc->logic_data->len > devc->samples_limit * devc->pod_count)
 945                 devc->logic_data->len = devc->samples_limit * devc->pod_count;
 946 }
 947
 948 /* Submit data for all channels, after the individual groups got collected. */
 949 SR_PRIV void hmo_send_logic_packet(struct sr_dev_inst *sdi,
 950                                    struct dev_context *devc)
 951 {
 952         struct sr_datafeed_packet packet;
 953         struct sr_datafeed_logic logic;
 954
 955         if (!devc->logic_data)
 956                 return;
 957
 958         logic.data = devc->logic_data->data;
 959         logic.length = devc->logic_data->len;
 960         logic.unitsize = devc->pod_count;
 961
 962         packet.type = SR_DF_LOGIC;
 963         packet.payload = &logic;
 964
 965         sr_session_send(sdi, &packet);
 966 }
 967
 968 /* Undo previous resource allocation. */
 969 SR_PRIV void hmo_cleanup_logic_data(struct dev_context *devc)
 970 {
 971
 972         if (devc->logic_data) {
 973                 g_byte_array_free(devc->logic_data, TRUE);
 974                 devc->logic_data = NULL;
 975         }
 976         /*
 977          * Keep 'pod_count'! It's required when more frames will be
 978          * received, and does not harm when kept after acquisition.
 979          */
 980 }
 981
 982 SR_PRIV int hmo_receive_data(int fd, int revents, void *cb_data)
 983 {
 984         struct sr_channel *ch;
 985         struct sr_dev_inst *sdi;
 986         struct dev_context *devc;
 987         struct scope_state *state;
 988         struct sr_datafeed_packet packet;
 989         GByteArray *data;
 990         struct sr_datafeed_analog analog;
 991         struct sr_analog_encoding encoding;
 992         struct sr_analog_meaning meaning;
 993         struct sr_analog_spec spec;
 994         struct sr_datafeed_logic logic;
 995         size_t group;
 996
 997         (void)fd;
 998         (void)revents;
 999
1000         data = NULL;
1001
1002         if (!(sdi = cb_data))
1003                 return TRUE;
1004
1005         if (!(devc = sdi->priv))
1006                 return TRUE;
1007
1008         /* Although this is correct in general, the USBTMC libusb implementation
1009          * currently does not generate an event prior to the first read. Often
1010          * it is ok to start reading just after the 50ms timeout. See bug #785.
1011         if (revents != G_IO_IN)
1012                 return TRUE;
1013         */
1014
1015         ch = devc->current_channel->data;
1016         state = devc->model_state;
1017
1018         /*
1019          * Send "frame begin" packet upon reception of data for the
1020          * first enabled channel.
1021          */
1022         if (devc->current_channel == devc->enabled_channels) {
1023                 packet.type = SR_DF_FRAME_BEGIN;
1024                 sr_session_send(sdi, &packet);
1025         }
1026
1027         /*
1028          * Pass on the received data of the channel(s).
1029          */
1030         switch (ch->type) {
1031         case SR_CHANNEL_ANALOG:
1032                 if (sr_scpi_get_block(sdi->conn, NULL, &data) != SR_OK) {
1033                         if (data)
1034                                 g_byte_array_free(data, TRUE);
1035                         return TRUE;
1036                 }
1037
1038                 packet.type = SR_DF_ANALOG;
1039
1040                 analog.data = data->data;
1041                 analog.num_samples = data->len / sizeof(float);
1042                 /* Truncate acquisition if a smaller number of samples has been requested. */
1043                 if (devc->samples_limit > 0 && analog.num_samples > devc->samples_limit)
1044                         analog.num_samples = devc->samples_limit;
1045                 analog.encoding = &encoding;
1046                 analog.meaning = &meaning;
1047                 analog.spec = &spec;
1048
1049                 encoding.unitsize = sizeof(float);
1050                 encoding.is_signed = TRUE;
1051                 encoding.is_float = TRUE;
1052 #ifdef WORDS_BIGENDIAN
1053                 encoding.is_bigendian = TRUE;
1054 #else
1055                 encoding.is_bigendian = FALSE;
1056 #endif
1057                 /* TODO: Use proper 'digits' value for this device (and its modes). */
1058                 encoding.digits = 2;
1059                 encoding.is_digits_decimal = FALSE;
1060                 encoding.scale.p = 1;
1061                 encoding.scale.q = 1;
1062                 encoding.offset.p = 0;
1063                 encoding.offset.q = 1;
1064                 if (state->analog_channels[ch->index].probe_unit == 'V') {
1065                         meaning.mq = SR_MQ_VOLTAGE;
1066                         meaning.unit = SR_UNIT_VOLT;
1067                 } else {
1068                         meaning.mq = SR_MQ_CURRENT;
1069                         meaning.unit = SR_UNIT_AMPERE;
1070                 }
1071                 meaning.mqflags = 0;
1072                 meaning.channels = g_slist_append(NULL, ch);
1073                 /* TODO: Use proper 'digits' value for this device (and its modes). */
1074                 spec.spec_digits = 2;
1075                 packet.payload = &analog;
1076                 sr_session_send(sdi, &packet);
1077                 devc->num_samples = data->len / sizeof(float);
1078                 g_slist_free(meaning.channels);
1079                 g_byte_array_free(data, TRUE);
1080                 data = NULL;
1081                 break;
1082         case SR_CHANNEL_LOGIC:
1083                 if (sr_scpi_get_block(sdi->conn, NULL, &data) != SR_OK) {
1084                         if (data)
1085                                 g_byte_array_free(data, TRUE);
1086                         return TRUE;
1087                 }
1088
1089                 /*
1090                  * If only data from the first pod is involved in the
1091                  * acquisition, then the raw input bytes can get passed
1092                  * forward for performance reasons. When the second pod
1093                  * is involved (either alone, or in combination with the
1094                  * first pod), then the received bytes need to be put
1095                  * into memory in such a layout that all channel groups
1096                  * get combined, and a unitsize larger than a single byte
1097                  * applies. The "queue" logic transparently copes with
1098                  * any such configuration. This works around the lack
1099                  * of support for "meaning" to logic data, which is used
1100                  * above for analog data.
1101                  */
1102                 if (devc->pod_count == 1) {
1103                         packet.type = SR_DF_LOGIC;
1104                         logic.data = data->data;
1105                         logic.length = data->len;
1106                         /* Truncate acquisition if a smaller number of samples has been requested. */
1107                         if (devc->samples_limit > 0 && logic.length > devc->samples_limit)
1108                                 logic.length = devc->samples_limit;
1109                         logic.unitsize = 1;
1110                         packet.payload = &logic;
1111                         sr_session_send(sdi, &packet);
1112                 } else {
1113                         group = ch->index / 8;
1114                         hmo_queue_logic_data(devc, group, data);
1115                 }
1116
1117                 devc->num_samples = data->len / devc->pod_count;
1118                 g_byte_array_free(data, TRUE);
1119                 data = NULL;
1120                 break;
1121         default:
1122                 sr_err("Invalid channel type.");
1123                 break;
1124         }
1125
1126         /*
1127          * Advance to the next enabled channel. When data for all enabled
1128          * channels was received, then flush potentially queued logic data,
1129          * and send the "frame end" packet.
1130          */
1131         if (devc->current_channel->next) {
1132                 devc->current_channel = devc->current_channel->next;
1133                 hmo_request_data(sdi);
1134                 return TRUE;
1135         }
1136         hmo_send_logic_packet(sdi, devc);
1137
1138         /*
1139          * Release the logic data storage after each frame. This copes
1140          * with sample counts that differ in length per frame. -- Is
1141          * this a real constraint when acquiring multiple frames with
1142          * identical device settings?
1143          */
1144         hmo_cleanup_logic_data(devc);
1145
1146         packet.type = SR_DF_FRAME_END;
1147         sr_session_send(sdi, &packet);
1148
1149         /*
1150          * End of frame was reached. Stop acquisition after the specified
1151          * number of frames or after the specified number of samples, or
1152          * continue reception by starting over at the first enabled channel.
1153          */
1154         if (++devc->num_frames >= devc->frame_limit || devc->num_samples >= devc->samples_limit) {
1155                 sr_dev_acquisition_stop(sdi);
1156                 hmo_cleanup_logic_data(devc);
1157         } else {
1158                 devc->current_channel = devc->enabled_channels;
1159                 hmo_request_data(sdi);
1160         }
1161
1162         return TRUE;
1163 }