]> sigrok.org Git - libsigrok.git/blobdiff - hardware/asix-sigma/asix-sigma.c
Sigma: Add state machine for tracking Sigma status.
[libsigrok.git] / hardware / asix-sigma / asix-sigma.c
index 014e6679c5f4643bf36d086a04fb808d0b8de0ec..fe57d857c7dc7d7ad073c5e17cf54e82bc4663b9 100644 (file)
@@ -48,8 +48,8 @@ static int cur_firmware = -1;
 static int num_probes = 0;
 static int samples_per_event = 0;
 static int capture_ratio = 50;
-
 static struct sigma_trigger trigger;
+static struct sigma_state sigma;
 
 static uint64_t supported_samplerates[] = {
        KHZ(200),
@@ -106,6 +106,8 @@ static const char *firmware_files[] = {
        "asix-sigma-phasor.fw", /* Frequency counter */
 };
 
+static void hw_stop_acquisition(int device_index, gpointer session_device_id);
+
 static int sigma_read(void *buf, size_t size)
 {
        int ret;
@@ -243,7 +245,7 @@ static int sigma_read_dram(uint16_t startchunk, size_t numchunks, uint8_t *data)
        return sigma_read(data, numchunks * CHUNK_SIZE);
 }
 
-/* Upload trigger look-up tables to Sigma */
+/* Upload trigger look-up tables to Sigma. */
 static int sigma_write_trigger_lut(struct triggerlut *lut)
 {
        int i;
@@ -530,7 +532,8 @@ static int hw_opendev(int device_index)
        return SIGROK_OK;
 }
 
-static int set_samplerate(struct sigrok_device_instance *sdi, uint64_t samplerate)
+static int set_samplerate(struct sigrok_device_instance *sdi,
+                         uint64_t samplerate)
 {
        int i, ret;
 
@@ -558,6 +561,7 @@ static int set_samplerate(struct sigrok_device_instance *sdi, uint64_t samplerat
 
        cur_samplerate = samplerate;
        samples_per_event = 16 / num_probes;
+       sigma.state = SIGMA_IDLE;
 
        g_message("Firmware uploaded");
 
@@ -577,11 +581,13 @@ static int configure_probes(GSList *probes)
        struct probe *probe;
        GSList *l;
        int trigger_set = 0;
+       int probebit;
 
        memset(&trigger, 0, sizeof(struct sigma_trigger));
 
        for (l = probes; l; l = l->next) {
                probe = (struct probe *)l->data;
+               probebit = 1 << (probe->index - 1);
 
                if (!probe->enabled || !probe->trigger)
                        continue;
@@ -589,14 +595,15 @@ static int configure_probes(GSList *probes)
                if (cur_samplerate >= MHZ(100)) {
                        /* Fast trigger support. */
                        if (trigger_set) {
-                               g_warning("Asix Sigma only supports a single pin trigger "
-                                               "in 100 and 200 MHz mode.");
+                               g_warning("Asix Sigma only supports a single "
+                                               "pin trigger in 100 and 200 "
+                                               "MHz mode.");
                                return SIGROK_ERR;
                        }
                        if (probe->trigger[0] == 'f')
-                               trigger.fast_fall = 1;
+                               trigger.fallingmask |= probebit;
                        else if (probe->trigger[0] == 'r')
-                               trigger.fast_fall = 0;
+                               trigger.risingmask |= probebit;
                        else {
                                g_warning("Asix Sigma only supports "
                                          "rising/falling trigger in 100 "
@@ -604,25 +611,23 @@ static int configure_probes(GSList *probes)
                                return SIGROK_ERR;
                        }
 
-                       trigger.fast_pin = probe->index - 1;
-
                        ++trigger_set;
                } else {
                        /* Simple trigger support (event). */
                        if (probe->trigger[0] == '1') {
-                               trigger.simplevalue |= 1 << (probe->index - 1);
-                               trigger.simplemask |= 1 << (probe->index - 1);
+                               trigger.simplevalue |= probebit;
+                               trigger.simplemask |= probebit;
                        }
                        else if (probe->trigger[0] == '0') {
-                               trigger.simplevalue |= 0 << (probe->index - 1);
-                               trigger.simplemask |= 1 << (probe->index - 1);
+                               trigger.simplevalue &= ~probebit;
+                               trigger.simplemask |= probebit;
                        }
                        else if (probe->trigger[0] == 'f') {
-                               trigger.fallingmask |= 1 << (probe->index - 1);
+                               trigger.fallingmask |= probebit;
                                ++trigger_set;
                        }
                        else if (probe->trigger[0] == 'r') {
-                               trigger.risingmask |= 1 << (probe->index - 1);
+                               trigger.risingmask |= probebit;
                                ++trigger_set;
                        }
 
@@ -745,6 +750,7 @@ static int decode_chunk_ts(uint8_t *buf, uint16_t *lastts,
        int triggerts = -1;
        int triggeroff = 0;
 
+       /* Check if trigger is in this chunk. */
        if (triggerpos != -1) {
                if (cur_samplerate <= MHZ(50))
                        triggerpos -= EVENTS_PER_CLUSTER;
@@ -811,11 +817,12 @@ static int decode_chunk_ts(uint8_t *buf, uint16_t *lastts,
                sent = 0;
                if (i == triggerts) {
                        /*
-                        * Trigger is presumptively only accurate to event, i.e.
-                        * for 100 and 200 MHz, where multiple samples are coded
-                        * in a single event, the trigger does not match the
-                        * exact sample.
+                        * Trigger is presumptively not accurate to sample.
+                        * However, it always trigger before the actual event,
+                        * so it would be possible to forward to correct position
+                        * here by manually checking for trigger condition.
                         */
+
                        tosend = (triggerpos % 7) - triggeroff;
 
                        if (tosend > 0) {
@@ -852,77 +859,75 @@ static int receive_data(int fd, int revents, void *user_data)
        struct datafeed_packet packet;
        const int chunks_per_read = 32;
        unsigned char buf[chunks_per_read * CHUNK_SIZE];
-       int bufsz, numchunks, curchunk, i, newchunks;
-       uint32_t triggerpos, stoppos, running_msec;
+       int bufsz, numchunks, i, newchunks;
+       uint32_t running_msec;
        struct timeval tv;
-       uint16_t lastts = 0;
-       uint16_t lastsample = 0;
-       uint8_t modestatus;
-       int triggerchunk = -1;
 
        fd = fd;
        revents = revents;
 
-       /* Get the current position. */
-       sigma_read_pos(&stoppos, &triggerpos);
-       numchunks = stoppos / 512;
+       numchunks = sigma.stoppos / 512;
 
-       /* Check if the has expired, or memory is full. */
-       gettimeofday(&tv, 0);
-       running_msec = (tv.tv_sec - start_tv.tv_sec) * 1000 +
-                      (tv.tv_usec - start_tv.tv_usec) / 1000;
-
-       if (running_msec < limit_msec && numchunks < 32767)
+       if (sigma.state == SIGMA_IDLE)
                return FALSE;
 
-       /* Stop acqusition. */
-       sigma_set_register(WRITE_MODE, 0x11);
+       if (sigma.state == SIGMA_CAPTURE) {
 
-       /* Set SDRAM Read Enable. */
-       sigma_set_register(WRITE_MODE, 0x02);
+               /* Check if the timer has expired, or memory is full. */
+               gettimeofday(&tv, 0);
+               running_msec = (tv.tv_sec - start_tv.tv_sec) * 1000 +
+                       (tv.tv_usec - start_tv.tv_usec) / 1000;
 
-       /* Get the current position. */
-       sigma_read_pos(&stoppos, &triggerpos);
+               if (running_msec < limit_msec && numchunks < 32767)
+                       return FALSE;
 
-       /* Check if trigger has fired. */
-       modestatus = sigma_get_register(READ_MODE);
-       if (modestatus & 0x20) {
-               triggerchunk = triggerpos / 512;
-       }
+               hw_stop_acquisition(-1, user_data);
+
+               return FALSE;
 
-       /* Download sample data. */
-       for (curchunk = 0; curchunk < numchunks;) {
-               newchunks = MIN(chunks_per_read, numchunks - curchunk);
+       } else if (sigma.state == SIGMA_DOWNLOAD) {
+               if (sigma.chunks_downloaded >= numchunks) {
+                       /* End of samples. */
+                       packet.type = DF_END;
+                       packet.length = 0;
+                       session_bus(user_data, &packet);
+
+                       sigma.state = SIGMA_IDLE;
+
+                       return TRUE;
+               }
+
+               newchunks = MIN(chunks_per_read,
+                               numchunks - sigma.chunks_downloaded);
 
                g_message("Downloading sample data: %.0f %%",
-                         100.0 * curchunk / numchunks);
+                         100.0 * sigma.chunks_downloaded / numchunks);
 
-               bufsz = sigma_read_dram(curchunk, newchunks, buf);
+               bufsz = sigma_read_dram(sigma.chunks_downloaded,
+                                       newchunks, buf);
 
                /* Find first ts. */
-               if (curchunk == 0)
-                       lastts = *(uint16_t *) buf - 1;
+               if (sigma.chunks_downloaded == 0) {
+                       sigma.lastts = *(uint16_t *) buf - 1;
+                       sigma.lastsample = 0;
+               }
 
                /* Decode chunks and send them to sigrok. */
                for (i = 0; i < newchunks; ++i) {
-                       if (curchunk + i == triggerchunk)
+                       if (sigma.chunks_downloaded + i == sigma.triggerchunk)
                                decode_chunk_ts(buf + (i * CHUNK_SIZE),
-                                               &lastts, &lastsample,
-                                               triggerpos & 0x1ff, user_data);
+                                               &sigma.lastts, &sigma.lastsample,
+                                               sigma.triggerpos & 0x1ff,
+                                               user_data);
                        else
                                decode_chunk_ts(buf + (i * CHUNK_SIZE),
-                                               &lastts, &lastsample,
+                                               &sigma.lastts, &sigma.lastsample,
                                                -1, user_data);
                }
 
-               curchunk += newchunks;
+               sigma.chunks_downloaded += newchunks;
        }
 
-       /* End of data. */
-       packet.type = DF_END;
-       packet.length = 0;
-       session_bus(user_data, &packet);
-
        return TRUE;
 }
 
@@ -945,7 +950,7 @@ static void build_lut_entry(uint16_t value, uint16_t mask, uint16_t *entry)
                                /* Set bit in entry */
                                if ((mask & bit) &&
                                    ((!(value & bit)) !=
-                                    (!(j & (1 << k)))))
+                                   (!(j & (1 << k)))))
                                        entry[i] &= ~(1 << j);
                        }
        }
@@ -1039,7 +1044,7 @@ static void add_trigger_function(enum triggerop oper, enum triggerfunc func,
 static int build_basic_trigger(struct triggerlut *lut)
 {
        int i,j;
-       uint16_t masks[2] = {0, 0};
+       uint16_t masks[2] = { 0, 0 };
 
        memset(lut, 0, sizeof(struct triggerlut));
 
@@ -1091,6 +1096,7 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
        uint8_t triggerselect;
        struct triggerinout triggerinout_conf;
        struct triggerlut lut;
+       int triggerpin;
 
        session_device_id = session_device_id;
 
@@ -1110,8 +1116,18 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
        if (cur_samplerate >= MHZ(100)) {
                sigma_set_register(WRITE_TRIGGER_SELECT1, 0x81);
 
-               triggerselect = (1 << LEDSEL1) | (trigger.fast_fall << 3) |
-                                       (trigger.fast_pin & 0x7);
+               /* Find which pin to trigger on from mask. */
+               for (triggerpin = 0; triggerpin < 8; ++triggerpin)
+                       if ((trigger.risingmask | trigger.fallingmask) &
+                           (1 << triggerpin))
+                               break;
+
+               /* Set trigger pin and light LED on trigger. */
+               triggerselect = (1 << LEDSEL1) | (triggerpin & 0x7);
+
+               /* Default rising edge. */
+               if (trigger.fallingmask)
+                       triggerselect |= 1 << 3;
 
        /* All other modes. */
        } else if (cur_samplerate <= MHZ(50)) {
@@ -1158,7 +1174,7 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
        }
 
        /* Setup maximum post trigger time. */
-       sigma_set_register(WRITE_POST_TRIGGER, (capture_ratio * 256) / 100);
+       sigma_set_register(WRITE_POST_TRIGGER, (capture_ratio * 255) / 100);
 
        /* Start acqusition. */
        gettimeofday(&start_tv, 0);
@@ -1178,19 +1194,38 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
        /* Add capture source. */
        source_add(0, G_IO_IN, 10, receive_data, session_device_id);
 
+       sigma.state = SIGMA_CAPTURE;
+
        return SIGROK_OK;
 }
 
 static void hw_stop_acquisition(int device_index, gpointer session_device_id)
 {
+       uint8_t modestatus;
+
        device_index = device_index;
        session_device_id = session_device_id;
 
        /* Stop acquisition. */
        sigma_set_register(WRITE_MODE, 0x11);
 
-       // XXX Set some state to indicate that data should be sent to sigrok
-       //     Now, we just wait for timeout
+       /* Set SDRAM Read Enable. */
+       sigma_set_register(WRITE_MODE, 0x02);
+
+       /* Get the current position. */
+       sigma_read_pos(&sigma.stoppos, &sigma.triggerpos);
+
+       /* Check if trigger has fired. */
+       modestatus = sigma_get_register(READ_MODE);
+       if (modestatus & 0x20) {
+               sigma.triggerchunk = sigma.triggerpos / 512;
+
+       } else
+               sigma.triggerchunk = -1;
+
+       sigma.chunks_downloaded = 0;
+
+       sigma.state = SIGMA_DOWNLOAD;
 }
 
 struct device_plugin asix_sigma_plugin_info = {