- Fix #169 (#170)

* - Fix #169
- Fix MK4 Y selftest

* - Remove trace-events from coverage
- Add basic timing test case for AT21CSxx

Author: vintagepc

.github/workflows/tests.yml

@@ -79,7 +79,7 @@ jobs:
       run: cd ${{ runner.workspace }}/MINI404/build && make coverage-html -j4
 
     - name: Strip down Coverage report
-      run: cd ${{ runner.workspace }}/MINI404/build/meson-logs && lcov -extract coverage.info '*/arm/prusa/*' --rc lcov_branch_coverage=1 --output-file=c2.info &&  lcov -remove c2.info '*/3rdParty/*'  --rc lcov_branch_coverage=1 --output-file=c2.info
+      run: cd ${{ runner.workspace }}/MINI404/build/meson-logs && lcov -extract coverage.info '*/arm/prusa/*' --rc lcov_branch_coverage=1 --output-file=c2.info &&  lcov -remove c2.info '*/3rdParty/*'  --rc lcov_branch_coverage=1 --output-file=c2.info &&  lcov -remove c2.info '*trace-events*'  --rc lcov_branch_coverage=1 --output-file=c2.info
 
     - name: Upload to codecov.io
       uses: codecov/codecov-action@v4

hw/arm/prusa/otp.h

@@ -25,6 +25,14 @@ typedef struct {
     MAC_addr mac_address; // MAC address (6 bytes)
 	uint16_t _padding;
 } OTP_v4;
+
+typedef struct  {
+    uint8_t version; // Data structure version (1 bytes)
+    uint16_t size; // Data structure size (uint16_t little endian)
+    uint8_t bomID; // BOM ID (1 bytes)
+    uint32_t timestamp; // UNIX Timestamp from 1970 (uint32_t little endian)
+    uint8_t datamatrix[24]; // DataMatrix ID 1 (24 bytes)
+}OTP_v2 ;
 #pragma pack(pop)
 
 #endif

hw/arm/prusa/parts/AT21CSxx.c

@@ -32,6 +32,8 @@
 #include "sysemu/block-backend.h"
 #include "sysemu/cpu-timers.h"
 #include "migration/vmstate.h"
+#include "../otp.h"
+#include "trace.h"
 
 #define TYPE_AT21CSXX "at21csxx"
 
@@ -44,7 +46,8 @@
 #define AT21_OP_SSM  0xD
 #define AT21_OP_HSM  0xE
 
-#define ICOUNT_PER_US 168
+// Empirically determined based on the bootloader code and its NOP()s... :-/
+#define ICOUNT_PER_US_INITIAL 124
 
 #define DEV_ADDR 0
 #define DEV_SIZE 128
