sr: zp: Add missing <string.h> #include.

[libsigrok.git] / hardware / openbench-logic-sniffer / ols.c

diff --git a/hardware/openbench-logic-sniffer/ols.c b/hardware/openbench-logic-sniffer/ols.c
index 88e585f0d3c1f53a1cc88d3bf7e8a864b924306f..724aa43b613dcb89d7180ebea9cc026bcbb1d3ac 100644 (file)
--- a/hardware/openbench-logic-sniffer/ols.c
+++ b/hardware/openbench-logic-sniffer/ols.c
@@ -38,8 +38,8 @@
 #include <arpa/inet.h>
 #endif
 #include <glib.h>
-#include <sigrok.h>
-#include <sigrok-internal.h>
+#include "sigrok.h"
+#include "sigrok-internal.h"
 #include "ols.h"
 
 #ifdef _WIN32
@@ -55,6 +55,42 @@ static int capabilities[] = {
        0,
 };
 
+static const char *probe_names[NUM_PROBES + 1] = {
+       "0",
+       "1",
+       "2",
+       "3",
+       "4",
+       "5",
+       "6",
+       "7",
+       "8",
+       "9",
+       "10",
+       "11",
+       "12",
+       "13",
+       "14",
+       "15",
+       "16",
+       "17",
+       "18",
+       "19",
+       "20",
+       "21",
+       "22",
+       "23",
+       "24",
+       "25",
+       "26",
+       "27",
+       "28",
+       "29",
+       "30",
+       "31",
+       NULL,
+};
+
 /* default supported samplerates, can be overridden by device metadata */
 static struct sr_samplerates samplerates = {
        SR_HZ(10),
@@ -513,6 +549,9 @@ static void *hw_get_device_info(int device_index, int device_info_id)
        case SR_DI_NUM_PROBES:
                info = GINT_TO_POINTER(NUM_PROBES);
                break;
+       case SR_DI_PROBE_NAMES:
+               info = probe_names;
+               break;
        case SR_DI_SAMPLERATES:
                info = &samplerates;
                break;
@@ -554,8 +593,6 @@ static int set_configuration_samplerate(struct sr_device_instance *sdi,
        } else if (samplerate < samplerates.low || samplerate > samplerates.high)
                return SR_ERR_SAMPLERATE;
 
-       ols->cur_samplerate = samplerate;
-       ols->period_ps = 1000000000000 / samplerate;
        if (samplerate > CLOCK_RATE) {
                ols->flag_reg |= FLAG_DEMUX;
                ols->cur_samplerate_divider = (CLOCK_RATE * 2 / samplerate) - 1;
@@ -564,6 +601,17 @@ static int set_configuration_samplerate(struct sr_device_instance *sdi,
                ols->cur_samplerate_divider = (CLOCK_RATE / samplerate) - 1;
        }
 
+       /* Calculate actual samplerate used and complain if it is different
+        * from the requested.
+        */
+       ols->cur_samplerate = CLOCK_RATE / (ols->cur_samplerate_divider + 1);
+       if(ols->flag_reg & FLAG_DEMUX)
+               ols->cur_samplerate *= 2;
+       ols->period_ps = 1000000000000 / ols->cur_samplerate;
+       if(ols->cur_samplerate != samplerate)
+               sr_warn("ols: can't match samplerate %" PRIu64 ", using %" PRIu64, 
+                       samplerate, ols->cur_samplerate);
+
        return SR_OK;
 }
 
@@ -593,9 +641,8 @@ static int hw_set_configuration(int device_index, int capability, void *value)
                tmp_u64 = value;
                if (*tmp_u64 < MIN_NUM_SAMPLES)
                        return SR_ERR;
-               if (*tmp_u64 > ols->max_samples) 
+               if (*tmp_u64 > ols->max_samples)
                        sr_warn("ols: sample limit exceeds hw max");
-
                ols->limit_samples = *tmp_u64;
                sr_info("ols: sample limit %" PRIu64, ols->limit_samples);
                ret = SR_OK;
@@ -610,7 +657,7 @@ static int hw_set_configuration(int device_index, int capability, void *value)
                        ret = SR_OK;
                break;
        case SR_HWCAP_RLE:
-               if(strcmp(value, "on") == 0) {
+               if (GPOINTER_TO_INT(value)) {
                        sr_info("ols: enabling RLE");
                        ols->flag_reg |= FLAG_RLE;
                }
@@ -675,35 +722,36 @@ static int receive_data(int fd, int revents, void *session_data)
                if (serial_read(fd, &byte, 1) != 1)
                        return FALSE;
 
-               /* Ignore it if we've read enough */
-               if(ols->num_samples >= ols->limit_samples) 
-                       return TRUE; 
+               /* Ignore it if we've read enough. */
+               if (ols->num_samples >= ols->limit_samples)
+                       return TRUE;
 
                ols->sample[ols->num_bytes++] = byte;
                sr_dbg("ols: received byte 0x%.2x", byte);
                if (ols->num_bytes == num_channels) {
                        /* Got a full sample. */
                        sr_dbg("ols: received sample 0x%.*x",
-                              ols->num_bytes * 2, *(int*)ols->sample);
+                              ols->num_bytes * 2, *(int *)ols->sample);
                        if (ols->flag_reg & FLAG_RLE) {
                                /*
                                 * In RLE mode -1 should never come in as a
                                 * sample, because bit 31 is the "count" flag.
                                 */
                                if (ols->sample[ols->num_bytes - 1] & 0x80) {
-                                       ols->sample[ols->num_bytes - 1] &= 0x7F;
-                                       /* FIXME: This will only work on 
-                                        * little-endian systems 
+                                       ols->sample[ols->num_bytes - 1] &= 0x7f;
+                                       /*
+                                        * FIXME: This will only work on
+                                        * little-endian systems.
                                         */
-                                       ols->rle_count = *(int*)(ols->sample);
+                                       ols->rle_count = *(int *)(ols->sample);
                                        sr_dbg("ols: RLE count = %d", ols->rle_count);
                                        ols->num_bytes = 0;
                                        return TRUE;
-                               } 
+                               }
                        }
                        ols->num_samples += ols->rle_count + 1;
-                       if(ols->num_samples > ols->limit_samples) {
-                               /* Save us from overrunning the buffer */
+                       if (ols->num_samples > ols->limit_samples) {
+                               /* Save us from overrunning the buffer. */
                                ols->rle_count -= ols->num_samples - ols->limit_samples;
                                ols->num_samples = ols->limit_samples;
                        }
@@ -731,7 +779,7 @@ static int receive_data(int fd, int revents, void *session_data)
                                        }
                                }
                                memcpy(ols->sample, ols->tmp_sample, 4);
