Change SIGROK_ prefix to SR_.

diff --git a/datastore.c b/datastore.c
index 4ca23a4c8e858daa2100ee6f29bc99fc1310181b..31dc770ecec3970ee3a3cad30e5c062d65bd5f02 100644 (file)
--- a/datastore.c
+++ b/datastore.c
@@ -28,19 +28,19 @@ static gpointer new_chunk(struct datastore **ds);
 int datastore_new(int unitsize, struct datastore **ds)
 {
        if (!ds)
-               return SIGROK_ERR;
+               return SR_ERR;
 
        if (unitsize <= 0)
-               return SIGROK_ERR; /* TODO: Different error? */
+               return SR_ERR; /* TODO: Different error? */
 
        if (!(*ds = g_malloc(sizeof(struct datastore))))
-               return SIGROK_ERR_MALLOC;
+               return SR_ERR_MALLOC;
 
        (*ds)->ds_unitsize = unitsize;
        (*ds)->num_units = 0;
        (*ds)->chunklist = NULL;
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 int datastore_destroy(struct datastore *ds)
@@ -48,14 +48,14 @@ int datastore_destroy(struct datastore *ds)
        GSList *chunk;
 
        if (!ds)
-               return SIGROK_ERR;
+               return SR_ERR;
 
        for (chunk = ds->chunklist; chunk; chunk = chunk->next)
                g_free(chunk->data);
        g_slist_free(ds->chunklist);
        g_free(ds);
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 void datastore_put(struct datastore *ds, void *data, unsigned int length,

diff --git a/filter.c b/filter.c
index d51471b285e2841dc34223702839e328767c445f..6b219842e5d6cc2195aa7bab265d2f78302464aa 100644 (file)
--- a/filter.c
+++ b/filter.c
@@ -36,7 +36,7 @@ int filter_probes(int in_unitsize, int out_unitsize, int *probelist,
        uint64_t sample_in, sample_out;
 
        if (!(*data_out = malloc(length_in)))
-               return SIGROK_ERR_MALLOC;
+               return SR_ERR_MALLOC;
 
        num_enabled_probes = 0;
        for (i = 0; probelist[i]; i++)
@@ -46,7 +46,7 @@ int filter_probes(int in_unitsize, int out_unitsize, int *probelist,
                /* All probes are used -- no need to compress anything. */
                memcpy(*data_out, data_in, length_in);
                *length_out = length_in;
-               return SIGROK_OK;
+               return SR_OK;
        }
 
        /* If we reached this point, not all probes are used, so "compress". */
@@ -65,5 +65,5 @@ int filter_probes(int in_unitsize, int out_unitsize, int *probelist,
        }
        *length_out = out_offset;
 
-       return SIGROK_OK;
+       return SR_OK;
 }

diff --git a/hardware/alsa/alsa.c b/hardware/alsa/alsa.c
index 7abdd56ef01ea545a1f7058bba0c37d23d1b7192..2ff25f2b5a1eba08d6959428f6637ca4b35d0eb9 100644 (file)
--- a/hardware/alsa/alsa.c
+++ b/hardware/alsa/alsa.c
@@ -79,7 +79,7 @@ static int hw_opendev(int device_index)
        int err;
 
        if (!(sdi = get_sigrok_device_instance(device_instances, device_index)))
-               return SIGROK_ERR;
+               return SR_ERR;
        alsa = sdi->priv;
 
        err = snd_pcm_open(&alsa->capture_handle, AUDIO_DEV,
@@ -87,24 +87,24 @@ static int hw_opendev(int device_index)
        if (err < 0) {
                g_warning("cannot open audio device %s (%s)", AUDIO_DEV,
                                snd_strerror(err));
-               return SIGROK_ERR;
+               return SR_ERR;
        }
 
        err = snd_pcm_hw_params_malloc(&alsa->hw_params);
        if (err < 0) {
                g_warning("cannot allocate hardware parameter structure (%s)",
                                snd_strerror(err));
-               return SIGROK_ERR;
+               return SR_ERR;
        }
 
        err = snd_pcm_hw_params_any(alsa->capture_handle, alsa->hw_params);
        if (err < 0) {
                g_warning("cannot initialize hardware parameter structure (%s)",
                                snd_strerror(err));
-               return SIGROK_ERR;
+               return SR_ERR;
        }
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 static void hw_closedev(int device_index)
@@ -182,20 +182,20 @@ static int hw_set_configuration(int device_index, int capability, void *value)
        struct alsa *alsa;
 
        if (!(sdi = get_sigrok_device_instance(device_instances, device_index)))
-               return SIGROK_ERR;
+               return SR_ERR;
        alsa = sdi->priv;
 
        switch (capability) {
        case HWCAP_PROBECONFIG:
-               return SIGROK_OK;
+               return SR_OK;
        case HWCAP_SAMPLERATE:
                alsa->cur_rate = *(uint64_t *) value;
-               return SIGROK_OK;
+               return SR_OK;
        case HWCAP_LIMIT_SAMPLES:
                alsa->limit_samples = *(uint64_t *) value;
-               return SIGROK_OK;
+               return SR_OK;
        default:
-               return SIGROK_ERR;
+               return SR_ERR;
        }
 }
 
@@ -267,14 +267,14 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
        int err;
 
        if (!(sdi = get_sigrok_device_instance(device_instances, device_index)))
-               return SIGROK_ERR;
+               return SR_ERR;
        alsa = sdi->priv;
 
        err = snd_pcm_hw_params_set_access(alsa->capture_handle,
                        alsa->hw_params, SND_PCM_ACCESS_RW_INTERLEAVED);
        if (err < 0) {
                g_warning("cannot set access type (%s)", snd_strerror(err));
-               return SIGROK_ERR;
+               return SR_ERR;
        }
 
        /* FIXME: Hardcoded for 16bits */
@@ -282,52 +282,52 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
                        alsa->hw_params, SND_PCM_FORMAT_S16_LE);
        if (err < 0) {
                g_warning("cannot set sample format (%s)", snd_strerror(err));
-               return SIGROK_ERR;
+               return SR_ERR;
        }
 
        err = snd_pcm_hw_params_set_rate_near(alsa->capture_handle,
                        alsa->hw_params, (unsigned int *) &alsa->cur_rate, 0);
        if (err < 0) {
                g_warning("cannot set sample rate (%s)", snd_strerror(err));
-               return SIGROK_ERR;
+               return SR_ERR;
        }
 
        err = snd_pcm_hw_params_set_channels(alsa->capture_handle,
                        alsa->hw_params, NUM_PROBES);
        if (err < 0) {
                g_warning("cannot set channel count (%s)", snd_strerror(err));
-               return SIGROK_ERR;
+               return SR_ERR;
        }
 
        err = snd_pcm_hw_params(alsa->capture_handle, alsa->hw_params);
        if (err < 0) {
                g_warning("cannot set parameters (%s)", snd_strerror(err));
-               return SIGROK_ERR;
+               return SR_ERR;
        }
 
        err = snd_pcm_prepare(alsa->capture_handle);
        if (err < 0) {
                g_warning("cannot prepare audio interface for use (%s)",
                                snd_strerror(err));
-               return SIGROK_ERR;
+               return SR_ERR;
        }
 
        count = snd_pcm_poll_descriptors_count(alsa->capture_handle);
        if (count < 1) {
                g_warning("Unable to obtain poll descriptors count");
-               return SIGROK_ERR;
+               return SR_ERR;
        }
 
        ufds = malloc(count * sizeof(struct pollfd));
        if (!ufds)
-               return SIGROK_ERR_MALLOC;
+               return SR_ERR_MALLOC;
 
        err = snd_pcm_poll_descriptors(alsa->capture_handle, ufds, count);
        if (err < 0) {
                g_warning("Unable to obtain poll descriptors (%s)",
                                snd_strerror(err));
                free(ufds);
-               return SIGROK_ERR;
+               return SR_ERR;
        }
 
        alsa->session_id = session_device_id;
@@ -345,7 +345,7 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
        session_bus(session_device_id, &packet);
        free(ufds);
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 static void hw_stop_acquisition(int device_index, gpointer session_device_id)

diff --git a/hardware/asix-sigma/asix-sigma.c b/hardware/asix-sigma/asix-sigma.c
index 41df8e6a171130341255edf5c02eaa2a3b5ec159..96a9b39f0cb94bd2190f27fb3a3a25e59ecb70bc 100644 (file)
--- a/hardware/asix-sigma/asix-sigma.c
+++ b/hardware/asix-sigma/asix-sigma.c
@@ -294,7 +294,7 @@ static int sigma_write_trigger_lut(struct triggerlut *lut, struct sigma *sigma)
        sigma_write_register(WRITE_TRIGGER_SELECT0, (uint8_t *) &lut->params,
                             sizeof(lut->params), sigma);
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 /* Generate the bitbang stream for programming the FPGA. */
@@ -484,7 +484,7 @@ static int upload_firmware(int firmware_idx, struct sigma *sigma)
        if (-1 == bin2bitbang(firmware_path, &buf, &buf_size)) {
                g_warning("An error occured while reading the firmware: %s",
                          firmware_path);
-               return SIGROK_ERR;
+               return SR_ERR;
        }
 
        /* Upload firmare. */
@@ -495,7 +495,7 @@ static int upload_firmware(int firmware_idx, struct sigma *sigma)
        if ((ret = ftdi_set_bitmode(&sigma->ftdic, 0x00, BITMODE_RESET)) < 0) {
                g_warning("ftdi_set_bitmode failed: %s",
                          ftdi_get_error_string(&sigma->ftdic));
-               return SIGROK_ERR;
+               return SR_ERR;
        }
 
        ftdi_usb_purge_buffers(&sigma->ftdic);
@@ -512,12 +512,12 @@ static int upload_firmware(int firmware_idx, struct sigma *sigma)
        if (ret != 3 ||
            result[0] != 0xa6 || result[1] != 0x55 || result[2] != 0xaa) {
                g_warning("Configuration failed. Invalid reply received.");
-               return SIGROK_ERR;
+               return SR_ERR;
        }
 
        sigma->cur_firmware = firmware_idx;
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 static int hw_opendev(int device_index)
@@ -527,7 +527,7 @@ static int hw_opendev(int device_index)
        int ret;
 
        if (!(sdi = get_sigrok_device_instance(device_instances, device_index)))
-               return SIGROK_ERR;
+               return SR_ERR;
 
        sigma = sdi->priv;
 
@@ -543,7 +543,7 @@ static int hw_opendev(int device_index)
 
        sdi->status = ST_ACTIVE;
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 static int set_samplerate(struct sigrok_device_instance *sdi,
@@ -557,7 +557,7 @@ static int set_samplerate(struct sigrok_device_instance *sdi,
                        break;
        }
        if (supported_samplerates[i] == 0)
-               return SIGROK_ERR_SAMPLERATE;
+               return SR_ERR_SAMPLERATE;
 
        if (samplerate <= MHZ(50)) {
                ret = upload_firmware(0, sigma);
@@ -612,7 +612,7 @@ static int configure_probes(struct sigrok_device_instance *sdi, GSList *probes)
                                g_warning("Asix Sigma only supports a single "
                                                "pin trigger in 100 and 200 "
                                                "MHz mode.");
-                               return SIGROK_ERR;
+                               return SR_ERR;
                        }
                        if (probe->trigger[0] == 'f')
                                sigma->trigger.fallingmask |= probebit;
@@ -622,7 +622,7 @@ static int configure_probes(struct sigrok_device_instance *sdi, GSList *probes)
                                g_warning("Asix Sigma only supports "
                                          "rising/falling trigger in 100 "
                                          "and 200 MHz mode.");
-                               return SIGROK_ERR;
+                               return SR_ERR;
                        }
 
                        ++trigger_set;
@@ -653,7 +653,7 @@ static int configure_probes(struct sigrok_device_instance *sdi, GSList *probes)
                        if (trigger_set > 1) {
                                g_warning("Asix Sigma only supports 1 rising/"
                                          "falling triggers.");
-                               return SIGROK_ERR;
+                               return SR_ERR;
                        }
                }
 