@@ -80,11 +83,15 @@ struct AT21CSxxState {
 
 	QEMUTimer *line_release;
 
+    uint32_t refined_icount;
+    bool icount_enabled;
+
 	int64_t low_start, high_start;
 	uint8_t bit_counter;
 	uint8_t byte_in, byte_out;
 	uint8_t sio_state;
 
+
 	uint8_t byte_count;
 	uint8_t address_pointer;
 
@@ -122,6 +129,7 @@ static void at21csxx_line_release(void *opaque)
 
 static bool at21csxx_process_byte(AT21CSxxState *s, uint8_t byte)
 {
+    trace_at21csxx_byte_in(s->byte_count, byte);
 	switch (s->byte_count)
 	{
 		case 0:
@@ -131,6 +139,7 @@ static bool at21csxx_process_byte(AT21CSxxState *s, uint8_t byte)
 				if (s->cmd.def.read)
 				{
 					s->sio_state = SIO_DOUT;
+                    trace_at21csxx_read_mode();
 				}
 				switch (s->cmd.def.opcode)
 				{
@@ -147,39 +156,49 @@ static bool at21csxx_process_byte(AT21CSxxState *s, uint8_t byte)
 			if (byte < DEV_SIZE)
 			{
 				s->address_pointer = byte;
+                trace_at21csxx_address_set(s->address_pointer);
 				s->byte_count++;
 				return true;
 			}
 			return false;
 		default:
+            trace_at21csxx_data_write(s->address_pointer, byte);
 			s->data[s->address_pointer++] = byte;
 			s->address_pointer %= DEV_SIZE;
 			return true;
 	}
 }
 
 static void at21csxx_sio(void* opaque, int n, int level) {
+    trace_at21csxx_sio_level(level);
     AT21CSxxState *s = AT21CSXX(opaque);
+    const uint32_t ICOUNT_PER_US = s->icount_enabled ? s->refined_icount : 1000;
 	if (!level)
 	{
-		s->low_start = icount_get_raw();
+
+		s->low_start = s->icount_enabled ? icount_get_raw() : qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
 		int64_t tHigh = s->low_start - s->high_start;
+        trace_at21csxx_sio_high_icount(tHigh);
 		if (tHigh > 500 * ICOUNT_PER_US)
 		{
-			// printf("AT21 Start cond\n");
+			trace_at21csxx_start_condition();
 			s->sio_state = SIO_IDLE;
 		}
 		return;
 	}
 
-	s->high_start = icount_get_raw();
+	s->high_start = s->icount_enabled ? icount_get_raw() : qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
 
 	int64_t tLow = s->high_start - s->low_start;
 
-	if (tLow > 150 * ICOUNT_PER_US)
+    trace_at21csxx_sio_low_icount(tLow);
+
+	if (tLow >= 150 * ICOUNT_PER_US)
 	{
 		s->bit_counter = 0;
 		s->byte_in = 0;
+        trace_at21csxx_enter_discovery();
+        qemu_set_irq(s->irq, 1);
 		s->sio_state = SIO_DISC;
 		return;
 	}
@@ -193,7 +212,7 @@ static void at21csxx_sio(void* opaque, int n, int level) {
 			{
 				qemu_irq_lower(s->irq);
 				timer_mod(s->line_release, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + NS_SCALE(6000)); // 2-6 us from the datasheet
-				// printf("Discovery ack\n");
+				trace_at21csxx_discovery_ack();
 				s->sio_state = SIO_IDLE;
 			}
 			break;
@@ -208,6 +227,7 @@ static void at21csxx_sio(void* opaque, int n, int level) {
 		case SIO_DIN:
 			if (logic_one || logic_zero )
 			{
+                trace_at21csxx_bit_logic_val(s->bit_counter, logic_one, logic_zero);
 				if (s->bit_counter < 8)
 				{
 					s->byte_in <<= 1;
@@ -218,12 +238,13 @@ static void at21csxx_sio(void* opaque, int n, int level) {
 			}
 			else
 			{
+                trace_at21csxx_bit_duration_error(s->bit_counter, tLow);
 				// printf("w1 Bus unhandled low duration: %"PRId64" instructions\n", tLow);
 			}
 			if (s->bit_counter == 8)
 			{
 				bool send_ack = at21csxx_process_byte(s, s->byte_in);
-				// printf("Byte in: %02x - %s\n", s->byte_in, send_ack? "ACK" : "NACK");
+				//printf("Byte in: %02x - %s\n", s->byte_in, send_ack? "ACK" : "NACK");
 				s->byte_in = 0;
 				qemu_set_irq(s->irq, !send_ack);
 				timer_mod(s->line_release, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + NS_SCALE(2000)); // 2-6 us from the datasheet
@@ -238,14 +259,15 @@ static void at21csxx_sio(void* opaque, int n, int level) {
 					{
 						case AT21_OP_EEA:
 							s->byte_out = s->data[s->address_pointer++];
-							printf("AT21CSxx: Sending byte@ %02x: %02x\n",s->address_pointer-1, s->byte_out);
+                            trace_at21csxx_data_read(s->address_pointer-1, s->byte_out);
 							break;
 						default:
 							printf("AT21 Unhandled read opcode %x\n", s->cmd.def.opcode);
 							break;
 					}
 					/* fallthru */
 				case 1 ... 7 :
+                    trace_at21csxx_sio_out(s->bit_counter, s->byte_out&0x80);
 					qemu_set_irq(s->irq, (s->byte_out & 0x80) > 0 );
 					s->bit_counter++;
 					s->byte_out <<= 1;
@@ -285,6 +307,12 @@ static void at21csxx_realize(DeviceState *dev, Error **errp)
 		printf("WARNING: icount is disabled. AT21CSxx EEPROM will NOT WORK!\n");
 		printf("WARNING: use -icount [number] to enable it.\n");
 	}
+    else 
+    {
+        s->icount_enabled = true;
+    }
+#else
+    s->icount_enabled = icount_enabled();
 #endif    
     if (s->blk) {
 
@@ -313,12 +341,14 @@ static void at21csxx_realize(DeviceState *dev, Error **errp)
 	else
 	{
 		// Add some fake data just to avoid 400 re-read attempts during boot... :(
-		s->data[0] = 0x00;
-		s->data[1] = 0x20;
-		s->data[2] = 0x00;
-		s->data[3] = 0x01;
-		s->data[8] = '0';
-		s->data[9] = '0';
+        OTP_v2* otp = (OTP_v2*) s->data;
+        otp->version = 2;
+        otp->size = sizeof(OTP_v2);
+        otp->bomID = 31; // Last variant that uses table 5... ;) 
+        // Should keep the bootloader happy:
+        otp->datamatrix[0] = '0';
+        otp->datamatrix[1] = '0';
+
 	}
 }
 
@@ -336,6 +366,7 @@ static void at21csxx_init(Object *obj)
 
 static Property at21csxx_eeprom_props[] = {
     DEFINE_PROP_DRIVE("drive", AT21CSxxState, blk),
+    DEFINE_PROP_UINT32("icount-per-us", AT21CSxxState, refined_icount, ICOUNT_PER_US_INITIAL),
     DEFINE_PROP_END_OF_LIST()
 };
 

hw/arm/prusa/parts/tmc2209.c

@@ -30,6 +30,7 @@
 #include "../utility/p404scriptable.h"
 #include "../utility/p404_motor_if.h"
 #include "../utility/ScriptHost_C.h"
+#include "trace.h"
 
 //#define DEBUG_TMC2209 1
 
@@ -352,6 +353,7 @@ static void tmc2209_read(tmc2209_state *s)
     reply[7] = tmc2209_calcCRC(reply,7);
     for (int i=0; i<8; i++)
     {
+        trace_tmc2209_byte_out(s->address, reply[i]);
         qemu_set_irq(s->byte_out, reply[i]); //
     }
 }
@@ -363,6 +365,8 @@ static void tmc2209_receive(void *opaque, int n, int level)
     s->rx_buffer[s->rx_pos] = (uint8_t)level;
     s->rx_pos++;
 
+    trace_tmc2209_byte_in(s->address, level);
+
     if (s->rx_pos == 8 && s->rx_buffer[2] & 0x80)
     {
         if (s->rx_buffer[1] == s->address) tmc2209_write(s);

hw/arm/prusa/parts/trace-events

@@ -0,0 +1,17 @@
+tmc2209_byte_in(uint8_t address, uint8_t byte) "A: %u D: %02x"
+tmc2209_byte_out(uint8_t address, uint8_t byte) "A: %u D: %02x"
+at21csxx_byte_in(uint8_t ct, uint8_t data) "D@%u: %02x"
+at21csxx_byte_out(uint8_t ct, uint8_t data) "D@%u: %02x"
+at21csxx_read_mode(void)
+at21csxx_address_set(uint8_t address) "A: %02x"
+at21csxx_data_write(uint8_t addr, uint8_t data) "write@%u = %02x"
+at21csxx_data_read(uint8_t addr, uint8_t data) "read@%u = %02x"
+at21csxx_bit_logic_val(uint8_t bit_count, bool logic_1, bool logic_0) "bit %u: 1:%u 0:%u"
+at21csxx_bit_duration_error(uint8_t bit_count, uint32_t duration) "Unknown low duration for bit %u: %u"
+at21csxx_sio_level(uint8_t level) "SIO: %u"
+at21csxx_sio_out(uint8_t bit, bool level) "SIO bit %u: %u"
+at21csxx_sio_low_icount(uint32_t icount) "SIO low: %u"
+at21csxx_sio_high_icount(uint32_t icount) "SIO high: %u"
+at21csxx_start_condition(void)
+at21csxx_enter_discovery(void)
+at21csxx_discovery_ack(void)

hw/arm/prusa/parts/trace.h

@@ -0,0 +1 @@
+#include "trace/trace-hw_arm_prusa_parts.h"

hw/arm/prusa/prusa-mk4.c

@@ -591,7 +591,7 @@ static void mk4_init(MachineState *machine)
     qdev_prop_set_string(db2, "indicators", "ZF");
 
     {
-        int32_t ends[4] = { 100*16*255, 100*16*214, 400*16*(cfg.has_loadcell ? 221: 212),0 };
+        int32_t ends[4] = { 100*16*255, 100*16*218, 400*16*(cfg.has_loadcell ? 221: 212),0 };
         static const char* links[4] = {"motor[0]","motor[1]","motor[2]","motor[3]"};
         static int32_t stepsize[4] = { 100*16, 100*16, 400*16, 320*16 };
 
@@ -891,6 +891,7 @@ static void mk4_init(MachineState *machine)
     if (cfg.has_at21) {
         dev = qdev_new("at21csxx");
 		qdev_prop_set_drive(dev, "drive", blk_by_name("loveboard-eeprom"));
+        object_property_add_child(OBJECT(periphs), "at21csxx", OBJECT(dev));
         sysbus_realize(SYS_BUS_DEVICE(dev), &error_fatal);
         // 2-way bitbang
         // WARNING: F13 is also used by the fan tach gate. So the output gets re-bount below

hw/arm/prusa/stm32_tests/meson.build

@@ -1,4 +1,5 @@
 qtests_buddy = [
+    'prusa/stm32_tests/mini404_at21csxx_test',
     'prusa/stm32_tests/mini404_dwarf_input_test',
     'prusa/stm32_tests/mini404_encoder_test',
     'prusa/stm32_tests/mini404_fan_test',