+/* queue a readback */
+#define readqueue_size 16384
+static struct
+{
+ uint8_t *dest;
+ int bits;
+} readqueue[readqueue_size];
+
+static int readqueue_pos = 0;
+
+/* flush the readqueue, this means reading any data that
+ * we're expecting and store them into the final position
+ */
+void zy1000_flush_readqueue(void)
+{
+ if (readqueue_pos == 0)
+ {
+ /* simply debugging by allowing easy breakpoints when there
+ * is something to do. */
+ return;
+ }
+ int i;
+ tcpip_open();
+ for (i = 0; i < readqueue_pos; i++)
+ {
+ uint32_t value;
+ if (!readLong(&value))
+ {
+ fprintf(stderr, "Could not read from zy1000 server\n");
+ exit(-1);
+ }
+
+ uint8_t *in_value = readqueue[i].dest;
+ int k = readqueue[i].bits;
+
+ // we're shifting in data to MSB, shift data to be aligned for returning the value
+ value >>= 32-k;
+
+ for (int l = 0; l < k; l += 8)
+ {
+ in_value[l/8]=(value >> l)&0xff;
+ }
+ }
+ readqueue_pos = 0;
+}
+
+/* By queuing the callback's we avoid flushing the
+read queue until jtag_execute_queue(). This can
+reduce latency dramatically for cases where
+callbacks are used extensively.
+*/
+#define callbackqueue_size 128
+static struct callbackentry
+{
+ jtag_callback_t callback;
+ jtag_callback_data_t data0;
+ jtag_callback_data_t data1;
+ jtag_callback_data_t data2;
+ jtag_callback_data_t data3;
+} callbackqueue[callbackqueue_size];
+
+static int callbackqueue_pos = 0;
+
+void zy1000_jtag_add_callback4(jtag_callback_t callback, jtag_callback_data_t data0, jtag_callback_data_t data1, jtag_callback_data_t data2, jtag_callback_data_t data3)
+{
+ if (callbackqueue_pos >= callbackqueue_size)
+ {
+ zy1000_flush_callbackqueue();
+ }
+
+ callbackqueue[callbackqueue_pos].callback = callback;
+ callbackqueue[callbackqueue_pos].data0 = data0;
+ callbackqueue[callbackqueue_pos].data1 = data1;
+ callbackqueue[callbackqueue_pos].data2 = data2;
+ callbackqueue[callbackqueue_pos].data3 = data3;
+ callbackqueue_pos++;
+}
+
+static int zy1000_jtag_convert_to_callback4(jtag_callback_data_t data0, jtag_callback_data_t data1, jtag_callback_data_t data2, jtag_callback_data_t data3)
+{
+ ((jtag_callback1_t)data1)(data0);
+ return ERROR_OK;
+}
+
+void zy1000_jtag_add_callback(jtag_callback1_t callback, jtag_callback_data_t data0)
+{
+ zy1000_jtag_add_callback4(zy1000_jtag_convert_to_callback4, data0, (jtag_callback_data_t)callback, 0, 0);
+}
+
+void zy1000_flush_callbackqueue(void)
+{
+ /* we have to flush the read queue so we have access to
+ the data the callbacks will use
+ */
+ zy1000_flush_readqueue();
+ int i;
+ for (i = 0; i < callbackqueue_pos; i++)
+ {
+ struct callbackentry *entry = &callbackqueue[i];
+ jtag_set_error(entry->callback(entry->data0, entry->data1, entry->data2, entry->data3));
+ }
+ callbackqueue_pos = 0;
+}
+
+static void writeShiftValue(uint8_t *data, int bits)
+{
+ waitIdle();
+
+ if (!writeLong((ZY1000_CMD_PEEK << 24) | (ZY1000_JTAG_BASE + 0xc)))
+ {
+ fprintf(stderr, "Could not read from zy1000 server\n");
+ exit(-1);
+ }
+
+ if (readqueue_pos >= readqueue_size)
+ {
+ zy1000_flush_readqueue();
+ }
+
+ readqueue[readqueue_pos].dest = data;
+ readqueue[readqueue_pos].bits = bits;
+ readqueue_pos++;
+}
+
+#else
+
+static void writeShiftValue(uint8_t *data, int bits)
+{
+ uint32_t value;
+ waitIdle();
+ ZY1000_PEEK(ZY1000_JTAG_BASE + 0xc, value);
+ VERBOSE(LOG_INFO("getShiftValue %08x", value));
+
+ // data in, LSB to MSB
+ // we're shifting in data to MSB, shift data to be aligned for returning the value
+ value >>= 32 - bits;
+
+ for (int l = 0; l < bits; l += 8)
+ {
+ data[l/8]=(value >> l)&0xff;
+ }
+}