@@ -661,7 +661,7 @@ static int configure_probes(struct sigrok_device_instance *sdi, GSList *probes)
                        sigma->use_triggers = 1;
        }
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 static void hw_closedev(int device_index)
@@ -752,7 +752,7 @@ static int hw_set_configuration(int device_index, int capability, void *value)
        int ret;
 
        if (!(sdi = get_sigrok_device_instance(device_instances, device_index)))
-               return SIGROK_ERR;
+               return SR_ERR;
 
        sigma = sdi->priv;
 
@@ -763,17 +763,17 @@ static int hw_set_configuration(int device_index, int capability, void *value)
        } else if (capability == HWCAP_LIMIT_MSEC) {
                sigma->limit_msec = *(uint64_t*) value;
                if (sigma->limit_msec > 0)
-                       ret = SIGROK_OK;
+                       ret = SR_OK;
                else
-                       ret = SIGROK_ERR;
+                       ret = SR_ERR;
        } else if (capability == HWCAP_CAPTURE_RATIO) {
                sigma->capture_ratio = *(uint64_t*) value;
                if (sigma->capture_ratio < 0 || sigma->capture_ratio > 100)
-                       ret = SIGROK_ERR;
+                       ret = SR_ERR;
                else
-                       ret = SIGROK_OK;
+                       ret = SR_OK;
        } else {
-               ret = SIGROK_ERR;
+               ret = SR_ERR;
        }
 
        return ret;
