src/hardware/yokogawa-dlm/protocol.c

   1 /*
   2  * This file is part of the libsigrok project.
   3  *
   4  * Copyright (C) 2014 abraxa (Soeren Apel) <soeren@apelpie.net>
   5  * Based on the Hameg HMO driver by poljar (Damir Jelić) <poljarinho@gmail.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 "scpi.h"
  23 #include "protocol.h"
  24
  25 static const char *coupling_options[] = {
  26         "AC", "DC", "DC50", "GND",
  27 };
  28
  29 static const char *trigger_sources_2ch[] = {
  30         "1", "2", "LINE", "EXT",
  31 };
  32
  33 /* TODO: Is BITx handled correctly or is Dx required? */
  34 static const char *trigger_sources_4ch[] = {
  35         "1", "2", "3", "4",
  36         "LINE", "EXT", "BIT1",
  37         "BIT2", "BIT3", "BIT4", "BIT5", "BIT6", "BIT7", "BIT8",
  38 };
  39
  40 /* Note: Values must correlate to the trigger_slopes values. */
  41 const char *dlm_trigger_slopes[2] = {
  42         "r", "f",
  43 };
  44
  45 const uint64_t dlm_timebases[36][2] = {
  46         /* nanoseconds */
  47         { 1, 1000000000 },
  48         { 2, 1000000000 },
  49         { 5, 1000000000 },
  50         { 10, 1000000000 },
  51         { 20, 1000000000 },
  52         { 50, 1000000000 },
  53         { 100, 1000000000 },
  54         { 200, 1000000000 },
  55         { 500, 1000000000 },
  56         /* microseconds */
  57         { 1, 1000000 },
  58         { 2, 1000000 },
  59         { 5, 1000000 },
  60         { 10, 1000000 },
  61         { 20, 1000000 },
  62         { 50, 1000000 },
  63         { 100, 1000000 },
  64         { 200, 1000000 },
  65         { 500, 1000000 },
  66         /* milliseconds */
  67         { 1, 1000 },
  68         { 2, 1000 },
  69         { 5, 1000 },
  70         { 10, 1000 },
  71         { 20, 1000 },
  72         { 50, 1000 },
  73         { 100, 1000 },
  74         { 200, 1000 },
  75         { 500, 1000 },
  76         /* seconds */
  77         { 1, 1 },
  78         { 2, 1 },
  79         { 5, 1 },
  80         { 10, 1 },
  81         { 20, 1 },
  82         { 50, 1 },
  83         { 100, 1 },
  84         { 200, 1 },
  85         { 500, 1 },
  86 };
  87
  88 const uint64_t dlm_vdivs[17][2] = {
  89         /* millivolts */
  90         { 2, 1000 },
  91         { 5, 1000 },
  92         { 10, 1000 },
  93         { 20, 1000 },
  94         { 50, 1000 },
  95         { 100, 1000 },
  96         { 200, 1000 },
  97         { 500, 1000 },
  98         /* volts */
  99         { 1, 1 },
 100         { 2, 1 },
 101         { 5, 1 },
 102         { 10, 1 },
 103         { 20, 1 },
 104         { 50, 1 },
 105         { 100, 1 },
 106         { 200, 1 },
 107         { 500, 1 },
 108 };
 109
 110 static const char *scope_analog_channel_names[] = {
 111         "1", "2", "3", "4",
 112 };
 113
 114 static const char *scope_digital_channel_names_8[] = {
 115         "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
 116 };
 117
 118 static const char *scope_digital_channel_names_32[] = {
 119         "A0", "A1", "A2", "A3", "A4", "A5", "A6", "A7",
 120         "B0", "B1", "B2", "B3", "B4", "B5", "B6", "B7",
 121         "C0", "C1", "C2", "C3", "C4", "C5", "C6", "C7",
 122         "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
 123 };
 124
 125 static const struct scope_config scope_models[] = {
 126         {
 127                 .model_id   = {"710105",  "710115",  "710125",  NULL},
 128                 .model_name = {"DLM2022", "DLM2032", "DLM2052", NULL},
 129                 .analog_channels = 2,
 130                 .digital_channels = 0,
 131                 .pods = 0,
 132
 133                 .analog_names = &scope_analog_channel_names,
 134                 .digital_names = &scope_digital_channel_names_8,
 135
 136                 .coupling_options = &coupling_options,
 137                 .num_coupling_options = ARRAY_SIZE(coupling_options),
 138
 139                 .trigger_sources = &trigger_sources_2ch,
 140                 .num_trigger_sources = ARRAY_SIZE(trigger_sources_2ch),
 141
 142                 .num_xdivs = 10,
 143                 .num_ydivs = 8,
 144         },
 145         {
 146                 .model_id   = {"710110",  "710120",  "710130",  NULL},
 147                 .model_name = {"DLM2024", "DLM2034", "DLM2054", NULL},
 148                 .analog_channels = 4,
 149                 .digital_channels = 8,
 150                 .pods = 1,
 151
 152                 .analog_names = &scope_analog_channel_names,
 153                 .digital_names = &scope_digital_channel_names_8,
 154
 155                 .coupling_options = &coupling_options,
 156                 .num_coupling_options = ARRAY_SIZE(coupling_options),
 157
 158                 .trigger_sources = &trigger_sources_4ch,
 159                 .num_trigger_sources = ARRAY_SIZE(trigger_sources_4ch),
 160
 161                 .num_xdivs = 10,
 162                 .num_ydivs = 8,
 163         },
 164         {
 165                 .model_id   = {"701307", "701308",  "701310", "701311",
 166                                "701312", "701313",  NULL},
 167                 .model_name = {"DL9040", "DL9040L", "DL9140", "DL9140L",
 168                                "DL9240", "DL9240L", NULL},
 169                 .analog_channels = 4,
 170                 .digital_channels = 0,
 171                 .pods = 0,
 172
 173                 .analog_names = &scope_analog_channel_names,
 174                 .digital_names = NULL,
 175
 176                 .coupling_options = &coupling_options,
 177                 .num_coupling_options = ARRAY_SIZE(coupling_options),
 178
 179                 .trigger_sources = &trigger_sources_4ch,
 180                 .num_trigger_sources = ARRAY_SIZE(trigger_sources_4ch),
 181
 182                 .num_xdivs = 10,
 183                 .num_ydivs = 8,
 184         },
 185         {
 186                 .model_id   = {"701320",  "701321",  NULL},
 187                 .model_name = {"DL9505L", "DL9510L", NULL},
 188                 .analog_channels = 4,
 189                 .digital_channels = 16,
 190                 .pods = 4,
 191
 192                 .analog_names = &scope_analog_channel_names,
 193                 .digital_names = &scope_digital_channel_names_32,
 194
 195                 .coupling_options = &coupling_options,
 196                 .num_coupling_options = ARRAY_SIZE(coupling_options),
 197
 198                 .trigger_sources = &trigger_sources_4ch,
 199                 .num_trigger_sources = ARRAY_SIZE(trigger_sources_4ch),
 200
 201                 .num_xdivs = 10,
 202                 .num_ydivs = 8,
 203         },
 204         {
 205                 .model_id   = {"701330",  "701331",  NULL},
 206                 .model_name = {"DL9705L", "DL9710L", NULL},
 207                 .analog_channels = 4,
 208                 .digital_channels = 32,
 209                 .pods = 4,
 210
 211                 .analog_names = &scope_analog_channel_names,
 212                 .digital_names = &scope_digital_channel_names_32,
 213
 214                 .coupling_options = &coupling_options,
 215                 .num_coupling_options = ARRAY_SIZE(coupling_options),
 216
 217                 .trigger_sources = &trigger_sources_4ch,
 218                 .num_trigger_sources = ARRAY_SIZE(trigger_sources_4ch),
 219
 220                 .num_xdivs = 10,
 221                 .num_ydivs = 8,
 222         },
 223 };
 224
 225 /**
 226  * Prints out the state of the device as we currently know it.
 227  *
 228  * @param config This is the scope configuration.
 229  * @param state The current scope state to print.
 230  */
 231 static void scope_state_dump(const struct scope_config *config,
 232                 struct scope_state *state)
 233 {
 234         unsigned int i;
 235         char *tmp;
 236
 237         for (i = 0; i < config->analog_channels; i++) {
 238                 tmp = sr_voltage_string(dlm_vdivs[state->analog_states[i].vdiv][0],
 239                                 dlm_vdivs[state->analog_states[i].vdiv][1]);
 240                 sr_info("State of analog channel %d -> %s : %s (coupling) %s (vdiv) %2.2e (offset)",
 241                                 i + 1, state->analog_states[i].state ? "On" : "Off",
 242                                 (*config->coupling_options)[state->analog_states[i].coupling],
 243                                 tmp, state->analog_states[i].vertical_offset);
 244         }
 245
 246         for (i = 0; i < config->digital_channels; i++) {
 247                 sr_info("State of digital channel %d -> %s", i,
 248                                 state->digital_states[i] ? "On" : "Off");
 249         }
 250
 251         for (i = 0; i < config->pods; i++) {
 252                 sr_info("State of digital POD %d -> %s", i,
 253                                 state->pod_states[i] ? "On" : "Off");
 254         }
 255
 256         tmp = sr_period_string(dlm_timebases[state->timebase][0],
 257                         dlm_timebases[state->timebase][1]);
 258         sr_info("Current timebase: %s", tmp);
 259         g_free(tmp);
 260
 261         tmp = sr_samplerate_string(state->sample_rate);
 262         sr_info("Current samplerate: %s", tmp);
 263         g_free(tmp);
 264
 265         sr_info("Current samples per acquisition (i.e. frame): %d",
 266                         state->samples_per_frame);
 267
 268         sr_info("Current trigger: %s (source), %s (slope) %.2f (offset)",
 269                         (*config->trigger_sources)[state->trigger_source],
 270                         dlm_trigger_slopes[state->trigger_slope],
 271                         state->horiz_triggerpos);
 272 }
 273
 274 /**
 275  * Searches through an array of strings and returns the index to the
 276  * array where a given string is located.
 277  *
 278  * @param value The string to search for.
 279  * @param array The array of strings.
 280  * @param result The index at which value is located in array. -1 on error.
 281  *
 282  * @return SR_ERR when value couldn't be found, SR_OK otherwise.
 283  */
 284 static int array_option_get(char *value, const char *(*array)[],
 285                 unsigned int n, int *result)
 286 {
 287         unsigned int i;
 288
 289         *result = -1;
 290
 291         for (i = 0; i < n; i++)
 292                 if (!g_strcmp0(value, (*array)[i])) {
 293                         *result = i;
 294                         break;
 295                 }
 296
 297         if (*result == -1)
 298                 return SR_ERR;
 299
 300         return SR_OK;
 301 }
 302
 303 /**
 304  * This function takes a value of the form "2.000E-03", converts it to a
 305  * significand / factor pair and returns the index of an array where
 306  * a matching pair was found.
 307  *
 308  * It's a bit convoluted because of floating-point issues. The value "10.00E-09"
 309  * is parsed by g_ascii_strtod() as 0.000000009999999939, for example.
 310  * Therefore it's easier to break the number up into two strings and handle
 311  * them separately.
 312  *
 313  * @param value The string to be parsed.
 314  * @param array The array of s/f pairs.
 315  * @param array_len The number of pairs in the array.
 316  * @param result The index at which a matching pair was found.
 317  *
 318  * @return SR_ERR on any parsing error, SR_OK otherwise.
 319  */
 320 static int array_float_get(gchar *value, const uint64_t array[][2],
 321                 int array_len, int *result)
 322 {
 323         int i, e;
 324         size_t pos;
 325         uint64_t f;
 326         float s;
 327         unsigned int s_int;
 328         gchar ss[10], es[10];
 329
 330         memset(ss, 0, sizeof(ss));
 331         memset(es, 0, sizeof(es));
 332
 333         /* Get index of the separating 'E' character and break up the string. */
 334         pos = strcspn(value, "E");
 335
 336         strncpy(ss, value, pos);
 337         strncpy(es, &(value[pos+1]), 3);
 338
 339         if (sr_atof_ascii(ss, &s) != SR_OK)
 340                 return SR_ERR;
 341         if (sr_atoi(es, &e) != SR_OK)
 342                 return SR_ERR;
 343
 344         /* Transform e.g. 10^-03 to 1000 as the array stores the inverse. */
 345         f = pow(10, abs(e));
 346
 347         /*
 348          * Adjust the significand/factor pair to make sure
 349          * that f is a multiple of 1000.
 350          */
 351         while ((int)fmod(log10(f), 3) > 0) {
 352                 s *= 10;
 353
 354                 if (e < 0)
 355                         f *= 10;
 356                 else
 357                         f /= 10;
 358         }
 359
 360         /* Truncate s to circumvent rounding errors. */
 361         s_int = (unsigned int)s;
 362
 363         for (i = 0; i < array_len; i++) {
 364                 if ((s_int == array[i][0]) && (f == array[i][1])) {
 365                         *result = i;
 366                         return SR_OK;
 367                 }
 368         }
 369
 370         return SR_ERR;
 371 }
 372
 373 /**
 374  * Obtains information about all analog channels from the oscilloscope.
 375  * The internal state information is updated accordingly.
 376  *
 377  * @param sdi The device instance.
 378  * @param config The device's device configuration.
 379  * @param state The device's state information.
 380  *
 381  * @return SR_ERR on error, SR_OK otherwise.
 382  */
 383 static int analog_channel_state_get(const struct sr_dev_inst *sdi,
 384                 const struct scope_config *config,
 385                 struct scope_state *state)
 386 {
 387         struct sr_scpi_dev_inst *scpi;
 388         int i, j;
 389         GSList *l;
 390         struct sr_channel *ch;
 391         gchar *response;
 392
 393         scpi = sdi->conn;
 394
 395         for (i = 0; i < config->analog_channels; i++) {
 396
 397                 if (dlm_analog_chan_state_get(scpi, i + 1,
 398                                 &state->analog_states[i].state) != SR_OK)
 399                         return SR_ERR;
 400
 401                 for (l = sdi->channels; l; l = l->next) {
 402                         ch = l->data;
 403                         if (ch->index == i) {
 404                                 ch->enabled = state->analog_states[i].state;
 405                                 break;
 406                         }
 407                 }
 408
 409                 if (dlm_analog_chan_vdiv_get(scpi, i + 1, &response) != SR_OK)
 410                         return SR_ERR;
 411
 412                 if (array_float_get(response, ARRAY_AND_SIZE(dlm_vdivs),
 413                                 &j) != SR_OK) {
 414                         g_free(response);
 415                         return SR_ERR;
 416                 }
 417
 418                 g_free(response);
 419                 state->analog_states[i].vdiv = j;
 420
 421                 if (dlm_analog_chan_voffs_get(scpi, i + 1,
 422                                 &state->analog_states[i].vertical_offset) != SR_OK)
 423                         return SR_ERR;
 424
 425                 if (dlm_analog_chan_wrange_get(scpi, i + 1,
 426                                 &state->analog_states[i].waveform_range) != SR_OK)
 427                         return SR_ERR;
 428
 429                 if (dlm_analog_chan_woffs_get(scpi, i + 1,
 430                                 &state->analog_states[i].waveform_offset) != SR_OK)
 431                         return SR_ERR;
 432
 433                 if (dlm_analog_chan_coupl_get(scpi, i + 1, &response) != SR_OK) {
 434                         g_free(response);
 435                         return SR_ERR;
 436                 }
 437
 438                 if (array_option_get(response, config->coupling_options,
 439                                 config->num_coupling_options,
 440                                 &state->analog_states[i].coupling) != SR_OK) {
 441                         g_free(response);
 442                         return SR_ERR;
 443                 }
 444                 g_free(response);
 445         }
 446
 447         return SR_OK;
 448 }
 449
 450 /**
 451  * Obtains information about all digital channels from the oscilloscope.
 452  * The internal state information is updated accordingly.
 453  *
 454  * @param sdi The device instance.
 455  * @param config The device's device configuration.
 456  * @param state The device's state information.
 457  *
 458  * @return SR_ERR on error, SR_OK otherwise.
 459  */
 460 static int digital_channel_state_get(const struct sr_dev_inst *sdi,
 461                 const struct scope_config *config,
 462                 struct scope_state *state)
 463 {
 464         struct sr_scpi_dev_inst *scpi;
 465         int i;
 466         GSList *l;
 467         struct sr_channel *ch;
 468
 469         scpi = sdi->conn;
 470
 471         if (!config->digital_channels) {
 472                 sr_warn("Tried obtaining digital channel states on a " \
 473                                 "model without digital inputs.");
 474                 return SR_OK;
 475         }
 476
 477         for (i = 0; i < config->digital_channels; i++) {
 478                 if (dlm_digital_chan_state_get(scpi, i + 1,
 479                                 &state->digital_states[i]) != SR_OK) {
 480                         return SR_ERR;
 481                 }
 482
 483                 for (l = sdi->channels; l; l = l->next) {
 484                         ch = l->data;
 485                         if (ch->index == i + DLM_DIG_CHAN_INDEX_OFFS) {
 486                                 ch->enabled = state->digital_states[i];
 487                                 break;
 488                         }
 489                 }
 490         }
 491
 492         if (!config->pods) {
 493                 sr_warn("Tried obtaining pod states on a model without pods.");
 494                 return SR_OK;
 495         }
 496
 497         for (i = 0; i < config->pods; i++) {
 498                 if (dlm_digital_pod_state_get(scpi, i + 'A',
 499                                 &state->pod_states[i]) != SR_OK)
 500                         return SR_ERR;
 501         }
 502
 503         return SR_OK;
 504 }
 505
 506 SR_PRIV int dlm_channel_state_set(const struct sr_dev_inst *sdi,
 507                 const int ch_index, gboolean ch_state)
 508 {
 509         GSList *l;
 510         struct sr_channel *ch;
 511         struct dev_context *devc = NULL;
 512         struct scope_state *state;
 513         const struct scope_config *model = NULL;
 514         struct sr_scpi_dev_inst *scpi;
 515         gboolean chan_found;
 516         gboolean *pod_enabled;
 517         int i, result;
 518
 519         result = SR_OK;
 520
 521         scpi = sdi->conn;
 522         devc = sdi->priv;
 523         state = devc->model_state;
 524         model = devc->model_config;
 525         chan_found = FALSE;
 526
 527         pod_enabled = g_malloc0(sizeof(gboolean) * model->pods);
 528
 529         for (l = sdi->channels; l; l = l->next) {
 530                 ch = l->data;
 531
 532                 switch (ch->type) {
 533                 case SR_CHANNEL_ANALOG:
 534                         if (ch->index == ch_index) {
 535                                 if (dlm_analog_chan_state_set(scpi, ch->index + 1, ch_state) != SR_OK) {
 536                                         result = SR_ERR;
 537                                         break;
 538                                 }
 539
 540                                 ch->enabled = ch_state;
 541                                 state->analog_states[ch->index].state = ch_state;
 542                                 chan_found = TRUE;
 543                                 break;
 544                         }
 545                         break;
 546                 case SR_CHANNEL_LOGIC:
 547                         i = ch->index - DLM_DIG_CHAN_INDEX_OFFS;
 548
 549                         if (ch->index == ch_index) {
 550                                 if (dlm_digital_chan_state_set(scpi, i + 1, ch_state) != SR_OK) {
 551                                         result = SR_ERR;
 552                                         break;
 553                                 }
 554
 555                                 ch->enabled = ch_state;
 556                                 state->digital_states[i] = ch_state;
 557                                 chan_found = TRUE;
 558
 559                                 /* The corresponding pod has to be enabled also. */
 560                                 pod_enabled[i / 8] |= ch->enabled;
 561                         } else {
 562                                 /* Also check all other channels. Maybe we can disable a pod. */
 563                                 pod_enabled[i / 8] |= ch->enabled;
 564                         }
 565                         break;
 566                 default:
 567                         result = SR_ERR_NA;
 568                 }
 569         }
 570
 571         for (i = 0; i < model->pods; i++) {
 572                 if (state->pod_states[i] == pod_enabled[i])
 573                         continue;
 574
 575                 if (dlm_digital_pod_state_set(scpi, i + 1, pod_enabled[i]) != SR_OK) {
 576                         result = SR_ERR;
 577                         break;
 578                 }
 579
 580                 state->pod_states[i] = pod_enabled[i];
 581         }
 582
 583         g_free(pod_enabled);
 584
 585         if ((result == SR_OK) && !chan_found)
 586                 result = SR_ERR_BUG;
 587
 588         return result;
 589 }
 590
 591 /**
 592  * Obtains information about the sample rate from the oscilloscope.
 593  * The internal state information is updated accordingly.
 594  *
 595  * @param sdi The device instance.
 596  *
 597  * @return SR_ERR on error, SR_OK otherwise.
 598  */
 599 SR_PRIV int dlm_sample_rate_query(const struct sr_dev_inst *sdi)
 600 {
 601         struct dev_context *devc;
 602         struct scope_state *state;
 603         float tmp_float;
 604
 605         devc = sdi->priv;
 606         state = devc->model_state;
 607
 608         /*
 609          * No need to find an active channel to query the sample rate:
 610          * querying any channel will do, so we use channel 1 all the time.
 611          */
 612         if (dlm_analog_chan_srate_get(sdi->conn, 1, &tmp_float) != SR_OK)
 613                 return SR_ERR;
 614
 615         state->sample_rate = tmp_float;
 616
 617         return SR_OK;
 618 }
 619
 620 /**
 621  * Obtains information about the current device state from the oscilloscope,
 622  * including all analog and digital channel configurations.
 623  * The internal state information is updated accordingly.
 624  *
 625  * @param sdi The device instance.
 626  *
 627  * @return SR_ERR on error, SR_OK otherwise.
 628  */
 629 SR_PRIV int dlm_scope_state_query(struct sr_dev_inst *sdi)
 630 {
 631         struct dev_context *devc;
 632         struct scope_state *state;
 633         const struct scope_config *config;
 634         float tmp_float;
 635         gchar *response;
 636         int i;
 637
 638         devc = sdi->priv;
 639         config = devc->model_config;
 640         state = devc->model_state;
 641
 642         if (analog_channel_state_get(sdi, config, state) != SR_OK)
 643                 return SR_ERR;
 644
 645         if (digital_channel_state_get(sdi, config, state) != SR_OK)
 646                 return SR_ERR;
 647
 648         if (dlm_timebase_get(sdi->conn, &response) != SR_OK)
 649                 return SR_ERR;
 650
 651         if (array_float_get(response, ARRAY_AND_SIZE(dlm_timebases), &i) != SR_OK) {
 652                 g_free(response);
 653                 return SR_ERR;
 654         }
 655
 656         g_free(response);
 657         state->timebase = i;
 658
 659         if (dlm_horiz_trigger_pos_get(sdi->conn, &tmp_float) != SR_OK)
 660                 return SR_ERR;
 661
 662         /* TODO: Check if the calculation makes sense for the DLM. */
 663         state->horiz_triggerpos = tmp_float /
 664                         (((double)dlm_timebases[state->timebase][0] /
 665                         dlm_timebases[state->timebase][1]) * config->num_xdivs);
 666         state->horiz_triggerpos -= 0.5;
 667         state->horiz_triggerpos *= -1;
 668
 669         if (dlm_trigger_source_get(sdi->conn, &response) != SR_OK) {
 670                 g_free(response);
 671                 return SR_ERR;
 672         }
 673
 674         if (array_option_get(response, config->trigger_sources,
 675                         config->num_trigger_sources, &state->trigger_source) != SR_OK) {
 676                 g_free(response);
 677                 return SR_ERR;
 678         }
 679
 680         g_free(response);
 681
 682         if (dlm_trigger_slope_get(sdi->conn, &i) != SR_OK)
 683                 return SR_ERR;
 684
 685         state->trigger_slope = i;
 686
 687         if (dlm_acq_length_get(sdi->conn, &state->samples_per_frame) != SR_OK) {
 688                 sr_err("Failed to query acquisition length.");
 689                 return SR_ERR;
 690         }
 691
 692         dlm_sample_rate_query(sdi);
 693
 694         scope_state_dump(config, state);
 695
 696         return SR_OK;
 697 }
 698
 699 /**
 700  * Creates a new device state structure.
 701  *
 702  * @param config The device configuration to use.
 703  *
 704  * @return The newly allocated scope_state struct.
 705  */
 706 static struct scope_state *dlm_scope_state_new(const struct scope_config *config)
 707 {
 708         struct scope_state *state;
 709
 710         state = g_malloc0(sizeof(struct scope_state));
 711
 712         state->analog_states = g_malloc0(config->analog_channels *
 713                         sizeof(struct analog_channel_state));
 714
 715         state->digital_states = g_malloc0(config->digital_channels *
 716                         sizeof(gboolean));
 717
 718         state->pod_states = g_malloc0(config->pods * sizeof(gboolean));
 719
 720         return state;
 721 }
 722
 723 /**
 724  * Frees the memory that was allocated by a call to dlm_scope_state_new().
 725  *
 726  * @param state The device state structure whose memory is to be freed.
 727  */
 728 SR_PRIV void dlm_scope_state_destroy(struct scope_state *state)
 729 {
 730         g_free(state->analog_states);
 731         g_free(state->digital_states);
 732         g_free(state->pod_states);
 733         g_free(state);
 734 }
 735
 736 SR_PRIV int dlm_model_get(char *model_id, char **model_name, int *model_index)
 737 {
 738         unsigned int i, j;
 739
 740         *model_index = -1;
 741         *model_name = NULL;
 742
 743         for (i = 0; i < ARRAY_SIZE(scope_models); i++) {
 744                 for (j = 0; scope_models[i].model_id[j]; j++) {
 745                         if (!strcmp(model_id, scope_models[i].model_id[j])) {
 746                                 *model_index = i;
 747                                 *model_name = (char *)scope_models[i].model_name[j];
 748                                 break;
 749                         }
 750                 }
 751                 if (*model_index != -1)
 752                         break;
 753         }
 754
 755         if (*model_index == -1) {
 756                 sr_err("Found unsupported DLM device with model identifier %s.",
 757                                 model_id);
 758                 return SR_ERR_NA;
 759         }
 760
 761         return SR_OK;
 762 }
 763
 764 /**
 765  * Attempts to initialize a DL/DLM device and prepares internal structures
 766  * if a suitable device was found.
 767  *
 768  * @param sdi The device instance.
 769  */
 770 SR_PRIV int dlm_device_init(struct sr_dev_inst *sdi, int model_index)
 771 {
 772         int i;
 773         struct sr_channel *ch;
 774         struct dev_context *devc;
 775
 776         devc = sdi->priv;
 777
 778         devc->analog_groups = g_malloc0(sizeof(struct sr_channel_group*) *
 779                         scope_models[model_index].analog_channels);
 780         devc->digital_groups = g_malloc0(sizeof(struct sr_channel_group*) *
 781                         scope_models[model_index].pods);
 782         if (!devc->analog_groups || !devc->digital_groups) {
 783                 g_free(devc->analog_groups);
 784                 g_free(devc->digital_groups);
 785                 return SR_ERR_MALLOC;
 786         }
 787
 788         /* Add analog channels, each in its own group. */
 789         for (i = 0; i < scope_models[model_index].analog_channels; i++) {
 790                 ch = sr_channel_new(sdi, i, SR_CHANNEL_ANALOG, TRUE,
 791                                 (*scope_models[model_index].analog_names)[i]);
 792
 793                 devc->analog_groups[i] = sr_channel_group_new(sdi,
 794                         (*scope_models[model_index].analog_names)[i], NULL);
 795                 devc->analog_groups[i]->channels = g_slist_append(NULL, ch);
 796         }
 797
 798         /* Add digital channel groups. */
 799         for (i = 0; i < scope_models[model_index].pods; i++) {
 800                 devc->digital_groups[i] = sr_channel_group_new(sdi, NULL, NULL);
 801                 if (!devc->digital_groups[i])
 802                         return SR_ERR_MALLOC;
 803                 devc->digital_groups[i]->name = g_strdup_printf("POD%d", i);
 804         }
 805
 806         /* Add digital channels. */
 807         for (i = 0; i < scope_models[model_index].digital_channels; i++) {
 808                 ch = sr_channel_new(sdi, DLM_DIG_CHAN_INDEX_OFFS + i,
 809                                 SR_CHANNEL_LOGIC, TRUE,
 810                                 (*scope_models[model_index].digital_names)[i]);
 811
 812                 devc->digital_groups[i / 8]->channels = g_slist_append(
 813                                 devc->digital_groups[i / 8]->channels, ch);
 814         }
 815         devc->model_config = &scope_models[model_index];
 816         devc->frame_limit = 0;
 817
 818         if (!(devc->model_state = dlm_scope_state_new(devc->model_config)))
 819                 return SR_ERR_MALLOC;
 820
 821         /* Disable non-standard response behavior. */
 822         if (dlm_response_headers_set(sdi->conn, FALSE) != SR_OK)
 823                 return SR_ERR;
 824
 825         return SR_OK;
 826 }
 827
 828 SR_PRIV int dlm_channel_data_request(const struct sr_dev_inst *sdi)
 829 {
 830         struct dev_context *devc;
 831         struct sr_channel *ch;
 832         int result;
 833
 834         devc = sdi->priv;
 835         ch = devc->current_channel->data;
 836
 837         switch (ch->type) {
 838         case SR_CHANNEL_ANALOG:
 839                 result = dlm_analog_data_get(sdi->conn, ch->index + 1);
 840                 break;
 841         case SR_CHANNEL_LOGIC:
 842                 result = dlm_digital_data_get(sdi->conn);
 843                 break;
 844         default:
 845                 sr_err("Invalid channel type encountered (%d).",
 846                                 ch->type);
 847                 result = SR_ERR;
 848         }
 849
 850         if (result == SR_OK)
 851                 devc->data_pending = TRUE;
 852         else
 853                 devc->data_pending = FALSE;
 854
 855         return result;
 856 }
 857
 858 /**
 859  * Reads and removes the block data header from a given data input.
 860  * Format is #ndddd... with n being the number of decimal digits d.
 861  * The string dddd... contains the decimal-encoded length of the data.
 862  * Example: #9000000013 would yield a length of 13 bytes.
 863  *
 864  * @param data The input data.
 865  * @param len The determined input data length.
 866  */
 867 static int dlm_block_data_header_process(GArray *data, int *len)
 868 {
 869         int i, n;
 870         gchar s[20];
 871
 872         if (g_array_index(data, gchar, 0) != '#')
 873                 return SR_ERR;
 874
 875         n = (uint8_t)(g_array_index(data, gchar, 1) - '0');
 876
 877         for (i = 0; i < n; i++)
 878                 s[i] = g_array_index(data, gchar, 2 + i);
 879         s[i] = 0;
 880
 881         if (sr_atoi(s, len) != SR_OK)
 882                 return SR_ERR;
 883
 884         g_array_remove_range(data, 0, 2 + n);
 885
 886         return SR_OK;
 887 }
 888
 889 /**
 890  * Turns raw sample data into voltages and sends them off to the session bus.
 891  *
 892  * @param data The raw sample data.
 893  * @ch_state Pointer to the state of the channel whose data we're processing.
 894  * @sdi The device instance.
 895  *
 896  * @return SR_ERR when data is trucated, SR_OK otherwise.
 897  */
 898 static int dlm_analog_samples_send(GArray *data,
 899                 struct analog_channel_state *ch_state,
 900                 struct sr_dev_inst *sdi)
 901 {
 902         uint32_t i, samples;
 903         float voltage, range, offset;
 904         GArray *float_data;
 905         struct dev_context *devc;
 906         struct scope_state *model_state;
 907         struct sr_channel *ch;
 908         struct sr_datafeed_analog analog;
 909         struct sr_analog_encoding encoding;
 910         struct sr_analog_meaning meaning;
 911         struct sr_analog_spec spec;
 912         struct sr_datafeed_packet packet;
 913
 914         devc = sdi->priv;
 915         model_state = devc->model_state;
 916         samples = model_state->samples_per_frame;
 917         ch = devc->current_channel->data;
 918
 919         if (data->len < samples * sizeof(uint8_t)) {
 920                 sr_err("Truncated waveform data packet received.");
 921                 return SR_ERR;
 922         }
 923
 924         range = ch_state->waveform_range;
 925         offset = ch_state->waveform_offset;
 926
 927         /*
 928          * Convert byte sample to voltage according to
 929          * page 269 of the Communication Interface User's Manual.
 930          */
 931         float_data = g_array_new(FALSE, FALSE, sizeof(float));
 932         for (i = 0; i < samples; i++) {
 933                 voltage = (float)g_array_index(data, int8_t, i);
 934                 voltage = (range * voltage /
 935                                 DLM_DIVISION_FOR_BYTE_FORMAT) + offset;
 936                 g_array_append_val(float_data, voltage);
 937         }
 938
 939         /* TODO: Use proper 'digits' value for this device (and its modes). */
 940         sr_analog_init(&analog, &encoding, &meaning, &spec, 2);
 941         analog.meaning->channels = g_slist_append(NULL, ch);
 942         analog.num_samples = float_data->len;
 943         analog.data = (float*)float_data->data;
 944         analog.meaning->mq = SR_MQ_VOLTAGE;
 945         analog.meaning->unit = SR_UNIT_VOLT;
 946         analog.meaning->mqflags = 0;
 947         packet.type = SR_DF_ANALOG;
 948         packet.payload = &analog;
 949         sr_session_send(sdi, &packet);
 950         g_slist_free(analog.meaning->channels);
 951
 952         g_array_free(float_data, TRUE);
 953         g_array_remove_range(data, 0, samples * sizeof(uint8_t));
 954
 955         return SR_OK;
 956 }
 957
 958 /**
 959  * Sends logic sample data off to the session bus.
 960  *
 961  * @param data The raw sample data.
 962  * @ch_state Pointer to the state of the channel whose data we're processing.
 963  * @sdi The device instance.
 964  *
 965  * @return SR_ERR when data is trucated, SR_OK otherwise.
 966  */
 967 static int dlm_digital_samples_send(GArray *data,
 968                 struct sr_dev_inst *sdi)
 969 {
 970         struct dev_context *devc;
 971         struct scope_state *model_state;
 972         uint32_t samples;
 973         struct sr_datafeed_logic logic;
 974         struct sr_datafeed_packet packet;
 975
 976         devc = sdi->priv;
 977         model_state = devc->model_state;
 978         samples = model_state->samples_per_frame;
 979
 980         if (data->len < samples * sizeof(uint8_t)) {
 981                 sr_err("Truncated waveform data packet received.");
 982                 return SR_ERR;
 983         }
 984
 985         logic.length = samples;
 986         logic.unitsize = 1;
 987         logic.data = data->data;
 988         packet.type = SR_DF_LOGIC;
 989         packet.payload = &logic;
 990         sr_session_send(sdi, &packet);
 991
 992         g_array_remove_range(data, 0, samples * sizeof(uint8_t));
 993
 994         return SR_OK;
 995 }
 996
 997 /**
 998  * Attempts to query sample data from the oscilloscope in order to send it
 999  * to the session bus for further processing.
1000  *
1001  * @param fd The file descriptor used as the event source.
1002  * @param revents The received events.
1003  * @param cb_data Callback data, in this case our device instance.
1004  *
1005  * @return TRUE in case of success or a recoverable error,
1006  *         FALSE when a fatal error was encountered.
1007  */
1008 SR_PRIV int dlm_data_receive(int fd, int revents, void *cb_data)
1009 {
1010         struct sr_dev_inst *sdi;
1011         struct scope_state *model_state;
1012         struct dev_context *devc;
1013         struct sr_channel *ch;
1014         int chunk_len, num_bytes;
1015         static GArray *data = NULL;
1016
1017         (void)fd;
1018         (void)revents;
1019
1020         if (!(sdi = cb_data))
1021                 return FALSE;
1022
1023         if (!(devc = sdi->priv))
1024                 return FALSE;
1025
1026         if (!(model_state = (struct scope_state*)devc->model_state))
1027                 return FALSE;
1028
1029         /* Are we waiting for a response from the device? */
1030         if (!devc->data_pending)
1031                 return TRUE;
1032
1033         /* Check if a new query response is coming our way. */
1034         if (!data) {
1035                 if (sr_scpi_read_begin(sdi->conn) == SR_OK)
1036                         /* The 16 here accounts for the header and EOL. */
1037                         data = g_array_sized_new(FALSE, FALSE, sizeof(uint8_t),
1038                                         16 + model_state->samples_per_frame);
1039                 else
1040                         return TRUE;
1041         }
1042
1043         /* Store incoming data. */
1044         chunk_len = sr_scpi_read_data(sdi->conn, devc->receive_buffer,
1045                         RECEIVE_BUFFER_SIZE);
1046         if (chunk_len < 0) {
1047                 sr_err("Error while reading data: %d", chunk_len);
1048                 goto fail;
1049         }
1050         g_array_append_vals(data, devc->receive_buffer, chunk_len);
1051
1052         /* Read the entire query response before processing. */
1053         if (!sr_scpi_read_complete(sdi->conn))
1054                 return TRUE;
1055
1056         /* We finished reading and are no longer waiting for data. */
1057         devc->data_pending = FALSE;
1058
1059         /* Signal the beginning of a new frame if this is the first channel. */
1060         if (devc->current_channel == devc->enabled_channels)
1061                 std_session_send_df_frame_begin(sdi);
1062
1063         if (dlm_block_data_header_process(data, &num_bytes) != SR_OK) {
1064                 sr_err("Encountered malformed block data header.");
1065                 goto fail;
1066         }
1067
1068         if (num_bytes == 0) {
1069                 sr_warn("Zero-length waveform data packet received. " \
1070                                 "Live mode not supported yet, stopping " \
1071                                 "acquisition and retrying.");
1072                 /* Don't care about return value here. */
1073                 dlm_acquisition_stop(sdi->conn);
1074                 g_array_free(data, TRUE);
1075                 dlm_channel_data_request(sdi);
1076                 return TRUE;
1077         }
1078
1079         ch = devc->current_channel->data;
1080         switch (ch->type) {
1081         case SR_CHANNEL_ANALOG:
1082                 if (dlm_analog_samples_send(data,
1083                                 &model_state->analog_states[ch->index],
1084                                 sdi) != SR_OK)
1085                         goto fail;
1086                 break;
1087         case SR_CHANNEL_LOGIC:
1088                 if (dlm_digital_samples_send(data, sdi) != SR_OK)
1089                         goto fail;
1090                 break;
1091         default:
1092                 sr_err("Invalid channel type encountered.");
1093                 break;
1094         }
1095
1096         g_array_free(data, TRUE);
1097         data = NULL;
1098
1099         /*
1100          * Signal the end of this frame if this was the last enabled channel
1101          * and set the next enabled channel. Then, request its data.
1102          */
1103         if (!devc->current_channel->next) {
1104                 std_session_send_df_frame_end(sdi);
1105                 devc->current_channel = devc->enabled_channels;
1106
1107                 /*
1108                  * As of now we only support importing the current acquisition
1109                  * data so we're going to stop at this point.
1110                  */
1111                 sr_dev_acquisition_stop(sdi);
1112                 return TRUE;
1113         } else
1114                 devc->current_channel = devc->current_channel->next;
1115
1116         if (dlm_channel_data_request(sdi) != SR_OK) {
1117                 sr_err("Failed to request acquisition data.");
1118                 goto fail;
1119         }
1120
1121         return TRUE;
1122
1123 fail:
1124         if (data) {
1125                 g_array_free(data, TRUE);
1126                 data = NULL;
1127         }
1128
1129         return FALSE;
1130 }