libsigrok: Use sr_err() et al instead of printf.

[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..35db8402f7b64a99eebb24304c9ede8fe1f3437a 100644 (file)
--- a/hardware/openbench-logic-sniffer/ols.c
+++ b/hardware/openbench-logic-sniffer/ols.c
@@ -554,8 +554,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 +562,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 +602,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 +618,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 (!strcmp(value, "on")) {
                        sr_info("ols: enabling RLE");
                        ols->flag_reg |= FLAG_RLE;
                }
@@ -675,35 +683,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 +740,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 +748,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 +774,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 +843,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 +855,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;