@@ -855,7 +855,7 @@ static int decode_chunk_ts(uint8_t *buf, uint16_t *lastts,
 
                /* Decode partial chunk. */
                if (limit_chunk && ts > limit_chunk)
-                       return SIGROK_OK;
+                       return SR_OK;
 
                /* Pad last sample up to current point. */
                numpad = tsdiff * sigma->samples_per_event - clustersize;
@@ -947,7 +947,7 @@ static int decode_chunk_ts(uint8_t *buf, uint16_t *lastts,
                *lastsample = samples[n - 1];
        }
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 static int receive_data(int fd, int revents, void *user_data)
@@ -1193,7 +1193,7 @@ static int build_basic_trigger(struct triggerlut *lut, struct sigma *sigma)
        /* Triggertype: event. */
        lut->params.selres = 3;
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 static int hw_start_acquisition(int device_index, gpointer session_device_id)
@@ -1212,7 +1212,7 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
        session_device_id = session_device_id;
 
        if (!(sdi = get_sigrok_device_instance(device_instances, device_index)))
-               return SIGROK_ERR;
+               return SR_ERR;
 
        sigma = sdi->priv;
 
@@ -1311,7 +1311,7 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
 
        sigma->state.state = SIGMA_CAPTURE;
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 static void hw_stop_acquisition(int device_index, gpointer session_device_id)

diff --git a/hardware/common/serial.c b/hardware/common/serial.c
index 46d4ad0535d8c4d3b6cb65509216a800a51111cf..f6efe3e26465e30d42411adcd08e7d922479701f 100644 (file)
--- a/hardware/common/serial.c
+++ b/hardware/common/serial.c
@@ -193,7 +193,7 @@ int serial_set_params(int fd, int speed, int bits, int parity, int stopbits,
 
        if (!GetCommState(hdl, &dcb)) {
                /* TODO: Error handling. */
-               return SIGROK_ERR;
+               return SR_ERR;
        }
 
        /* TODO: Rename 'speed' to 'baudrate'. */
@@ -224,7 +224,7 @@ int serial_set_params(int fd, int speed, int bits, int parity, int stopbits,
 
        if (!SetCommState(hdl, &dcb)) {
                /* TODO: Error handling. */
-               return SIGROK_ERR;
+               return SR_ERR;
        }
 #else
        struct termios term;
@@ -247,13 +247,13 @@ int serial_set_params(int fd, int speed, int bits, int parity, int stopbits,
                baud = B460800;
                break;
        default:
-               return SIGROK_ERR;
+               return SR_ERR;
        }
 
        if (tcgetattr(fd, &term) < 0)
-               return SIGROK_ERR;
+               return SR_ERR;
        if (cfsetispeed(&term, baud) < 0)
-               return SIGROK_ERR;
+               return SR_ERR;
 
        term.c_cflag &= ~CSIZE;
        switch (bits) {
@@ -264,7 +264,7 @@ int serial_set_params(int fd, int speed, int bits, int parity, int stopbits,
                term.c_cflag |= CS7;
                break;
        default:
-               return SIGROK_ERR;
+               return SR_ERR;
        }
 
        term.c_cflag &= ~CSTOPB;
@@ -274,7 +274,7 @@ int serial_set_params(int fd, int speed, int bits, int parity, int stopbits,
        case 2:
                term.c_cflag |= CSTOPB;
        default:
-               return SIGROK_ERR;
+               return SR_ERR;
        }
 
        term.c_cflag &= ~(IXON | IXOFF | CRTSCTS);
@@ -285,7 +285,7 @@ int serial_set_params(int fd, int speed, int bits, int parity, int stopbits,
        case 1:
                term.c_cflag |= CRTSCTS;
        default:
-               return SIGROK_ERR;
+               return SR_ERR;
        }
 
        term.c_iflag &= ~IGNPAR;
@@ -301,12 +301,12 @@ int serial_set_params(int fd, int speed, int bits, int parity, int stopbits,
                term.c_cflag |= PARENB | PARODD;
                break;
        default:
-               return SIGROK_ERR;
+               return SR_ERR;
        }
 
        if (tcsetattr(fd, TCSADRAIN, &term) < 0)
-               return SIGROK_ERR;
+               return SR_ERR;
 #endif
 
-       return SIGROK_OK;
+       return SR_OK;
 }

diff --git a/hardware/demo/demo.c b/hardware/demo/demo.c
index f5f57b8d8093839f8d2b20acfda4a18d95daea41..ac7dea9a8977d79092a10b8a6c5bf9da00032ea2 100644 (file)
--- a/hardware/demo/demo.c
+++ b/hardware/demo/demo.c
@@ -111,7 +111,7 @@ static int hw_opendev(int device_index)
        device_index = device_index;
 
        /* Nothing needed so far. */
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 static void hw_closedev(int device_index)
@@ -177,28 +177,28 @@ static int hw_set_configuration(int device_index, int capability, void *value)
 
        if (capability == HWCAP_PROBECONFIG) {
                /* Nothing to do. */
-               ret = SIGROK_OK;
+               ret = SR_OK;
        } else if (capability == HWCAP_LIMIT_SAMPLES) {
                tmp_u64 = value;
                limit_samples = *tmp_u64;
-               ret = SIGROK_OK;
+               ret = SR_OK;
        } else if (capability == HWCAP_LIMIT_MSEC) {
                tmp_u64 = value;
                limit_msec = *tmp_u64;
-               ret = SIGROK_OK;
+               ret = SR_OK;
        } else if (capability == HWCAP_PATTERN_MODE) {
                stropt = value;
                if (!strcmp(stropt, "random")) {
                        default_genmode = GENMODE_RANDOM;
-                       ret = SIGROK_OK;
+                       ret = SR_OK;
                } else if (!strcmp(stropt, "incremental")) {
                        default_genmode = GENMODE_INC;
-                       ret = SIGROK_OK;
+                       ret = SR_OK;
                } else {
-                       ret = SIGROK_ERR;
+                       ret = SR_ERR;
                }
        } else {
-               ret = SIGROK_ERR;
+               ret = SR_ERR;
        }
 
        return ret;
@@ -326,7 +326,7 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
 
        mydata = malloc(sizeof(struct databag));
        if (!mydata)
-               return SIGROK_ERR_MALLOC;
+               return SR_ERR_MALLOC;
 
        mydata->sample_generator = default_genmode;
        mydata->session_device_id = session_device_id;
@@ -334,7 +334,7 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
        mydata->samples_counter = 0;
 
        if (pipe(mydata->pipe_fds))
-               return SIGROK_ERR;
+               return SR_ERR;
 
        channels[0] = g_io_channel_unix_new(mydata->pipe_fds[0]);
        channels[1] = g_io_channel_unix_new(mydata->pipe_fds[1]);
@@ -357,12 +357,12 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
        my_thread =
            g_thread_create((GThreadFunc)thread_func, mydata, TRUE, NULL);
        if (!my_thread)
-               return SIGROK_ERR;
+               return SR_ERR;
 
        packet = malloc(sizeof(struct datafeed_packet));
        header = malloc(sizeof(struct datafeed_header));
        if (!packet || !header)
-               return SIGROK_ERR_MALLOC;
+               return SR_ERR_MALLOC;
 
        packet->type = DF_HEADER;
        packet->length = sizeof(struct datafeed_header);
@@ -377,7 +377,7 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
        free(header);
        free(packet);
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 static void hw_stop_acquisition(int device_index, gpointer session_device_id)

diff --git a/hardware/link-mso19/link-mso19.c b/hardware/link-mso19/link-mso19.c
index 05729556495d0265204ead4aba3ce36a1b043dc4..4689269a21a2dc58f82ce0e5dfcf2a9dc0af29b9 100644 (file)
--- a/hardware/link-mso19/link-mso19.c
+++ b/hardware/link-mso19/link-mso19.c
@@ -86,12 +86,12 @@ static int mso_send_control_message(struct sigrok_device_instance *sdi,
        while (w < s) {
                ret = serial_write(fd, buf + w, s - w);
                if (ret < 0) {
-                       ret = SIGROK_ERR;
+                       ret = SR_ERR;
                        goto free;
                }
                w += ret;
        }
-       ret = SIGROK_OK;
+       ret = SR_OK;
 free:
        free(buf);
 ret:
@@ -142,12 +142,12 @@ static int mso_check_trigger(struct sigrok_device_instance *sdi,
        int ret;
 
        ret = mso_send_control_message(sdi, ARRAY_AND_SIZE(ops));
-       if (info == NULL || ret != SIGROK_OK)
+       if (info == NULL || ret != SR_OK)
                return ret;
 
        buf[0] = 0;
        if (serial_read(sdi->serial->fd, buf, 1) != 1) /* FIXME: Need timeout */
-               ret = SIGROK_ERR;
+               ret = SR_ERR;
        *info = buf[0];
 
        return ret;
@@ -210,13 +210,13 @@ static int mso_configure_rate(struct sigrok_device_instance *sdi,
 {
        struct mso *mso = sdi->priv;
        unsigned int i;
-       int ret = SIGROK_ERR;
+       int ret = SR_ERR;
 
        for (i = 0; i < ARRAY_SIZE(rate_map); i++) {
                if (rate_map[i].rate == rate) {
                        mso->slowmode = rate_map[i].slowmode;
                        ret = mso_clkrate_out(sdi, rate_map[i].val);
-                       if (ret == SIGROK_OK)
+                       if (ret == SR_OK)
                                mso->cur_rate = rate;
                        return ret;
                }
@@ -325,7 +325,7 @@ static int mso_parse_serial(const char *iSerial, const char *iProduct,
        /* parse iSerial */
        if (iSerial[0] != '4' || sscanf(iSerial, "%5u%3u%3u%1u%1u%6u",
                                &u1, &u2, &u3, &u4, &u5, &u6) != 6)
-               return SIGROK_ERR;
+               return SR_ERR;
        mso->hwmodel = u4;
        mso->hwrev = u5;
        mso->serial = u6;
@@ -345,7 +345,7 @@ static int mso_parse_serial(const char *iSerial, const char *iProduct,
         * I will not implement it yet
         */
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 static int hw_init(char *deviceinfo)
@@ -418,7 +418,7 @@ static int hw_init(char *deviceinfo)
                        continue;
                memset(mso, 0, sizeof(struct mso));
 
-               if (mso_parse_serial(iSerial, iProduct, mso) != SIGROK_OK) {
+               if (mso_parse_serial(iSerial, iProduct, mso) != SR_OK) {
                        g_warning("Invalid iSerial: %s", iSerial);
                        goto err_free_mso;
                }
@@ -479,7 +479,7 @@ static int hw_opendev(int device_index)
 {
        struct sigrok_device_instance *sdi;
        struct mso *mso;
-       int ret = SIGROK_ERR;
+       int ret = SR_ERR;
 
        if (!(sdi = get_sigrok_device_instance(device_instances, device_index)))
                return ret;
@@ -490,7 +490,7 @@ static int hw_opendev(int device_index)
                return ret;
 
        ret = serial_set_params(sdi->serial->fd, 460800, 8, 0, 1, 2);
-       if (ret != SIGROK_OK)
+       if (ret != SR_OK)
                return ret;
 
        sdi->status = ST_ACTIVE;
@@ -501,18 +501,18 @@ static int hw_opendev(int device_index)
 //     g_warning("trigger state: %c", mso->trigger_state);
 
        ret = mso_reset_adc(sdi);
-       if (ret != SIGROK_OK)
+       if (ret != SR_OK)
                return ret;
 
        mso_check_trigger(sdi, &mso->trigger_state);
 //     g_warning("trigger state: %c", mso->trigger_state);
 
 //     ret = mso_reset_fsm(sdi);
-//     if (ret != SIGROK_OK)
+//     if (ret != SR_OK)
 //             return ret;
 
-//     return SIGROK_ERR;
-       return SIGROK_OK;
+//     return SR_ERR;
+       return SR_OK;
 }
 
 static void hw_closedev(int device_index)
@@ -579,7 +579,7 @@ static int hw_set_configuration(int device_index, int capability, void *value)
        struct sigrok_device_instance *sdi;
 
        if (!(sdi = get_sigrok_device_instance(device_instances, device_index)))
-               return SIGROK_ERR;
+               return SR_ERR;
 
        switch (capability) {
        case HWCAP_SAMPLERATE:
@@ -587,7 +587,7 @@ static int hw_set_configuration(int device_index, int capability, void *value)
        case HWCAP_PROBECONFIG:
        case HWCAP_LIMIT_SAMPLES:
        default:
-               return SIGROK_OK; /* FIXME */
+               return SR_OK; /* FIXME */
        }
 
 }
@@ -670,7 +670,7 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
        struct mso *mso;
        struct datafeed_packet packet;
        struct datafeed_header header;
-       int ret = SIGROK_ERR;
+       int ret = SR_ERR;
 
        if (!(sdi = get_sigrok_device_instance(device_instances, device_index)))
                return ret;
@@ -678,7 +678,7 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
 
        /* FIXME: No need to do full reconfigure every time */
 //     ret = mso_reset_fsm(sdi);
-//     if (ret != SIGROK_OK)
+//     if (ret != SR_OK)
 //             return ret;
 
        /* FIXME: ACDC Mode */
@@ -686,20 +686,20 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
 //     mso->ctlbase |= mso->acdcmode;
 
        ret = mso_configure_rate(sdi, mso->cur_rate);
-       if (ret != SIGROK_OK)
+       if (ret != SR_OK)
                return ret;
 
        /* set dac offset */
        ret = mso_dac_out(sdi, mso->dac_offset);
-       if (ret != SIGROK_OK)
+       if (ret != SR_OK)
                return ret;
 
        ret = mso_configure_threshold_level(sdi);
-       if (ret != SIGROK_OK)
+       if (ret != SR_OK)
                return ret;
 
        ret = mso_configure_trigger(sdi);
-       if (ret != SIGROK_OK)
+       if (ret != SR_OK)
                return ret;
 
        /* FIXME: trigger_position */
@@ -709,17 +709,17 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
 
        /* with trigger */
        ret = mso_arm(sdi);
-       if (ret != SIGROK_OK)
+       if (ret != SR_OK)
                return ret;
 
        /* without trigger */
 //     ret = mso_force_capture(sdi);
-//     if (ret != SIGROK_OK)
+//     if (ret != SR_OK)
 //             return ret;
 
        mso_check_trigger(sdi, &mso->trigger_state);
        ret = mso_check_trigger(sdi, NULL);
-       if (ret != SIGROK_OK)
+       if (ret != SR_OK)
                return ret;
 
        mso->session_id = session_device_id;

diff --git a/hardware/openbench-logic-sniffer/ols.c b/hardware/openbench-logic-sniffer/ols.c
index 57d7aa0aba31078db7291bf22871458838a5f868..04e8649b8283e7c3eee30ef131859360a005a7bd 100644 (file)
--- a/hardware/openbench-logic-sniffer/ols.c
+++ b/hardware/openbench-logic-sniffer/ols.c
@@ -122,9 +122,9 @@ static int send_shortcommand(int fd, uint8_t command)
        g_debug("ols: sending cmd 0x%.2x", command);
        buf[0] = command;
        if (serial_write(fd, buf, 1) != 1)
-               return SIGROK_ERR;
+               return SR_ERR;
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 static int send_longcommand(int fd, uint8_t command, uint32_t data)
@@ -138,9 +138,9 @@ static int send_longcommand(int fd, uint8_t command, uint32_t data)
        buf[3] = (data & 0xff00) >> 8;
        buf[4] = data & 0xff;
        if (serial_write(fd, buf, 5) != 5)
-               return SIGROK_ERR;
+               return SR_ERR;
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 static int configure_probes(GSList *probes)
@@ -184,13 +184,13 @@ static int configure_probes(GSList *probes)
                                 * TODO: Only supporting parallel mode, with
                                 * up to 4 stages.
                                 */
-                               return SIGROK_ERR;
+                               return SR_ERR;
                }
                if (stage > num_stages)
                        num_stages = stage;
        }
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 static uint32_t reverse16(uint32_t in)
@@ -252,15 +252,15 @@ static int hw_init(char *deviceinfo)
                if (fd != -1) {
                        serial_params[devcnt] = serial_backup_params(fd);
                        serial_set_params(fd, 115200, 8, 0, 1, 2);
-                       ret = SIGROK_OK;
+                       ret = SR_OK;
                        for (i = 0; i < 5; i++) {
                                if ((ret = send_shortcommand(fd,
-                                       CMD_RESET)) != SIGROK_OK) {
+                                       CMD_RESET)) != SR_OK) {
                                        /* Serial port is not writable. */
                                        break;
                                }
                        }
-                       if (ret != SIGROK_OK) {
+                       if (ret != SR_OK) {
                                serial_restore_params(fd,
                                        serial_params[devcnt]);
                                serial_close(fd);
@@ -329,15 +329,15 @@ static int hw_opendev(int device_index)
        struct sigrok_device_instance *sdi;
 
        if (!(sdi = get_sigrok_device_instance(device_instances, device_index)))
-               return SIGROK_ERR;
+               return SR_ERR;
 
        sdi->serial->fd = serial_open(sdi->serial->port, O_RDWR);
        if (sdi->serial->fd == -1)
-               return SIGROK_ERR;
+               return SR_ERR;
 
        sdi->status = ST_ACTIVE;
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 static void hw_closedev(int device_index)
@@ -421,7 +421,7 @@ static int set_configuration_samplerate(struct sigrok_device_instance *sdi,
        uint32_t divider;
 
        if (samplerate < samplerates.low || samplerate > samplerates.high)
-               return SIGROK_ERR_SAMPLERATE;
+               return SR_ERR_SAMPLERATE;
 
        if (samplerate > CLOCK_RATE) {
                flag_reg |= FLAG_DEMUX;
@@ -434,11 +434,11 @@ static int set_configuration_samplerate(struct sigrok_device_instance *sdi,
        g_message("ols: setting samplerate to %" PRIu64 " Hz (divider %u, demux %s)",
                        samplerate, divider, flag_reg & FLAG_DEMUX ? "on" : "off");
 
-       if (send_longcommand(sdi->serial->fd, CMD_SET_DIVIDER, reverse32(divider)) != SIGROK_OK)
-               return SIGROK_ERR;
+       if (send_longcommand(sdi->serial->fd, CMD_SET_DIVIDER, reverse32(divider)) != SR_OK)
+               return SR_ERR;
        cur_samplerate = samplerate;
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 static int hw_set_configuration(int device_index, int capability, void *value)
@@ -448,10 +448,10 @@ static int hw_set_configuration(int device_index, int capability, void *value)
        uint64_t *tmp_u64;
 
        if (!(sdi = get_sigrok_device_instance(device_instances, device_index)))
-               return SIGROK_ERR;
+               return SR_ERR;
 
        if (sdi->status != ST_ACTIVE)
-               return SIGROK_ERR;
+               return SR_ERR;
 
        switch (capability) {
        case HWCAP_SAMPLERATE:
@@ -464,22 +464,22 @@ static int hw_set_configuration(int device_index, int capability, void *value)
        case HWCAP_LIMIT_SAMPLES:
                tmp_u64 = value;
                if (*tmp_u64 < MIN_NUM_SAMPLES)
-                       return SIGROK_ERR;
+                       return SR_ERR;
                limit_samples = *tmp_u64;
                g_message("ols: sample limit %" PRIu64, limit_samples);
-               ret = SIGROK_OK;
+               ret = SR_OK;
                break;
        case HWCAP_CAPTURE_RATIO:
                tmp_u64 = value;
                capture_ratio = *tmp_u64;
                if (capture_ratio < 0 || capture_ratio > 100) {
                        capture_ratio = 0;
-                       ret = SIGROK_ERR;
+                       ret = SR_ERR;
                } else
-                       ret = SIGROK_OK;
+                       ret = SR_OK;
                break;
        default:
-               ret = SIGROK_ERR;
+               ret = SR_ERR;
        }
 
        return ret;
@@ -659,10 +659,10 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
        uint8_t changrp_mask;
 
        if (!(sdi = get_sigrok_device_instance(device_instances, device_index)))
-               return SIGROK_ERR;
+               return SR_ERR;
 
        if (sdi->status != ST_ACTIVE)
-               return SIGROK_ERR;
+               return SR_ERR;
 
        readcount = limit_samples / 4;
 
@@ -673,54 +673,54 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
                trigger_at = (readcount - delaycount) * 4 - num_stages;
 
                if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_MASK_0,
-                       reverse32(trigger_mask[0])) != SIGROK_OK)
-                       return SIGROK_ERR;
+                       reverse32(trigger_mask[0])) != SR_OK)
+                       return SR_ERR;
                if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_VALUE_0,
-                       reverse32(trigger_value[0])) != SIGROK_OK)
-                       return SIGROK_ERR;
+                       reverse32(trigger_value[0])) != SR_OK)
+                       return SR_ERR;
                if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_CONFIG_0,
-                       trigger_config[0]) != SIGROK_OK)
-                       return SIGROK_ERR;
+                       trigger_config[0]) != SR_OK)
+                       return SR_ERR;
 
                if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_MASK_1,
