[nrf fromlist] tests: drivers: uart: async_dual: Optimize test data handling

Stress test is executed on CPUs with slow clock (16MHz). Handling of test
data in UART_RX_RDY event is optimized to reduce time spent in the
interrupt context. Since payload is always a decrementing sequence, fixed
array is used to compare memory which allows to use standard memcmp
instead of byte by byte comparison.

Upstream PR #: 92767

Signed-off-by: Krzysztof Chruściński <[email protected]>

Author: nordic-krch

tests/drivers/uart/uart_async_dual/src/main.c

@@ -61,6 +61,25 @@ ZTEST_DMEM struct dut_data duts[] = {
 #endif
 };
 
+/* Array that contains potential payload. It is used to memcmp against incoming packets. */
+static const uint8_t test_buf[256] = {
+	255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241,
+	240, 239, 238, 237, 236, 235, 234, 233, 232, 231, 230, 229, 228, 227, 226,
+	225, 224, 223, 222, 221, 220, 219, 218, 217, 216, 215, 214, 213, 212, 211,
+	210, 209, 208, 207, 206, 205, 204, 203, 202, 201, 200, 199, 198, 197, 196,
+	195, 194, 193, 192, 191, 190, 189, 188, 187, 186, 185, 184, 183, 182, 181,
+	180, 179, 178, 177, 176, 175, 174, 173, 172, 171, 170, 169, 168, 167, 166,
+	165, 164, 163, 162, 161, 160, 159, 158, 157, 156, 155, 154, 153, 152, 151,
+	150, 149, 148, 147, 146, 145, 144, 143, 142, 141, 140, 139, 138, 137, 136,
+	135, 134, 133, 132, 131, 130, 129, 128, 127, 126, 125, 124, 123, 122, 121,
+	120, 119, 118, 117, 116, 115, 114, 113, 112, 111, 110, 109, 108, 107, 106,
+	105, 104, 103, 102, 101, 100, 99, 98, 97, 96, 95, 94, 93, 92, 91, 90, 89,
+	88, 87, 86, 85, 84, 83, 82, 81, 80, 79, 78, 77, 76, 75, 74, 73, 72, 71, 70,
+	69, 68, 67, 66, 65, 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50,
+	49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30,
+	29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10,
+	9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
+
 static void pm_check(const struct device *dev, const struct device *second_dev, bool exp_on,
 		     int line)
 {
@@ -128,6 +147,8 @@ enum test_rx_mode {
 	RX_ALL,
 };
 
+typedef bool (*test_on_rx_rdy_t)(const struct device *dev, uint8_t *buf, size_t len);
+
 struct test_rx_data {
 	uint8_t hdr[1];
 	uint8_t buf[256];
@@ -140,6 +161,7 @@ struct test_rx_data {
 	struct k_sem sem;
 	uint32_t timeout;
 	uint32_t buf_idx;
+	test_on_rx_rdy_t on_rx_rdy;
 };
 
 static struct test_tx_data tx_data;
@@ -277,75 +299,86 @@ static void on_tx_done(const struct device *dev, struct uart_event *evt)
 	try_tx(dev, true);
 }
 
-static void on_rx_rdy(const struct device *dev, struct uart_event *evt)
+static bool on_rx_rdy_rx_all(const struct device *dev, uint8_t *buf, size_t len)
 {
-	uint32_t len = evt->data.rx.len;
-	uint32_t off = evt->data.rx.offset;
-	int err;
+	bool ok;
 
-	if (!rx_data.cont) {
-		return;
+	if (rx_data.payload_idx == 0) {
+		rx_data.payload_idx = buf[0] - 1;
+		buf++;
+		len--;
 	}
 
-	rx_data.rx_cnt += evt->data.rx.len;
-	if (evt->data.rx.buf == rx_data.hdr) {
-		if (rx_data.hdr[0] == 1) {
-			/* single byte packet. */
-			err = uart_rx_buf_rsp(dev, rx_data.hdr, 1);
-			zassert_equal(err, 0);
-			return;
+	ok = memcmp(buf, &test_buf[256 - rx_data.payload_idx], len) == 0;
+	rx_data.payload_idx -= len;
+
+	return ok;
+}
+
+static bool on_rx_rdy_hdr(const struct device *dev, uint8_t *buf, size_t len);
+
+static bool on_rx_rdy_payload(const struct device *dev, uint8_t *buf, size_t len)
+{
+	bool ok;
+	int err;
+
+	ok = memcmp(buf, &test_buf[255 - rx_data.payload_idx], len) == 0;
+	if (!ok) {
+		for (int i = 0; i < len; i++) {
+			if (buf[i] != test_buf[255 - rx_data.payload_idx + i]) {
+				zassert_true(false, "Byte %d expected: %02x got: %02x",
+					i, buf[i], test_buf[255 - rx_data.payload_idx + i]);
+			}
 		}
+		rx_data.cont = false;
+		tx_data.cont = false;
+		zassert_true(ok);
+		return false;
+	}
 
-		zassert_equal(rx_data.payload_idx, 0);
-		rx_data.state = RX_PAYLOAD;
-		rx_data.payload_idx = rx_data.hdr[0] - 1;
-		if ((rx_data.mode == RX_CONT) && rx_data.buf_req) {
-			size_t l = rx_data.hdr[0] - 1;
+	rx_data.payload_idx -= len;
 
-			zassert_true(l > 0);
+	if (rx_data.payload_idx == 0) {
+		rx_data.state = RX_HDR;
+		rx_data.on_rx_rdy = on_rx_rdy_hdr;
+		if ((rx_data.mode == RX_CONT) && rx_data.buf_req) {
 			rx_data.buf_req = false;
-			err = uart_rx_buf_rsp(dev, rx_data.buf, rx_data.hdr[0] - 1);
+			err = uart_rx_buf_rsp(dev, rx_data.hdr, 1);
+			zassert_equal(err, 0);
 		}
-	} else {
-		for (int i = 0; i < len; i++) {
-			bool ok;
+	}
 
-			if ((rx_data.mode == RX_ALL) && (rx_data.payload_idx == 0)) {
-				rx_data.payload_idx = evt->data.rx.buf[off + i];
-				ok = true;
-			} else {
-				ok = evt->data.rx.buf[off + i] == (uint8_t)rx_data.payload_idx;
-			}
+	return true;
+}
 
-			if (!ok) {
-				LOG_ERR("Unexpected data at %d, exp:%02x got:%02x",
-					i, rx_data.payload_idx, evt->data.rx.buf[off + i]);
-			}
+static bool on_rx_rdy_hdr(const struct device *dev, uint8_t *buf, size_t len)
+{
+	int err;
 
-			zassert_true(ok, "Unexpected data at %d, exp:%02x got:%02x",
-					i, len - i, evt->data.rx.buf[off + i]);
-			if (!ok) {
-				rx_data.cont = false;
-				tx_data.cont = false;
-				/* Avoid flood of errors as we are in the interrupt and ztest
-				 * cannot abort from here.
-				 */
-				return;
-			}
-			rx_data.payload_idx--;
-			if (rx_data.payload_idx == 0) {
-				if (rx_data.mode != RX_ALL) {
-					zassert_equal(i + 1, len, "len:%d i:%d", len, i);
-				}
-				rx_data.state = RX_HDR;
-				if ((rx_data.mode == RX_CONT) && rx_data.buf_req) {
-					rx_data.buf_req = false;
-					err = uart_rx_buf_rsp(dev, rx_data.hdr, 1);
-					zassert_equal(err, 0);
-				}
-			}
+	zassert_equal(buf, rx_data.hdr);
+	zassert_equal(len, 1);
+	if (rx_data.hdr[0] == 1) {
+		/* single byte packet. */
+		if ((rx_data.mode == RX_CONT) && rx_data.buf_req) {
+			err = uart_rx_buf_rsp(dev, rx_data.hdr, 1);
+			zassert_equal(err, 0);
 		}
+		return true;
 	}
+
+	zassert_equal(rx_data.payload_idx, 0);
+	rx_data.on_rx_rdy = on_rx_rdy_payload;
+	rx_data.payload_idx = rx_data.hdr[0] - 1;
+	rx_data.state = RX_PAYLOAD;
+	if ((rx_data.mode == RX_CONT) && rx_data.buf_req) {
+		size_t l = rx_data.hdr[0] - 1;
+
+		zassert_true(l > 0);
+		rx_data.buf_req = false;
+		err = uart_rx_buf_rsp(dev, rx_data.buf, buf[0] - 1);
+	}
+
+	return true;
 }
 
 static void on_rx_buf_req(const struct device *dev)
@@ -385,7 +418,6 @@ static void on_rx_dis(const struct device *dev, struct uart_event *evt, void *us
 		return;
 	}
 
-
 	zassert_true(len > 0);
 	err = uart_rx_enable(dev, buf, len, data->timeout);
 	zassert_equal(err, 0, "Unexpected err:%d", err);
@@ -417,7 +449,11 @@ static void uart_callback(const struct device *dev, struct uart_event *evt, void
 		break;
 	case UART_RX_RDY:
 		zassert_true(dev == rx_dev);
-		on_rx_rdy(dev, evt);
+		if (rx_data.cont) {
+			rx_data.on_rx_rdy(dev, &evt->data.rx.buf[evt->data.rx.offset],
+					  evt->data.rx.len);
+			rx_data.rx_cnt += evt->data.rx.len;
+		}
 		break;
 	case UART_RX_BUF_RELEASED:
 		zassert_true(dev == rx_dev);
@@ -516,7 +552,7 @@ static void var_packet(uint32_t baudrate, enum test_tx_mode tx_mode,
 	tx_data.rx_timeout = rx_data.timeout;
 	rx_data.cont = true;
 	rx_data.rx_cnt = 0;
-	rx_data.state = RX_HDR;
+	rx_data.on_rx_rdy = rx_mode == RX_ALL ? on_rx_rdy_rx_all : on_rx_rdy_hdr;
 	rx_data.mode = rx_mode;
 
 	ring_buf_init(&tx_data.rbuf, sizeof(tx_data.buf), tx_data.buf);