Change all sigrok_ prefixes to sr_.

[libsigrok.git] / hardware / link-mso19 / link-mso19.c

diff --git a/hardware/link-mso19/link-mso19.c b/hardware/link-mso19/link-mso19.c
index 16176ffa287fca8bc7b39a13e427584fffccfd7b..9f2b46a273032f1048f267581a06d14ddaa12713 100644 (file)
--- a/hardware/link-mso19/link-mso19.c
+++ b/hardware/link-mso19/link-mso19.c
@@ -28,6 +28,7 @@
 #include <libudev.h>
 #include <sigrok.h>
 #include <arpa/inet.h>
+#include <sigrok-internal.h>
 #include "config.h"
 #include "link-mso19.h"
 
@@ -57,7 +58,7 @@ static struct samplerates samplerates = {
 
 static GSList *device_instances = NULL;
 
-static int mso_send_control_message(struct sigrok_device_instance *sdi,
+static int mso_send_control_message(struct sr_device_instance *sdi,
                uint16_t payload[], int n)
 {
        int fd = sdi->serial->fd;
@@ -85,19 +86,19 @@ 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:
        return ret;
 }
 
-static int mso_reset_adc(struct sigrok_device_instance *sdi)
+static int mso_reset_adc(struct sr_device_instance *sdi)
 {
        struct mso *mso = sdi->priv;
        uint16_t ops[2];
@@ -109,7 +110,7 @@ static int mso_reset_adc(struct sigrok_device_instance *sdi)
        return mso_send_control_message(sdi, ARRAY_AND_SIZE(ops));
 }
 
-static int mso_reset_fsm(struct sigrok_device_instance *sdi)
+static int mso_reset_fsm(struct sr_device_instance *sdi)
 {
        struct mso *mso = sdi->priv;
        uint16_t ops[1];
@@ -120,7 +121,7 @@ static int mso_reset_fsm(struct sigrok_device_instance *sdi)
        return mso_send_control_message(sdi, ARRAY_AND_SIZE(ops));
 }
 
-static int mso_toggle_led(struct sigrok_device_instance *sdi, int state)
+static int mso_toggle_led(struct sr_device_instance *sdi, int state)
 {
        struct mso *mso = sdi->priv;
        uint16_t ops[1];
@@ -133,7 +134,7 @@ static int mso_toggle_led(struct sigrok_device_instance *sdi, int state)
        return mso_send_control_message(sdi, ARRAY_AND_SIZE(ops));
 }
 
-static int mso_check_trigger(struct sigrok_device_instance *sdi,
+static int mso_check_trigger(struct sr_device_instance *sdi,
                uint8_t *info)
 {
        uint16_t ops[] = { mso_trans(REG_TRIGGER, 0) };
@@ -141,25 +142,25 @@ 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;
 }
 
-static int mso_read_buffer(struct sigrok_device_instance *sdi)
+static int mso_read_buffer(struct sr_device_instance *sdi)
 {
        uint16_t ops[] = { mso_trans(REG_BUFFER, 0) };
 
        return mso_send_control_message(sdi, ARRAY_AND_SIZE(ops));
 }
 
-static int mso_arm(struct sigrok_device_instance *sdi)
+static int mso_arm(struct sr_device_instance *sdi)
 {
        struct mso *mso = sdi->priv;
        uint16_t ops[] = {
@@ -171,7 +172,7 @@ static int mso_arm(struct sigrok_device_instance *sdi)
        return mso_send_control_message(sdi, ARRAY_AND_SIZE(ops));
 }
 
-static int mso_force_capture(struct sigrok_device_instance *sdi)
+static int mso_force_capture(struct sr_device_instance *sdi)
 {
        struct mso *mso = sdi->priv;
        uint16_t ops[] = {
@@ -182,7 +183,7 @@ static int mso_force_capture(struct sigrok_device_instance *sdi)
        return mso_send_control_message(sdi, ARRAY_AND_SIZE(ops));
 }
 
-static int mso_dac_out(struct sigrok_device_instance *sdi, uint16_t val)
+static int mso_dac_out(struct sr_device_instance *sdi, uint16_t val)
 {
        struct mso *mso = sdi->priv;
        uint16_t ops[] = {
@@ -194,7 +195,7 @@ static int mso_dac_out(struct sigrok_device_instance *sdi, uint16_t val)
        return mso_send_control_message(sdi, ARRAY_AND_SIZE(ops));
 }
 
-static int mso_clkrate_out(struct sigrok_device_instance *sdi, uint16_t val)
+static int mso_clkrate_out(struct sr_device_instance *sdi, uint16_t val)
 {
        uint16_t ops[] = {
                mso_trans(REG_CLKRATE1, (val >> 8) & 0xff),
@@ -204,18 +205,18 @@ static int mso_clkrate_out(struct sigrok_device_instance *sdi, uint16_t val)
        return mso_send_control_message(sdi, ARRAY_AND_SIZE(ops));
 }
 
-static int mso_configure_rate(struct sigrok_device_instance *sdi,
+static int mso_configure_rate(struct sr_device_instance *sdi,
                uint32_t rate)
 {
        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;
                }
@@ -231,7 +232,7 @@ static inline uint16_t mso_calc_raw_from_mv(struct mso *mso)
                         mso->vbit));
 }
 
-static int mso_configure_trigger(struct sigrok_device_instance *sdi)
+static int mso_configure_trigger(struct sr_device_instance *sdi)
 {
        struct mso *mso = sdi->priv;
        uint16_t ops[16];
@@ -301,7 +302,7 @@ static int mso_configure_trigger(struct sigrok_device_instance *sdi)
        return mso_send_control_message(sdi, ARRAY_AND_SIZE(ops));
 }
 
-static int mso_configure_threshold_level(struct sigrok_device_instance *sdi)
+static int mso_configure_threshold_level(struct sr_device_instance *sdi)
 {
        struct mso *mso = sdi->priv;
 
@@ -324,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;
@@ -344,12 +345,12 @@ 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)
 {
-       struct sigrok_device_instance *sdi;
+       struct sr_device_instance *sdi;
        int devcnt = 0;
        struct udev *udev;
        struct udev_enumerate *enumerate;
@@ -417,14 +418,14 @@ 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;
                }
                /* hardware initial state */
                mso->ctlbase = 0;
 
-               sdi = sigrok_device_instance_new(devcnt, ST_INITIALIZING,
+               sdi = sr_device_instance_new(devcnt, ST_INITIALIZING,
                        manufacturer, product, hwrev);
                if (!sdi) {
                        g_warning("Unable to create device instance for %s",
@@ -444,7 +445,7 @@ static int hw_init(char *deviceinfo)
                continue;
 
 err_device_instance_free:
-               sigrok_device_instance_free(sdi);
+               sr_device_instance_free(sdi);
 err_free_mso:
                free(mso);
        }
@@ -459,7 +460,7 @@ ret:
 static void hw_cleanup(void)
 {
        GSList *l;
-       struct sigrok_device_instance *sdi;
+       struct sr_device_instance *sdi;
 
        /* Properly close all devices. */
        for (l = device_instances; l; l = l->next) {
@@ -468,7 +469,7 @@ static void hw_cleanup(void)
                        serial_close(sdi->serial->fd);
                if (sdi->priv != NULL)
                        free(sdi->priv);
-               sigrok_device_instance_free(sdi);
+               sr_device_instance_free(sdi);
        }
        g_slist_free(device_instances);
        device_instances = NULL;
@@ -476,11 +477,11 @@ static void hw_cleanup(void)
 
 static int hw_opendev(int device_index)
 {
-       struct sigrok_device_instance *sdi;
+       struct sr_device_instance *sdi;
        struct mso *mso;
-       int ret = SIGROK_ERR;
+       int ret = SR_ERR;
 
-       if (!(sdi = get_sigrok_device_instance(device_instances, device_index)))
+       if (!(sdi = get_sr_device_instance(device_instances, device_index)))
                return ret;
 
        mso = sdi->priv;
@@ -489,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;
@@ -500,25 +501,25 @@ 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)
 {
-       struct sigrok_device_instance *sdi;
+       struct sr_device_instance *sdi;
 
-       if (!(sdi = get_sigrok_device_instance(device_instances, device_index)))
+       if (!(sdi = get_sr_device_instance(device_instances, device_index)))
                return;
 
        if (sdi->serial->fd != -1) {
@@ -530,11 +531,11 @@ static void hw_closedev(int device_index)
 
 static void *hw_get_device_info(int device_index, int device_info_id)
 {
-       struct sigrok_device_instance *sdi;
+       struct sr_device_instance *sdi;
        struct mso *mso;
        void *info = NULL;
 
-       if (!(sdi = get_sigrok_device_instance(device_instances, device_index)))
+       if (!(sdi = get_sr_device_instance(device_instances, device_index)))
                return NULL;
        mso = sdi->priv;
 
@@ -560,9 +561,9 @@ static void *hw_get_device_info(int device_index, int device_info_id)
 
 static int hw_get_status(int device_index)
 {
-       struct sigrok_device_instance *sdi;
+       struct sr_device_instance *sdi;
 
-       if (!(sdi = get_sigrok_device_instance(device_instances, device_index)))
+       if (!(sdi = get_sr_device_instance(device_instances, device_index)))
                return ST_NOT_FOUND;
 
        return sdi->status;
@@ -575,10 +576,10 @@ static int *hw_get_capabilities(void)
 
 static int hw_set_configuration(int device_index, int capability, void *value)
 {
-       struct sigrok_device_instance *sdi;
+       struct sr_device_instance *sdi;
 
-       if (!(sdi = get_sigrok_device_instance(device_instances, device_index)))
-               return SIGROK_ERR;
+       if (!(sdi = get_sr_device_instance(device_instances, device_index)))
+               return SR_ERR;
 
        switch (capability) {
        case HWCAP_SAMPLERATE:
@@ -586,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 */
        }
 
 }
@@ -602,7 +603,7 @@ static int hw_set_configuration(int device_index, int capability, void *value)
 /* FIXME: Pass errors? */
 static int receive_data(int fd, int revents, void *user_data)
 {
-       struct sigrok_device_instance *sdi = user_data;
+       struct sr_device_instance *sdi = user_data;
        struct mso *mso = sdi->priv;
        struct datafeed_packet packet;
        uint8_t in[1024], logic_out[1024];
@@ -665,19 +666,19 @@ static int receive_data(int fd, int revents, void *user_data)
 
 static int hw_start_acquisition(int device_index, gpointer session_device_id)
 {
-       struct sigrok_device_instance *sdi;
+       struct sr_device_instance *sdi;
        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)))
+       if (!(sdi = get_sr_device_instance(device_instances, device_index)))
                return ret;
        mso = sdi->priv;
 
        /* 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 */
@@ -685,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 */
@@ -708,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;