-                       reverse32(trigger_mask[1])) != SIGROK_OK)
-                       return SIGROK_ERR;
+                       reverse32(trigger_mask[1])) != SR_OK)
+                       return SR_ERR;
                if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_VALUE_1,
-                       reverse32(trigger_value[1])) != SIGROK_OK)
-                       return SIGROK_ERR;
+                       reverse32(trigger_value[1])) != SR_OK)
+                       return SR_ERR;
                if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_CONFIG_1,
-                       trigger_config[1]) != SIGROK_OK)
-                       return SIGROK_ERR;
+                       trigger_config[1]) != SR_OK)
+                       return SR_ERR;
 
                if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_MASK_2,
-                       reverse32(trigger_mask[2])) != SIGROK_OK)
-                       return SIGROK_ERR;
+                       reverse32(trigger_mask[2])) != SR_OK)
+                       return SR_ERR;
                if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_VALUE_2,
-                       reverse32(trigger_value[2])) != SIGROK_OK)
-                       return SIGROK_ERR;
+                       reverse32(trigger_value[2])) != SR_OK)
+                       return SR_ERR;
                if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_CONFIG_2,
-                       trigger_config[2]) != SIGROK_OK)
-                       return SIGROK_ERR;
+                       trigger_config[2]) != SR_OK)
+                       return SR_ERR;
 
                if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_MASK_3,
-                       reverse32(trigger_mask[3])) != SIGROK_OK)
-                       return SIGROK_ERR;
+                       reverse32(trigger_mask[3])) != SR_OK)
+                       return SR_ERR;
                if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_VALUE_3,
-                       reverse32(trigger_value[3])) != SIGROK_OK)
-                       return SIGROK_ERR;
+                       reverse32(trigger_value[3])) != SR_OK)
+                       return SR_ERR;
                if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_CONFIG_3,
-                       trigger_config[3]) != SIGROK_OK)
-                       return SIGROK_ERR;
+                       trigger_config[3]) != SR_OK)
+                       return SR_ERR;
        } else {
                if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_MASK_0,
-                    trigger_mask[0]) != SIGROK_OK)
-                       return SIGROK_ERR;
+                    trigger_mask[0]) != SR_OK)
+                       return SR_ERR;
                if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_VALUE_0,
-                    trigger_value[0]) != SIGROK_OK)
-                       return SIGROK_ERR;
+                    trigger_value[0]) != SR_OK)
+                       return SR_ERR;
                if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_CONFIG_0,
