lecroy-xstream: Random whitespace/style fixes

diff --git a/src/hardware/lecroy-xstream/api.c b/src/hardware/lecroy-xstream/api.c
index e20c5adc1d1dd5e5d17483337190b9a25d347455..2bcf2cd00567443e0c2f7ef4cd4bc8a8fe548365 100644 (file)
--- a/src/hardware/lecroy-xstream/api.c
+++ b/src/hardware/lecroy-xstream/api.c
@@ -83,7 +83,6 @@ static struct sr_dev_inst *probe_device(struct sr_scpi_dev_inst *scpi)
        hw_info = NULL;
 
        devc = g_malloc0(sizeof(struct dev_context));
-
        sdi->priv = devc;
 
        if (lecroy_xstream_init_device(sdi) != SR_OK)
@@ -132,7 +131,7 @@ static int dev_close(struct sr_dev_inst *sdi)
 }
 
 static int config_get(uint32_t key, GVariant **data,
-       const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
+               const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
 {
        int idx;
        struct dev_context *devc;
@@ -166,8 +165,8 @@ static int config_get(uint32_t key, GVariant **data,
                if ((idx = std_cg_idx(cg, devc->analog_groups, model->analog_channels)) < 0)
                        return SR_ERR_ARG;
                *data = g_variant_new("(tt)",
-                       (*model->vdivs)[state->analog_channels[idx].vdiv][0],
-                       (*model->vdivs)[state->analog_channels[idx].vdiv][1]);
+                               (*model->vdivs)[state->analog_channels[idx].vdiv][0],
+                               (*model->vdivs)[state->analog_channels[idx].vdiv][1]);
                break;
        case SR_CONF_TRIGGER_SOURCE:
                *data = g_variant_new_string((*model->trigger_sources)[state->trigger_source]);
@@ -197,7 +196,7 @@ static int config_get(uint32_t key, GVariant **data,
 }
 
 static int config_set(uint32_t key, GVariant *data,
-       const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
+               const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
 {
        int ret, idx, j;
        char command[MAX_COMMAND_SIZE];
@@ -228,7 +227,7 @@ static int config_set(uint32_t key, GVariant *data,
                        return SR_ERR_ARG;
                state->trigger_source = idx;
                g_snprintf(command, sizeof(command),
-                       "SET TRIGGER SOURCE %s", (*model->trigger_sources)[idx]);
+                               "SET TRIGGER SOURCE %s", (*model->trigger_sources)[idx]);
                ret = sr_scpi_send(sdi->conn, command);
                break;
        case SR_CONF_VDIV:
@@ -238,9 +237,8 @@ static int config_set(uint32_t key, GVariant *data,
                        return SR_ERR_ARG;
                state->analog_channels[j].vdiv = idx;
                g_snprintf(command, sizeof(command),
-                       "C%d:VDIV %E", j + 1, (float) (*model->vdivs)[idx][0] / (*model->vdivs)[idx][1]);
-               if (sr_scpi_send(sdi->conn, command) != SR_OK ||
-                   sr_scpi_get_opc(sdi->conn) != SR_OK)
+                               "C%d:VDIV %E", j + 1, (float) (*model->vdivs)[idx][0] / (*model->vdivs)[idx][1]);
+               if (sr_scpi_send(sdi->conn, command) != SR_OK || sr_scpi_get_opc(sdi->conn) != SR_OK)
                        return SR_ERR;
                ret = SR_OK;
                break;
@@ -249,7 +247,7 @@ static int config_set(uint32_t key, GVariant *data,
                        return SR_ERR_ARG;
                state->timebase = idx;
                g_snprintf(command, sizeof(command),
-                       "TIME_DIV %E", (float) (*model->timebases)[idx][0] / (*model->timebases)[idx][1]);
+                               "TIME_DIV %E", (float) (*model->timebases)[idx][0] / (*model->timebases)[idx][1]);
                ret = sr_scpi_send(sdi->conn, command);
                update_sample_rate = TRUE;
                break;
@@ -261,9 +259,9 @@ static int config_set(uint32_t key, GVariant *data,
 
                state->horiz_triggerpos = tmp_d;
                tmp_d = -(tmp_d - 0.5) *
-                       ((double)(*model->timebases)[state->timebase][0] /
-                        (*model->timebases)[state->timebase][1])
-                        * model->num_xdivs;
+                               ((double)(*model->timebases)[state->timebase][0] /
+                               (*model->timebases)[state->timebase][1])
+                               * model->num_xdivs;
 
                g_snprintf(command, sizeof(command), "TRIG POS %e S", tmp_d);
 
@@ -274,7 +272,7 @@ static int config_set(uint32_t key, GVariant *data,
                        return SR_ERR_ARG;
                state->trigger_slope = idx;
                g_snprintf(command, sizeof(command),
-                       "SET TRIGGER SLOPE %s", (*model->trigger_slopes)[idx]);
+                               "SET TRIGGER SLOPE %s", (*model->trigger_slopes)[idx]);
                ret = sr_scpi_send(sdi->conn, command);
                break;
        case SR_CONF_COUPLING:
@@ -285,8 +283,7 @@ static int config_set(uint32_t key, GVariant *data,
                state->analog_channels[j].coupling = idx;
                g_snprintf(command, sizeof(command), "C%d:COUPLING %s",
                                j + 1, (*model->coupling_options)[idx]);
-               if (sr_scpi_send(sdi->conn, command) != SR_OK ||
-                   sr_scpi_get_opc(sdi->conn) != SR_OK)
+               if (sr_scpi_send(sdi->conn, command) != SR_OK || sr_scpi_get_opc(sdi->conn) != SR_OK)
                        return SR_ERR;
                ret = SR_OK;
                break;
@@ -305,7 +302,7 @@ static int config_set(uint32_t key, GVariant *data,
 }
 
 static int config_list(uint32_t key, GVariant **data,
-       const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
+               const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
 {
        struct dev_context *devc;
        const struct scope_config *model;
@@ -358,14 +355,12 @@ SR_PRIV int lecroy_xstream_request_data(const struct sr_dev_inst *sdi)
        struct dev_context *devc;
 
        devc = sdi->priv;
-
        ch = devc->current_channel->data;
 
        if (ch->type != SR_CHANNEL_ANALOG)
                return SR_ERR;
 
-       g_snprintf(command, sizeof(command),
-               "COMM_FORMAT DEF9,WORD,BIN;C%d:WAVEFORM?", ch->index + 1);
+       g_snprintf(command, sizeof(command), "C%d:WAVEFORM?", ch->index + 1);
        return sr_scpi_send(sdi->conn, command);
 }
 
@@ -391,10 +386,11 @@ static int setup_channels(const struct sr_dev_inst *sdi)
                        if (ch->enabled == state->analog_channels[ch->index].state)
                                break;
                        g_snprintf(command, sizeof(command), "C%d:TRACE %s",
-                                  ch->index + 1, ch->enabled ? "ON" : "OFF");
+                                       ch->index + 1, ch->enabled ? "ON" : "OFF");
 
                        if (sr_scpi_send(scpi, command) != SR_OK)
                                return SR_ERR;
+
                        state->analog_channels[ch->index].state = ch->enabled;
                        setup_changed = TRUE;
                        break;

diff --git a/src/hardware/lecroy-xstream/protocol.c b/src/hardware/lecroy-xstream/protocol.c
index ce06c9b4cf7f66ccb78a53bb791935097c6198b8..1d0c37e0bcf62da55d61ed127f28e1c83b71f664 100644 (file)
--- a/src/hardware/lecroy-xstream/protocol.c
+++ b/src/hardware/lecroy-xstream/protocol.c
@@ -75,9 +75,9 @@ struct lecroy_wavedesc {
 } __attribute__((packed));
 
 static const char *coupling_options[] = {
-       "A1M", // AC with 1 MOhm termination
-       "D50", // DC with 50 Ohm termination
-       "D1M", // DC with 1 MOhm termination
+       "A1M", ///< AC with 1 MOhm termination
+       "D50", ///< DC with 50 Ohm termination
+       "D1M", ///< DC with 1 MOhm termination
        "GND",
        "OVL",
 };
@@ -193,22 +193,22 @@ static const struct scope_config scope_models[] = {
 };
 
 static void scope_state_dump(const struct scope_config *config,
-                            struct scope_state *state)
+               struct scope_state *state)
 {
        unsigned int i;
        char *tmp;
 
        for (i = 0; i < config->analog_channels; i++) {
                tmp = sr_voltage_string((*config->vdivs)[state->analog_channels[i].vdiv][0],
-                                       (*config->vdivs)[state->analog_channels[i].vdiv][1]);
+                               (*config->vdivs)[state->analog_channels[i].vdiv][1]);
                sr_info("State of analog channel %d -> %s : %s (coupling) %s (vdiv) %2.2e (offset)",
-                       i + 1, state->analog_channels[i].state ? "On" : "Off",
-                       (*config->coupling_options)[state->analog_channels[i].coupling],
-                       tmp, state->analog_channels[i].vertical_offset);
+                               i + 1, state->analog_channels[i].state ? "On" : "Off",
+                               (*config->coupling_options)[state->analog_channels[i].coupling],
+                               tmp, state->analog_channels[i].vertical_offset);
        }
 
        tmp = sr_period_string((*config->timebases)[state->timebase][0],
-                               (*config->timebases)[state->timebase][1]);
+                       (*config->timebases)[state->timebase][1]);
        sr_info("Current timebase: %s", tmp);
        g_free(tmp);
 
@@ -217,13 +217,13 @@ static void scope_state_dump(const struct scope_config *config,
        g_free(tmp);
 
        sr_info("Current trigger: %s (source), %s (slope) %.2f (offset)",
-               (*config->trigger_sources)[state->trigger_source],
-               (*config->trigger_slopes)[state->trigger_slope],
-               state->horiz_triggerpos);
+                       (*config->trigger_sources)[state->trigger_source],
+                       (*config->trigger_slopes)[state->trigger_slope],
+                       state->horiz_triggerpos);
 }
 
 static int scope_state_get_array_option(const char *resp,
-       const char *(*array)[], unsigned int n, int *result)
+               const char *(*array)[], unsigned int n, int *result)
 {
        unsigned int i;
 
@@ -269,8 +269,7 @@ static int array_float_get(gchar *value, const uint64_t array[][2],
 }
 
 static int analog_channel_state_get(struct sr_scpi_dev_inst *scpi,
-                                   const struct scope_config *config,
-                                   struct scope_state *state)
+               const struct scope_config *config, struct scope_state *state)
 {
        unsigned int i, j;
        char command[MAX_COMMAND_SIZE];
@@ -288,7 +287,7 @@ static int analog_channel_state_get(struct sr_scpi_dev_inst *scpi,
                if (sr_scpi_get_string(scpi, command, &tmp_str) != SR_OK)
                        return SR_ERR;
 
-                if (array_float_get(tmp_str, ARRAY_AND_SIZE(vdivs), &j) != SR_OK) {
+               if (array_float_get(tmp_str, ARRAY_AND_SIZE(vdivs), &j) != SR_OK) {
                        g_free(tmp_str);
                        sr_err("Could not determine array index for vertical div scale.");
                        return SR_ERR;
@@ -391,18 +390,20 @@ SR_PRIV int lecroy_xstream_state_get(struct sr_dev_inst *sdi)
                i++;
        }
 
-       if (!trig_source || scope_state_get_array_option(trig_source, config->trigger_sources, config->num_trigger_sources, &state->trigger_source) != SR_OK)
+       if (!trig_source || scope_state_get_array_option(trig_source,
+                       config->trigger_sources, config->num_trigger_sources,
+                       &state->trigger_source) != SR_OK)
                return SR_ERR;
 
        g_snprintf(command, sizeof(command), "%s:TRIG_SLOPE?", trig_source);
        if (sr_scpi_get_string(sdi->conn, command, &tmp_str) != SR_OK)
                return SR_ERR;
 
-       if (scope_state_get_array_option(tmp_str,
-               config->trigger_slopes, config->num_trigger_slopes, &state->trigger_slope) != SR_OK)
+       if (scope_state_get_array_option(tmp_str, config->trigger_slopes,
+                       config->num_trigger_slopes, &state->trigger_slope) != SR_OK)
                return SR_ERR;
 
-       if (sr_scpi_get_float(sdi->conn, "TRIG_DELAY?", &state->horiz_triggerpos) != SR_OK)
+       if (sr_scpi_get_float(sdi->conn, "TRIG_DELAY?", &state->horiz_triggerpos) != SR_OK)
                return SR_ERR;
 
        if (lecroy_xstream_update_sample_rate(sdi) != SR_OK)
@@ -464,7 +465,7 @@ SR_PRIV int lecroy_xstream_init_device(struct sr_dev_inst *sdi)
 
        /* Set the desired response and format modes. */
        sr_scpi_send(sdi->conn, "COMM_HEADER OFF");
-       sr_scpi_send(sdi->conn, "COMM_FORMAT OFF,WORD,BIN");
+       sr_scpi_send(sdi->conn, "COMM_FORMAT DEF9,WORD,BIN");
 
        devc->analog_groups = g_malloc0(sizeof(struct sr_channel_group*) *
                                scope_models[model_index].analog_channels);
@@ -479,7 +480,7 @@ SR_PRIV int lecroy_xstream_init_device(struct sr_dev_inst *sdi)
                g_snprintf(command, sizeof(command), "C%d:VDIV?", i + 1);
 
                ch = sr_channel_new(sdi, i, SR_CHANNEL_ANALOG, channel_enabled,
-                          (*scope_models[model_index].analog_names)[i]);
+                       (*scope_models[model_index].analog_names)[i]);
 
                devc->analog_groups[i] = g_malloc0(sizeof(struct sr_channel_group));
 
@@ -488,21 +489,18 @@ SR_PRIV int lecroy_xstream_init_device(struct sr_dev_inst *sdi)
                devc->analog_groups[i]->channels = g_slist_append(NULL, ch);
 
                sdi->channel_groups = g_slist_append(sdi->channel_groups,
-                                                  devc->analog_groups[i]);
+                       devc->analog_groups[i]);
        }
 
        devc->model_config = &scope_models[model_index];
        devc->frame_limit = 0;
-
-       if (!(devc->model_state = scope_state_new(devc->model_config)))
-               return SR_ERR_MALLOC;
+       devc->model_state = scope_state_new(devc->model_config);
 
        return SR_OK;
 }
 
 static int lecroy_waveform_2_x_to_analog(GByteArray *data,
-                                        struct lecroy_wavedesc *desc,
-                                        struct sr_datafeed_analog *analog)
+               struct lecroy_wavedesc *desc, struct sr_datafeed_analog *analog)
 {
        struct sr_analog_encoding *encoding = analog->encoding;
        struct sr_analog_meaning *meaning = analog->meaning;
@@ -514,9 +512,9 @@ static int lecroy_waveform_2_x_to_analog(GByteArray *data,
        data_float = g_malloc(desc->version_2_x.wave_array_count * sizeof(float));
        num_samples = desc->version_2_x.wave_array_count;
 
-       waveform_data = (int16_t *)(data->data +
-                                   + desc->version_2_x.wave_descriptor_length
-                                   + desc->version_2_x.user_text_len);
+       waveform_data = (int16_t*)(data->data +
+               + desc->version_2_x.wave_descriptor_length
+               + desc->version_2_x.user_text_len);
 
        for (i = 0; i < num_samples; i++)
                data_float[i] = (float)waveform_data[i]
@@ -554,23 +552,21 @@ static int lecroy_waveform_2_x_to_analog(GByteArray *data,
 }
 
 static int lecroy_waveform_to_analog(GByteArray *data,
-                                    struct sr_datafeed_analog *analog)
+               struct sr_datafeed_analog *analog)
 {
        struct lecroy_wavedesc *desc;
 
        if (data->len < sizeof(struct lecroy_wavedesc))
                return SR_ERR;
 
-       desc = (struct lecroy_wavedesc *)data->data;
+       desc = (struct lecroy_wavedesc*)data->data;
 
        if (!strncmp(desc->template_name, "LECROY_2_2", 16) ||
            !strncmp(desc->template_name, "LECROY_2_3", 16)) {
                return lecroy_waveform_2_x_to_analog(data, desc, analog);
        }
 
-       sr_err("Waveformat template '%.16s' not supported.",
-              desc->template_name);
-
+       sr_err("Waveformat template '%.16s' not supported.", desc->template_name);
        return SR_ERR;
 }