Let FPGA sim server know about streaming tables

python/sim_server

@@ -75,6 +75,9 @@ def run_simulation(conn):
             length, = struct.unpack('I', read(conn, 4))
             data = read(conn, length * 4)
             sim_registers.write_table(block, num, reg, data)
+            conn.sendall(struct.pack('I', 0))
+        elif command == b'Q':
+            conn.sendall(struct.pack('I', 0))
         elif command == b'D':
             # Retrieve increment of data stream
             length, = struct.unpack('I', read(conn, 4))

server/base64.c

@@ -6,7 +6,7 @@
 #include "base64.h"
 
 /* Encoding lookup table. */
-static const char encode[64] =
+static const char encode[64] __attribute__((nonstring)) =
     "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
 /* Decode lookup table, setup during initialisation. */

server/hardware.c

@@ -509,9 +509,26 @@ static error__t hw_long_table_write(
     };
     return TEST_IO(ioctl(block_id, PANDA_BLOCK_SEND, &request));
 }
+
+static size_t hw_long_table_get_queued_words(int block_id)
+{
+    size_t result = 0;
+    ioctl(block_id, PANDA_BLOCK_NWORDS, &result);
+    return result;
+}
 #endif
 
 
+size_t hw_table_get_queued_words(struct hw_table *table, unsigned int number)
+{
+    if (table->table_type == LONG_TABLE)
+        return hw_long_table_get_queued_words(
+            table->long_table.block_ids[number]);
+    else
+        return 0;
+}
+
+
 static error__t create_long_table(
     struct hw_table *table, unsigned int order, unsigned int nbuffers,
     size_t *block_length, unsigned int base_reg, unsigned int length_reg)
@@ -651,18 +668,6 @@ void hw_close_table(struct hw_table *table)
 }
 
 
-size_t hw_get_queued_words(struct hw_table *table, unsigned int number)
-{
-    if (table->table_type == LONG_TABLE)
-    {
-        size_t result = 0;
-        ioctl(table->long_table.block_ids[number], PANDA_BLOCK_NWORDS, &result);
-        return result;
-    }
-    return 0;
-}
-
-
 /******************************************************************************/
 
 

server/hardware.h

@@ -147,7 +147,7 @@ void hw_close_table(struct hw_table *table);
 
 /* Returns the number of 4-byte words scheduled, it's valid for long tables
  * only, otherwise 0 */
-size_t hw_get_queued_words(struct hw_table *table, unsigned int number);
+size_t hw_table_get_queued_words(struct hw_table *table, unsigned int number);
 
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /* Streamed data capture. */

server/sim_hardware.c

@@ -254,12 +254,30 @@ error__t hw_long_table_write(
 
     memcpy(block->data, data, nbytes);
     ASSERT_OK(length == (uint32_t) length);
+    uint32_t length_with_flag = (uint32_t) length;
+    if (streaming_mode && !last_table)
+        length_with_flag |= 0x80000000;
+    uint32_t result = 0;
     WITH_MUTEX(mutex)
         handle_error(
             write_command_int('T',
-                block->block_base, block->number, 0, (uint32_t) length)  ?:
-            write_all(block->data, nbytes));
-    return ERROR_OK;
+                block->block_base, block->number, 0, length_with_flag)  ?:
+            write_all(block->data, nbytes) ?:
+            read_all(&result, 4));
+    return TEST_OK_(result == 0, "Long table write failed");
+}
+
+
+size_t hw_long_table_get_queued_words(int block_id)
+{
+    ASSERT_OK(0 <= block_id  &&  block_id < (int) block_id_count);
+    struct table_block *block = &block_id_table[block_id];
+    uint32_t result = 0;
+    WITH_MUTEX(mutex)
+        handle_error(
+            write_command('Q', block->block_base, block->number, 0)  ?:
+            read_all(&result, 4));
+    return (size_t) result;
 }
 
 

server/sim_hardware.h

@@ -17,3 +17,5 @@ void hw_long_table_release(int block_id, void *data);
 error__t hw_long_table_write(
     int block_id, const void *data, size_t length, bool streaming_mode,
     bool last_table);
+
+size_t hw_long_table_get_queued_words(int block_id);

server/table.c

@@ -721,9 +721,10 @@ static error__t table_queued_lines_format(
     char result[], size_t length)
 {
     struct table_state *state = class_data;
+    size_t queued_words = hw_table_get_queued_words(state->table, number);
     return format_string(
         result, length, "%zu",
-        hw_get_queued_words(state->table, number) / state->field_set.row_words);
+        queued_words / state->field_set.row_words);
 }