-                    0x00000008) != SIGROK_OK)
-                       return SIGROK_ERR;
+                    0x00000008) != SR_OK)
+                       return SR_ERR;
                delaycount = readcount;
        }
 
@@ -729,8 +729,8 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
        /* Send sample limit and pre/post-trigger capture ratio. */
        data = ((readcount - 1) & 0xffff) << 16;
        data |= (delaycount - 1) & 0xffff;
-       if (send_longcommand(sdi->serial->fd, CMD_CAPTURE_SIZE, reverse16(data)) != SIGROK_OK)
-               return SIGROK_ERR;
+       if (send_longcommand(sdi->serial->fd, CMD_CAPTURE_SIZE, reverse16(data)) != SR_OK)
+               return SR_ERR;
 
        /*
         * Enable/disable channel groups in the flag register according to the
@@ -746,12 +746,12 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
        flag_reg |= ~(changrp_mask << 2) & 0x3c;
        flag_reg |= FLAG_FILTER;
        data = flag_reg << 24;
-       if (send_longcommand(sdi->serial->fd, CMD_SET_FLAGS, data) != SIGROK_OK)
-               return SIGROK_ERR;
+       if (send_longcommand(sdi->serial->fd, CMD_SET_FLAGS, data) != SR_OK)
+               return SR_ERR;
 
        /* Start acquisition on the device. */
-       if (send_shortcommand(sdi->serial->fd, CMD_RUN) != SIGROK_OK)
-               return SIGROK_ERR;
+       if (send_shortcommand(sdi->serial->fd, CMD_RUN) != SR_OK)
+               return SR_ERR;
 
        source_add(sdi->serial->fd, G_IO_IN, -1, receive_data,
                   session_device_id);
@@ -760,7 +760,7 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
        packet = g_malloc(sizeof(struct datafeed_packet));
        header = g_malloc(sizeof(struct datafeed_header));
        if (!packet || !header)
-               return SIGROK_ERR;
+               return SR_ERR;
        packet->type = DF_HEADER;
        packet->length = sizeof(struct datafeed_header);
        packet->payload = (unsigned char *)header;
@@ -774,7 +774,7 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
        g_free(header);
        g_free(packet);
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 static void hw_stop_acquisition(int device_index, gpointer session_device_id)

diff --git a/hardware/saleae-logic/saleae-logic.c b/hardware/saleae-logic/saleae-logic.c
index be4892a796cdc0f714235ed0c2914fdf61534f5a..2273964845a4e39ebe6e011de3519dedc75f3692 100644 (file)
--- a/hardware/saleae-logic/saleae-logic.c
+++ b/hardware/saleae-logic/saleae-logic.c
@@ -271,7 +271,7 @@ static int configure_probes(GSList *probes)
                                trigger_value[stage] |= probe_bit;
                        stage++;
                        if (stage > NUM_TRIGGER_STAGES)
-                               return SIGROK_ERR;
+                               return SR_ERR;
                }
        }
 
@@ -284,7 +284,7 @@ static int configure_probes(GSList *probes)
        else
                trigger_stage = 0;
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 /*
@@ -375,23 +375,23 @@ static int hw_opendev(int device_index)
 
        if (!(sdi = sl_open_device(device_index))) {
                g_warning("unable to open device");
-               return SIGROK_ERR;
+               return SR_ERR;
        }
 
        err = libusb_claim_interface(sdi->usb->devhdl, USB_INTERFACE);
        if (err != 0) {
                g_warning("Unable to claim interface: %d", err);
-               return SIGROK_ERR;
+               return SR_ERR;
        }
 
        if (cur_samplerate == 0) {
                /* Samplerate hasn't been set; default to the slowest one. */
                if (hw_set_configuration(device_index, HWCAP_SAMPLERATE,
-                   &supported_samplerates[0]) == SIGROK_ERR)
-                       return SIGROK_ERR;
+                   &supported_samplerates[0]) == SR_ERR)
+                       return SR_ERR;
        }
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 static void hw_closedev(int device_index)
@@ -478,7 +478,7 @@ static int set_configuration_samplerate(struct sigrok_device_instance *sdi,
                        break;
        }
        if (supported_samplerates[i] == 0)
-               return SIGROK_ERR_SAMPLERATE;
+               return SR_ERR_SAMPLERATE;
 
        divider = (uint8_t) (48 / (samplerate / 1000000.0)) - 1;
 
@@ -490,11 +490,11 @@ static int set_configuration_samplerate(struct sigrok_device_instance *sdi,
                                   buf, 2, &result, 500);
        if (ret != 0) {
                g_warning("failed to set samplerate: %d", ret);
-               return SIGROK_ERR;
+               return SR_ERR;
        }
        cur_samplerate = samplerate;
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 static int hw_set_configuration(int device_index, int capability, void *value)
@@ -504,7 +504,7 @@ static int hw_set_configuration(int device_index, int capability, void *value)
        uint64_t *tmp_u64;
 
        if (!(sdi = get_sigrok_device_instance(device_instances, device_index)))
-               return SIGROK_ERR;
+               return SR_ERR;
 
        if (capability == HWCAP_SAMPLERATE) {
                tmp_u64 = value;
@@ -514,9 +514,9 @@ static int hw_set_configuration(int device_index, int capability, void *value)
        } else if (capability == HWCAP_LIMIT_SAMPLES) {
                tmp_u64 = value;
                limit_samples = *tmp_u64;
-               ret = SIGROK_OK;
+               ret = SR_OK;
        } else {
-               ret = SIGROK_ERR;
+               ret = SR_ERR;
        }
 
        return ret;
@@ -678,12 +678,12 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
        unsigned char *buf;
 
        if (!(sdi = get_sigrok_device_instance(device_instances, device_index)))
-               return SIGROK_ERR;
+               return SR_ERR;
 
        packet = g_malloc(sizeof(struct datafeed_packet));
        header = g_malloc(sizeof(struct datafeed_header));
        if (!packet || !header)
-               return SIGROK_ERR;
+               return SR_ERR;
 
        /* Start with 2K transfer, subsequently increased to 4K. */
        size = 2048;
@@ -697,7 +697,7 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
                        /* TODO: Free them all. */
                        libusb_free_transfer(transfer);
                        g_free(buf);
-                       return SIGROK_ERR;
+                       return SR_ERR;
                }
                size = 4096;
        }
@@ -721,7 +721,7 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
        g_free(header);
        g_free(packet);
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 /* This stops acquisition on ALL devices, ignoring device_index. */

diff --git a/hardware/zeroplus-logic-cube/zeroplus.c b/hardware/zeroplus-logic-cube/zeroplus.c
index 1c5f2cef0488d128ed0a2a1e30838f14a9aedebe..639547afb52bba66335d9b279a8e7d22faf23db1 100644 (file)
--- a/hardware/zeroplus-logic-cube/zeroplus.c
+++ b/hardware/zeroplus-logic-cube/zeroplus.c
@@ -261,12 +261,12 @@ static int configure_probes(GSList *probes)
                                        trigger_value[stage] |= probe_bit;
                                stage++;
                                if (stage > NUM_TRIGGER_STAGES)
-                                       return SIGROK_ERR;
+                                       return SR_ERR;
                        }
                }
        }
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 /*
@@ -330,13 +330,13 @@ static int hw_opendev(int device_index)
 
        if (!(sdi = zp_open_device(device_index))) {
                g_warning("unable to open device");
-               return SIGROK_ERR;
+               return SR_ERR;
        }
 
        err = libusb_claim_interface(sdi->usb->devhdl, USB_INTERFACE);
        if (err != 0) {
                g_warning("Unable to claim interface: %d", err);
-               return SIGROK_ERR;
+               return SR_ERR;
        }
        analyzer_reset(sdi->usb->devhdl);
        analyzer_initialize(sdi->usb->devhdl);
@@ -361,11 +361,11 @@ static int hw_opendev(int device_index)
        if (cur_samplerate == 0) {
                /* Samplerate hasn't been set. Default to the slowest one. */
                if (hw_set_configuration(device_index, HWCAP_SAMPLERATE,
-                    &samplerates.low) == SIGROK_ERR)
-                       return SIGROK_ERR;
+                    &samplerates.low) == SR_ERR)
+                       return SR_ERR;
        }
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 static void hw_closedev(int device_index)
@@ -453,7 +453,7 @@ static int set_configuration_samplerate(uint64_t samplerate)
 
        cur_samplerate = samplerate;
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 static int hw_set_configuration(int device_index, int capability, void *value)
@@ -462,7 +462,7 @@ static int hw_set_configuration(int device_index, int capability, void *value)
        uint64_t *tmp_u64;
 
        if (!(sdi = get_sigrok_device_instance(device_instances, device_index)))
-               return SIGROK_ERR;
+               return SR_ERR;
 
        switch (capability) {
        case HWCAP_SAMPLERATE:
@@ -473,9 +473,9 @@ static int hw_set_configuration(int device_index, int capability, void *value)
        case HWCAP_LIMIT_SAMPLES:
                tmp_u64 = value;
                limit_samples = *tmp_u64;
-               return SIGROK_OK;
+               return SR_OK;
        default:
-               return SIGROK_ERR;
+               return SR_ERR;
        }
 }
 
@@ -489,7 +489,7 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
        unsigned char *buf;
 
        if (!(sdi = get_sigrok_device_instance(device_instances, device_index)))