-                               sr_dbg("ols: full sample 0x%.8x", *(int*)ols->sample);
+                               sr_dbg("ols: full sample 0x%.8x", *(int *)ols->sample);
                        }
 
                        /* the OLS sends its sample buffer backwards.
@@ -739,9 +787,10 @@ static int receive_data(int fd, int revents, void *session_data)
                         * this on the session bus later.
                         */
                        offset = (ols->limit_samples - ols->num_samples) * 4;
-                       for(i = 0; i <= ols->rle_count; i++)
-                               memcpy(ols->raw_sample_buf + offset + (i*4), ols->sample, 4);
-
+                       for (i = 0; i <= ols->rle_count; i++) {
+                               memcpy(ols->raw_sample_buf + offset + (i * 4),
+                                      ols->sample, 4);
+                       }
                        memset(ols->sample, 0, 4);
                        ols->num_bytes = 0;
                        ols->rle_count = 0;
@@ -764,7 +813,7 @@ static int receive_data(int fd, int revents, void *session_data)
                                packet.payload = &logic;
                                logic.length = ols->trigger_at * 4;
                                logic.unitsize = 4;
-                               logic.data = ols->raw_sample_buf + 
+                               logic.data = ols->raw_sample_buf +
                                        (ols->limit_samples - ols->num_samples) * 4;
                                sr_session_bus(session_data, &packet);
                        }
@@ -833,7 +882,7 @@ static int hw_start_acquisition(int device_index, gpointer session_data)
 
        /*
         * Enable/disable channel groups in the flag register according to the
-        * probe mask.  Calculate this here, because num_channels is needed
+        * probe mask. Calculate this here, because num_channels is needed
         * to limit readcount.
         */
        changrp_mask = 0;
@@ -845,7 +894,8 @@ static int hw_start_acquisition(int device_index, gpointer session_data)
                }
        }
 
-       /* Limit readcount to prevent reading past the end of the hardware
+       /*
+        * Limit readcount to prevent reading past the end of the hardware
         * buffer.
         */
        readcount = MIN(ols->max_samples / num_channels, ols->limit_samples) / 4;
@@ -968,7 +1018,7 @@ static void hw_stop_acquisition(int device_index, gpointer session_device_id)
        struct sr_datafeed_packet packet;
 
        /* Avoid compiler warnings. */
-       device_index = device_index;
+       (void)device_index;
 
        packet.type = SR_DF_END;
        sr_session_bus(session_device_id, &packet);