-               return SIGROK_ERR;
+               return SR_ERR;
 
        /* push configured settings to device */
        analyzer_configure(sdi->usb->devhdl);
@@ -518,7 +518,7 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
 
        buf = g_malloc(PACKET_SIZE);
        if (!buf)
-               return SIGROK_ERR;
+               return SR_ERR;
        analyzer_read_start(sdi->usb->devhdl);
        /* Send the incoming transfer to the session bus. */
        for (packet_num = 0; packet_num < (memory_size * 4 / PACKET_SIZE);
@@ -541,7 +541,7 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
        packet.type = DF_END;
        session_bus(session_device_id, &packet);
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 /* This stops acquisition on ALL devices, ignoring device_index. */

diff --git a/hwplugin.c b/hwplugin.c
index 1f3a34ba3814ba7734f35dc2549db6862475f687..a826cd9eb8ef768ea2a11ee6b56b5259781b9fef 100644 (file)
--- a/hwplugin.c
+++ b/hwplugin.c
@@ -91,7 +91,7 @@ int load_hwplugins(void)
 #endif
 
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 GSList *list_hwplugins(void)

diff --git a/input/input_binary.c b/input/input_binary.c
index ef9bddcb7e017dab9bc4c9f7d30cda3e8ee0f524..7581341adf058aa0bb381e248ee967c3786e14c6 100644 (file)
--- a/input/input_binary.c
+++ b/input/input_binary.c
@@ -46,14 +46,14 @@ static int init(struct input *in)
        if (in->param && in->param[0]) {
                num_probes = strtoul(in->param, NULL, 10);
                if (num_probes < 1)
-                       return SIGROK_ERR;
+                       return SR_ERR;
        } else
                num_probes = DEFAULT_NUM_PROBES;
 
        /* create a virtual device */
        in->vdevice = device_new(NULL, 0, num_probes);
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 static int loadfile(struct input *in, const char *filename)
@@ -64,7 +64,7 @@ static int loadfile(struct input *in, const char *filename)
        int fd, size, num_probes;
 
        if ((fd = open(filename, O_RDONLY)) == -1)
-               return SIGROK_ERR;
+               return SR_ERR;
 
        num_probes = g_slist_length(in->vdevice->probes);
 
@@ -95,7 +95,7 @@ static int loadfile(struct input *in, const char *filename)
        packet.length = 0;
        session_bus(in->vdevice, &packet);
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 struct input_format input_binary = {

diff --git a/output/output_analog.c b/output/output_analog.c
index b68f60faf1767b9f53be08afebac067e3df77b0f..075dcb2a11e479c30dc8fc303ac51ed731fefd89 100644 (file)
--- a/output/output_analog.c
+++ b/output/output_analog.c
@@ -99,7 +99,7 @@ static int init(struct output *o, int default_spl, enum outputmode mode)
        char *samplerate_s;
 
        if (!(ctx = calloc(1, sizeof(struct context))))
-               return SIGROK_ERR_MALLOC;
+               return SR_ERR_MALLOC;
 
        o->internal = ctx;
        ctx->num_enabled_probes = 0;
@@ -122,13 +122,13 @@ static int init(struct output *o, int default_spl, enum outputmode mode)
        if (o->param && o->param[0]) {
                ctx->samples_per_line = strtoul(o->param, NULL, 10);
                if (ctx->samples_per_line < 1)
-                       return SIGROK_ERR;
+                       return SR_ERR;
        } else
                ctx->samples_per_line = default_spl;
 
        if (!(ctx->header = malloc(512))) {
                free(ctx);
-               return SIGROK_ERR_MALLOC;
+               return SR_ERR_MALLOC;
        }
 
        snprintf(ctx->header, 511, "%s\n", PACKAGE_STRING);
@@ -139,7 +139,7 @@ static int init(struct output *o, int default_spl, enum outputmode mode)
                if (!(samplerate_s = sigrok_samplerate_string(samplerate))) {
                        free(ctx->header);
                        free(ctx);
-                       return SIGROK_ERR;
+                       return SR_ERR;
                }
                snprintf(ctx->header + strlen(ctx->header),
                         511 - strlen(ctx->header),
@@ -152,15 +152,15 @@ static int init(struct output *o, int default_spl, enum outputmode mode)
        if (!(ctx->linebuf = calloc(1, num_probes * ctx->linebuf_len))) {
                free(ctx->header);
                free(ctx);
-               return SIGROK_ERR_MALLOC;
+               return SR_ERR_MALLOC;
        }
        if (!(ctx->linevalues = calloc(1, num_probes))) {
                free(ctx->header);
                free(ctx);
-               return SIGROK_ERR_MALLOC;
+               return SR_ERR_MALLOC;
        }
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 static int event(struct output *o, int event_type, char **data_out,
@@ -181,7 +181,7 @@ static int event(struct output *o, int event_type, char **data_out,
                outsize = ctx->num_enabled_probes
                                * (ctx->samples_per_line + 20) + 512;
                if (!(outbuf = calloc(1, outsize)))
-                       return SIGROK_ERR_MALLOC;
+                       return SR_ERR_MALLOC;
                flush_linebufs(ctx, outbuf);
                *data_out = outbuf;
                *length_out = strlen(outbuf);
@@ -194,7 +194,7 @@ static int event(struct output *o, int event_type, char **data_out,
                break;
        }
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 static int init_bits(struct output *o)
@@ -222,7 +222,7 @@ static int data_bits(struct output *o, char *data_in, uint64_t length_in,
             * (ctx->num_enabled_probes * max_linelen);
 
        if (!(outbuf = calloc(1, outsize + 1)))
-               return SIGROK_ERR_MALLOC;
+               return SR_ERR_MALLOC;
 
        outbuf[0] = '\0';
        if (ctx->header) {
@@ -280,7 +280,7 @@ static int data_bits(struct output *o, char *data_in, uint64_t length_in,
        *data_out = outbuf;
        *length_out = strlen(outbuf);
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 #if 0
 static int init_hex(struct output *o)
@@ -304,7 +304,7 @@ static int data_hex(struct output *o, char *data_in, uint64_t length_in,
                        / ctx->samples_per_line * max_linelen + 512;
 
        if (!(outbuf = calloc(1, outsize + 1)))
-               return SIGROK_ERR_MALLOC;
+               return SR_ERR_MALLOC;
 
        outbuf[0] = '\0';
        if (ctx->header) {
@@ -345,7 +345,7 @@ static int data_hex(struct output *o, char *data_in, uint64_t length_in,
        *data_out = outbuf;
        *length_out = strlen(outbuf);
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 static int init_ascii(struct output *o)
@@ -373,7 +373,7 @@ static int data_ascii(struct output *o, char *data_in, uint64_t length_in,
             * (ctx->num_enabled_probes * max_linelen);
 
        if (!(outbuf = calloc(1, outsize + 1)))
-               return SIGROK_ERR_MALLOC;
+               return SR_ERR_MALLOC;
 
        outbuf[0] = '\0';
        if (ctx->header) {
@@ -434,7 +434,7 @@ static int data_ascii(struct output *o, char *data_in, uint64_t length_in,
        *data_out = outbuf;
        *length_out = strlen(outbuf);
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 #endif
 

diff --git a/output/output_binary.c b/output/output_binary.c
index 2e6603d583c398da62580aa7dd4181038f3ae108..1c93da90189d758a7dbf7f0f75ec652e6c2e8844 100644 (file)
--- a/output/output_binary.c
+++ b/output/output_binary.c
@@ -34,13 +34,13 @@ static int data(struct output *o, char *data_in, uint64_t length_in,
        o = o;
 
        if (!(outbuf = calloc(1, length_in)))
-               return SIGROK_ERR_MALLOC;
+               return SR_ERR_MALLOC;
 
        memcpy(outbuf, data_in, length_in);
        *data_out = outbuf;
        *length_out = length_in;
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 struct output_format output_binary = {

diff --git a/output/output_gnuplot.c b/output/output_gnuplot.c
index 05da1e1aa9fc36e8666d5a7f5782db02880a5e14..4fd81f2da7092f9564185c325a05ff2d563c603e 100644 (file)
--- a/output/output_gnuplot.c
+++ b/output/output_gnuplot.c
@@ -59,11 +59,11 @@ static int init(struct output *o)
        time_t t;
 
        if (!(ctx = calloc(1, sizeof(struct context))))
-               return SIGROK_ERR_MALLOC;
+               return SR_ERR_MALLOC;
 
        if (!(ctx->header = calloc(1, MAX_HEADER_LEN + 1))) {
                free(ctx);
-               return SIGROK_ERR_MALLOC;
+               return SR_ERR_MALLOC;
        }
 
        o->internal = ctx;
@@ -85,7 +85,7 @@ static int init(struct output *o)
                if (!(frequency_s = sigrok_samplerate_string(samplerate))) {
                        free(ctx->header);
                        free(ctx);
-                       return SIGROK_ERR;
+                       return SR_ERR;
                }
                snprintf(comment, 127, gnuplot_header_comment,
                        ctx->num_enabled_probes, num_probes, frequency_s);
@@ -102,7 +102,7 @@ static int init(struct output *o)
        if (!(frequency_s = sigrok_period_string(samplerate))) {
                free(ctx->header);
                free(ctx);
-               return SIGROK_ERR;
+               return SR_ERR;
        }
        t = time(NULL);
        b = snprintf(ctx->header, MAX_HEADER_LEN, gnuplot_header,
@@ -113,7 +113,7 @@ static int init(struct output *o)
        if (b < 0) {
                free(ctx->header);
                free(ctx);
-               return SIGROK_ERR;
+               return SR_ERR;
        }
 
        return 0;
@@ -138,7 +138,7 @@ static int event(struct output *o, int event_type, char **data_out,
        *data_out = NULL;
        *length_out = 0;
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 static int data(struct output *o, char *data_in, uint64_t length_in,
@@ -157,7 +157,7 @@ static int data(struct output *o, char *data_in, uint64_t length_in,
                outsize += strlen(ctx->header);
 
        if (!(outbuf = calloc(1, outsize)))
-               return SIGROK_ERR_MALLOC;
+               return SR_ERR_MALLOC;
 
        outbuf[0] = '\0';
        if (ctx->header) {
@@ -188,7 +188,7 @@ static int data(struct output *o, char *data_in, uint64_t length_in,
        *data_out = outbuf;
        *length_out = strlen(outbuf);
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 static int analog_init(struct output *o)
@@ -204,11 +204,11 @@ static int analog_init(struct output *o)
        time_t t;
 
        if (!(ctx = calloc(1, sizeof(struct context))))
-               return SIGROK_ERR_MALLOC;
+               return SR_ERR_MALLOC;
 
        if (!(ctx->header = calloc(1, MAX_HEADER_LEN + 1))) {
                free(ctx);
-               return SIGROK_ERR_MALLOC;
+               return SR_ERR_MALLOC;
        }
 
        o->internal = ctx;
@@ -232,7 +232,7 @@ static int analog_init(struct output *o)
                if (!(frequency_s = sigrok_samplerate_string(samplerate))) {
                        free(ctx->header);
                        free(ctx);
-                       return SIGROK_ERR;
+                       return SR_ERR;
                }
                snprintf(comment, 127, gnuplot_header_comment,
                        ctx->num_enabled_probes, num_probes, frequency_s);
@@ -249,7 +249,7 @@ static int analog_init(struct output *o)
        if (!(frequency_s = sigrok_period_string(samplerate))) {
                free(ctx->header);
                free(ctx);
-               return SIGROK_ERR;
+               return SR_ERR;
        }
        t = time(NULL);
        b = snprintf(ctx->header, MAX_HEADER_LEN, gnuplot_header,
@@ -260,7 +260,7 @@ static int analog_init(struct output *o)
        if (b < 0) {
                free(ctx->header);
                free(ctx);
-               return SIGROK_ERR;
+               return SR_ERR;
        }
 
        return 0;
@@ -284,7 +284,7 @@ static int analog_data(struct output *o, char *data_in, uint64_t length_in,
                outsize += strlen(ctx->header);
 
        if (!(outbuf = calloc(1, outsize)))
-               return SIGROK_ERR_MALLOC;
+               return SR_ERR_MALLOC;
 
        outbuf[0] = '\0';
        if (ctx->header) {
@@ -323,7 +323,7 @@ static int analog_data(struct output *o, char *data_in, uint64_t length_in,
        *data_out = outbuf;
        *length_out = strlen(outbuf);
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 struct output_format output_gnuplot = {

diff --git a/output/output_ols.c b/output/output_ols.c
index a288ad50210fb312d99f91b88347b2b74741aad1..acf10af66981a0224aeb37b91d96f0fd5c9988a1 100644 (file)
--- a/output/output_ols.c
+++ b/output/output_ols.c
@@ -79,11 +79,11 @@ static int init(struct output *o)
        time_t t;
 
        if (!(ctx = calloc(1, sizeof(struct context))))
-               return SIGROK_ERR_MALLOC;
+               return SR_ERR_MALLOC;
 
        if (!(ctx->header = calloc(1, MAX_HEADER_LEN + 1))) {
                free(ctx);
-               return SIGROK_ERR_MALLOC;
+               return SR_ERR_MALLOC;
        }
 
        o->internal = ctx;
@@ -108,7 +108,7 @@ static int init(struct output *o)
                if (!(frequency_s = sigrok_samplerate_string(samplerate))) {
                        free(ctx->header);
                        free(ctx);
-                       return SIGROK_ERR;
+                       return SR_ERR;
                }
                snprintf(comment, 127, ols_header_comment,
                         ctx->num_enabled_probes, num_probes, frequency_s);
@@ -125,7 +125,7 @@ static int init(struct output *o)
        if (!(frequency_s = sigrok_period_string(samplerate))) {
                free(ctx->header);
                free(ctx);
-               return SIGROK_ERR;
+               return SR_ERR;
        }
 
        t = time(NULL);
@@ -149,7 +149,7 @@ static int init(struct output *o)
        if (b < 0) {
                free(ctx->header);
                free(ctx);
-               return SIGROK_ERR;
+               return SR_ERR;
        }
 
        return 0;
@@ -174,7 +174,7 @@ static int event(struct output *o, int event_type, char **data_out,
        *data_out = NULL;
        *length_out = 0;
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 static int data(struct output *o, char *data_in, uint64_t length_in,
@@ -193,7 +193,7 @@ static int data(struct output *o, char *data_in, uint64_t length_in,
                outsize += strlen(ctx->header);
 
        if (!(outbuf = calloc(1, outsize)))
-               return SIGROK_ERR_MALLOC;
+               return SR_ERR_MALLOC;
 
        outbuf[0] = '\0';
        if (ctx->header) {
@@ -215,7 +215,7 @@ static int data(struct output *o, char *data_in, uint64_t length_in,
        *data_out = outbuf;
        *length_out = strlen(outbuf);
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 struct output_format output_ols = {

diff --git a/output/output_skeleton.c b/output/output_skeleton.c
index 91ee9171e73c1a522b2c9995d6f57e36ba2c2254..669a29cdb41eafd43d71ee7210c52d9a91ea8e94 100644 (file)
--- a/output/output_skeleton.c
+++ b/output/output_skeleton.c
@@ -28,13 +28,13 @@ static int init(struct output *o)
 static int data(struct output *o, char *data_in, uint64_t length_in,
                char **data_out, uint64_t *length_out)
 {
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 static int event(struct output *o, int event_type, char **data_out,
                 uint64_t *length_out)
 {
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 struct output_format output_foo = {

diff --git a/output/output_vcd.c b/output/output_vcd.c
index b21bfb92d83d17b87816011ba84b0c9165b812fb..06bb7f4578a9da34b087097bc3b3c62232f8ca97 100644 (file)
--- a/output/output_vcd.c
+++ b/output/output_vcd.c
@@ -59,7 +59,7 @@ static int init(struct output *o)
        time_t t;
 
        if (!(ctx = calloc(1, sizeof(struct context))))
-               return SIGROK_ERR_MALLOC;
+               return SR_ERR_MALLOC;
 
        o->internal = ctx;
        ctx->num_enabled_probes = 0;
@@ -72,7 +72,7 @@ static int init(struct output *o)
        }
        if (ctx->num_enabled_probes > 94) {
                g_warning("VCD only supports 94 probes.");
-               return SIGROK_ERR;
+               return SR_ERR;
        }
 
        ctx->probelist[ctx->num_enabled_probes] = 0;
@@ -97,7 +97,7 @@ static int init(struct output *o)
                if (!((samplerate_s = sigrok_samplerate_string(ctx->samplerate)))) {
                        g_string_free(ctx->header, TRUE);
                        free(ctx);
-                       return SIGROK_ERR;
+                       return SR_ERR;
                }
                g_string_append_printf(ctx->header, vcd_header_comment,
                                 ctx->num_enabled_probes, num_probes, samplerate_s);
@@ -115,7 +115,7 @@ static int init(struct output *o)
        if (!(frequency_s = sigrok_period_string(ctx->period))) {
                g_string_free(ctx->header, TRUE);
                free(ctx);
-               return SIGROK_ERR;
+               return SR_ERR;
        }
        g_string_append_printf(ctx->header, "$timescale %s $end\n", frequency_s);
        free(frequency_s);
@@ -135,10 +135,10 @@ static int init(struct output *o)
        if (!(ctx->prevbits = calloc(sizeof(int), num_probes))) {
                g_string_free(ctx->header, TRUE);
                free(ctx);
-               return SIGROK_ERR_MALLOC;
+               return SR_ERR_MALLOC;
        }
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 static int event(struct output *o, int event_type, char **data_out,
@@ -162,7 +162,7 @@ static int event(struct output *o, int event_type, char **data_out,
                break;
        }
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 static int data(struct output *o, char *data_in, uint64_t length_in,
@@ -219,7 +219,7 @@ static int data(struct output *o, char *data_in, uint64_t length_in,
        *length_out = out->len;
        g_string_free(out, FALSE);
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 struct output_format output_vcd = {

diff --git a/output/text/ascii.c b/output/text/ascii.c
index b9f08254a54b4fd4dfaba69f5c7146fd233c8404..27f5d74217e0fc19fa61f6566770831d43a5b98d 100644 (file)
--- a/output/text/ascii.c
+++ b/output/text/ascii.c
@@ -50,7 +50,7 @@ int data_ascii(struct output *o, char *data_in, uint64_t length_in,
             * (ctx->num_enabled_probes * max_linelen);
 
        if (!(outbuf = calloc(1, outsize + 1)))
-               return SIGROK_ERR_MALLOC;
+               return SR_ERR_MALLOC;
 
        outbuf[0] = '\0';
        if (ctx->header) {
@@ -111,7 +111,7 @@ int data_ascii(struct output *o, char *data_in, uint64_t length_in,
        *data_out = outbuf;
        *length_out = strlen(outbuf);
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 

diff --git a/output/text/bits.c b/output/text/bits.c
index c124ece5a6c5f596c313ce0318a9690e87695336..75662b80b00711bcc80f63dac16db8930f2be0fc 100644 (file)
--- a/output/text/bits.c
+++ b/output/text/bits.c
@@ -50,7 +50,7 @@ int data_bits(struct output *o, char *data_in, uint64_t length_in,
             * (ctx->num_enabled_probes * max_linelen);
 
        if (!(outbuf = calloc(1, outsize + 1)))
-               return SIGROK_ERR_MALLOC;
+               return SR_ERR_MALLOC;
 
        outbuf[0] = '\0';
        if (ctx->header) {
@@ -98,7 +98,7 @@ int data_bits(struct output *o, char *data_in, uint64_t length_in,
        *data_out = outbuf;
        *length_out = strlen(outbuf);
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 

diff --git a/output/text/hex.c b/output/text/hex.c
index 39f12134988017ed37953de44b5433f093362612..943ce01cee6420da10627f55699e69ff6b3e4e24 100644 (file)
--- a/output/text/hex.c
+++ b/output/text/hex.c
@@ -46,7 +46,7 @@ int data_hex(struct output *o, char *data_in, uint64_t length_in,
                        / ctx->samples_per_line * max_linelen + 512;
 
        if (!(outbuf = calloc(1, outsize + 1)))
-               return SIGROK_ERR_MALLOC;
+               return SR_ERR_MALLOC;
 
        outbuf[0] = '\0';
        if (ctx->header) {
@@ -87,7 +87,7 @@ int data_hex(struct output *o, char *data_in, uint64_t length_in,
        *data_out = outbuf;
        *length_out = strlen(outbuf);
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 

diff --git a/output/text/text.c b/output/text/text.c
index 84e41e45b7ce7fc757dcd78308959b51faa30979..8a8e66ad9b00776bb186347709baa9dbe6d26a24 100644 (file)
--- a/output/text/text.c
+++ b/output/text/text.c
@@ -74,7 +74,7 @@ int init(struct output *o, int default_spl, enum outputmode mode)
        char *samplerate_s;
 
        if (!(ctx = calloc(1, sizeof(struct context))))
-               return SIGROK_ERR_MALLOC;
+               return SR_ERR_MALLOC;
 
        o->internal = ctx;
        ctx->num_enabled_probes = 0;
@@ -96,13 +96,13 @@ int init(struct output *o, int default_spl, enum outputmode mode)
        if (o->param && o->param[0]) {
                ctx->samples_per_line = strtoul(o->param, NULL, 10);
                if (ctx->samples_per_line < 1)
-                       return SIGROK_ERR;
+                       return SR_ERR;
        } else
                ctx->samples_per_line = default_spl;
 
        if (!(ctx->header = malloc(512))) {
                free(ctx);
-               return SIGROK_ERR_MALLOC;
+               return SR_ERR_MALLOC;
        }
 
        snprintf(ctx->header, 511, "%s\n", PACKAGE_STRING);
@@ -113,7 +113,7 @@ int init(struct output *o, int default_spl, enum outputmode mode)
                if (!(samplerate_s = sigrok_samplerate_string(samplerate))) {
                        free(ctx->header);
                        free(ctx);
-                       return SIGROK_ERR;
+                       return SR_ERR;
                }
                snprintf(ctx->header + strlen(ctx->header),
                         511 - strlen(ctx->header),
@@ -126,15 +126,15 @@ int init(struct output *o, int default_spl, enum outputmode mode)
        if (!(ctx->linebuf = calloc(1, num_probes * ctx->linebuf_len))) {
                free(ctx->header);
                free(ctx);
-               return SIGROK_ERR_MALLOC;
+               return SR_ERR_MALLOC;
        }
        if (!(ctx->linevalues = calloc(1, num_probes))) {
                free(ctx->header);
                free(ctx);
-               return SIGROK_ERR_MALLOC;
+               return SR_ERR_MALLOC;
        }
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 int event(struct output *o, int event_type, char **data_out,
@@ -155,7 +155,7 @@ int event(struct output *o, int event_type, char **data_out,
                outsize = ctx->num_enabled_probes
                                * (ctx->samples_per_line + 20) + 512;
                if (!(outbuf = calloc(1, outsize)))
-                       return SIGROK_ERR_MALLOC;
+                       return SR_ERR_MALLOC;
                flush_linebufs(ctx, outbuf);
                *data_out = outbuf;
                *length_out = strlen(outbuf);
@@ -168,6 +168,6 @@ int event(struct output *o, int event_type, char **data_out,
                break;
        }
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 

diff --git a/session.c b/session.c
index 13b7a241a9cbf43555d72a5acf35e9c86577b7ef..ec4ae6fb1b9b4cbeed7d39e3e845137bd64b192a 100644 (file)
--- a/session.c
+++ b/session.c
@@ -89,13 +89,13 @@ int session_device_add(struct device *device)
 
        if (device->plugin && device->plugin->open) {
                ret = device->plugin->open(device->plugin_index);
-               if (ret != SIGROK_OK)
+               if (ret != SR_OK)
                        return ret;
        }
 
        session->devices = g_slist_append(session->devices, device);
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 void session_pa_clear(void)
@@ -135,7 +135,7 @@ int session_start(void)
        for (l = session->devices; l; l = l->next) {
                device = l->data;
                if ((ret = device->plugin->start_acquisition(
-                               device->plugin_index, device)) != SIGROK_OK)
+                               device->plugin_index, device)) != SR_OK)
                        break;
        }
 
@@ -244,23 +244,23 @@ int session_save(char *filename)
        /* Quietly delete it first, libzip wants replace ops otherwise. */
        unlink(newfn);
        if (!(zipfile = zip_open(newfn, ZIP_CREATE, &error)))
-               return SIGROK_ERR;
+               return SR_ERR;
        g_free(newfn);
 
        /* "version" */
        version[0] = '1';
        if (!(versrc = zip_source_buffer(zipfile, version, 1, 0)))
-               return SIGROK_ERR;
+               return SR_ERR;
        if (zip_add(zipfile, "version", versrc) == -1) {
                g_message("error saving version into zipfile: %s",
                          zip_strerror(zipfile));
-               return SIGROK_ERR;
+               return SR_ERR;
        }
 
        /* init "metadata" */
        strcpy(metafile, "sigrok-meta-XXXXXX");
        if ((tmpfile = g_mkstemp(metafile)) == -1)
-               return SIGROK_ERR;
+               return SR_ERR;
        close(tmpfile);
        meta = fopen(metafile, "wb");
        fprintf(meta, "sigrok version = %s\n", PACKAGE_VERSION);
@@ -303,28 +303,28 @@ int session_save(char *filename)
                        }
                        if (!(logicsrc = zip_source_buffer(zipfile, buf,
                                       ds->num_units * ds->ds_unitsize, TRUE)))
-                               return SIGROK_ERR;
+                               return SR_ERR;
                        snprintf(rawname, 15, "logic-%d", devcnt);
                        if (zip_add(zipfile, rawname, logicsrc) == -1)
-                               return SIGROK_ERR;
+                               return SR_ERR;
                }
                devcnt++;
        }
        fclose(meta);
 
        if (!(metasrc = zip_source_file(zipfile, metafile, 0, -1)))
-               return SIGROK_ERR;
+               return SR_ERR;
        if (zip_add(zipfile, "metadata", metasrc) == -1)
-               return SIGROK_ERR;
+               return SR_ERR;
 
        if ((ret = zip_close(zipfile)) == -1) {
                g_message("error saving zipfile: %s", zip_strerror(zipfile));
-               return SIGROK_ERR;
+               return SR_ERR;
        }
 
        unlink(metafile);
 
-       return SIGROK_OK;
+       return SR_OK;
 }
 
 void session_source_add(int fd, int events, int timeout,

diff --git a/sigrok.h b/sigrok.h
index 72f3229e0bd795d8957e609c7918d86f9dbef0a5..a2d707ac7f3b9ab88bd5e21b99caa45f7529818c 100644 (file)
--- a/sigrok.h
+++ b/sigrok.h
@@ -48,10 +48,10 @@ extern "C" {
  * or reused for different #defines later. You can only add new #defines and
  * return codes, but never remove or redefine existing ones.
  */
-#define SIGROK_OK                 0 /* No error */
-#define SIGROK_ERR               -1 /* Generic/unspecified error */
-#define SIGROK_ERR_MALLOC        -2 /* Malloc/calloc/realloc error */
-#define SIGROK_ERR_SAMPLERATE    -3 /* Incorrect samplerate */
+#define SR_OK                 0 /* No error */
+#define SR_ERR               -1 /* Generic/unspecified error */
+#define SR_ERR_MALLOC        -2 /* Malloc/calloc/realloc error */
+#define SR_ERR_SAMPLERATE    -3 /* Incorrect samplerate */
 
 /* limited by uint64_t */
 #define MAX_NUM_PROBES 64