Add test implementation for prepare pipeline functions

- Created ull_prepare_impl.c with minimal prepare pipeline implementation
- Added init/cleanup functions for test setup/teardown
- Updated all test files to call init/cleanup in fixtures
- Included mem.c for memory management
- Added test_common.h header for shared declarations

Co-authored-by: cvinayak <6350656+cvinayak@users.noreply.github.com>

Author: Copilot

tests/bluetooth/controller/ctrl_prepare_pipeline/CMakeLists.txt

@@ -13,10 +13,12 @@ target_link_libraries(testbinary PRIVATE common)
 target_sources(testbinary
   PRIVATE
     src/main.c
+    src/ull_prepare_impl.c
     src/test_ull_prepare_basic.c
     src/test_ull_prepare_ordering.c
     src/test_ull_prepare_iterator.c
     src/test_ull_prepare_edge_cases.c
+    ${ZEPHYR_BASE}/subsys/bluetooth/controller/util/mem.c
 )
 
 # Include paths for controller sources

tests/bluetooth/controller/ctrl_prepare_pipeline/src/test_common.h

@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2024 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef ZEPHYR_TESTS_BT_CTRL_PREPARE_PIPELINE_H_
+#define ZEPHYR_TESTS_BT_CTRL_PREPARE_PIPELINE_H_
+
+/**
+ * @brief Initialize the prepare pipeline for testing
+ *
+ * Must be called before any prepare pipeline operations.
+ */
+void ull_prepare_pipeline_init(void);
+
+/**
+ * @brief Cleanup the prepare pipeline after testing
+ *
+ * Frees all allocated events and resets the pipeline.
+ */
+void ull_prepare_pipeline_cleanup(void);
+
+#endif /* ZEPHYR_TESTS_BT_CTRL_PREPARE_PIPELINE_H_ */

tests/bluetooth/controller/ctrl_prepare_pipeline/src/test_ull_prepare_basic.c

@@ -23,6 +23,8 @@
 #include "lll.h"
 #include "ull_internal.h"
 
+#include "test_common.h"
+
 /* Mock callbacks for testing */
 static int test_prepare_cb(struct lll_prepare_param *prepare_param)
 {
@@ -209,18 +211,14 @@ static void *test_ull_prepare_basic_setup(void)
 
 static void test_ull_prepare_basic_before(void *f)
 {
-	/* Note: Pipeline initialization/cleanup would happen here if needed.
-	 * For now, we rely on the implementation's internal state management.
-	 * In a real scenario after PR #79444, we might need to initialize
-	 * the ordered list structure here.
-	 */
+	/* Initialize pipeline before each test */
+	ull_prepare_pipeline_init();
 }
 
 static void test_ull_prepare_basic_after(void *f)
 {
-	/* Cleanup after each test - drain the pipeline
-	 * This ensures each test starts with a clean state.
-	 */
+	/* Cleanup pipeline after each test to ensure clean state */
+	ull_prepare_pipeline_cleanup();
 }
 
 static void test_ull_prepare_basic_teardown(void *f)

tests/bluetooth/controller/ctrl_prepare_pipeline/src/test_ull_prepare_edge_cases.c

@@ -23,6 +23,8 @@
 #include "lll.h"
 #include "ull_internal.h"
 
+#include "test_common.h"
+
 /* Event pipeline maximum size as defined in ull.c */
 #define EVENT_DEFER_MAX 2
 #define EVENT_PIPELINE_MAX (7U + (EVENT_DEFER_MAX))
@@ -370,10 +372,12 @@ static void *test_ull_prepare_edge_cases_setup(void)
 
 static void test_ull_prepare_edge_cases_before(void *f)
 {
+	ull_prepare_pipeline_init();
 }
 
 static void test_ull_prepare_edge_cases_after(void *f)
 {
+	ull_prepare_pipeline_cleanup();
 }
 
 static void test_ull_prepare_edge_cases_teardown(void *f)

tests/bluetooth/controller/ctrl_prepare_pipeline/src/test_ull_prepare_iterator.c

@@ -23,6 +23,8 @@
 #include "lll.h"
 #include "ull_internal.h"
 
+#include "test_common.h"
+
 /* Mock callbacks */
 static int test_prepare_cb(struct lll_prepare_param *prepare_param)
 {
@@ -314,10 +316,12 @@ static void *test_ull_prepare_iterator_setup(void)
 
 static void test_ull_prepare_iterator_before(void *f)
 {
+	ull_prepare_pipeline_init();
 }
 
 static void test_ull_prepare_iterator_after(void *f)
 {
+	ull_prepare_pipeline_cleanup();
 }
 
 static void test_ull_prepare_iterator_teardown(void *f)

tests/bluetooth/controller/ctrl_prepare_pipeline/src/test_ull_prepare_ordering.c

@@ -23,6 +23,8 @@
 #include "lll.h"
 #include "ull_internal.h"
 
+#include "test_common.h"
+
 /* Mock callbacks */
 static int test_prepare_cb(struct lll_prepare_param *prepare_param)
 {
@@ -316,11 +318,13 @@ static void *test_ull_prepare_ordering_setup(void)
 static void test_ull_prepare_ordering_before(void *f)
 {
 	/* Initialize pipeline state */
+	ull_prepare_pipeline_init();
 }
 
 static void test_ull_prepare_ordering_after(void *f)
 {
 	/* Cleanup pipeline */
+	ull_prepare_pipeline_cleanup();
 }
 
 static void test_ull_prepare_ordering_teardown(void *f)

tests/bluetooth/controller/ctrl_prepare_pipeline/src/ull_prepare_impl.c

@@ -0,0 +1,221 @@
+/*
+ * Copyright (c) 2024 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @file
+ * @brief Test implementation of ULL prepare pipeline
+ *
+ * This file provides a minimal implementation of the prepare pipeline
+ * functions for unit testing. It includes only the prepare pipeline
+ * functions from ull.c without the full ULL dependencies.
+ */
+
+#include <string.h>
+#include <zephyr/types.h>
+
+#include "util/util.h"
+#include "util/mem.h"
+
+#include "lll.h"
+
+/* BIT macro if not already defined */
+#ifndef BIT
+#define BIT(n) (1UL << (n))
+#endif
+
+/* Ticker constants - for testing we use 32-bit counter */
+#define HAL_TICKER_CNTR_MSBIT 31
+#define HAL_TICKER_CNTR_MASK 0xFFFFFFFF
+
+/* Ticker tick difference calculation */
+static inline uint32_t ticker_ticks_diff_get(uint32_t ticks_now, uint32_t ticks_old)
+{
+	return ((ticks_now - ticks_old) & HAL_TICKER_CNTR_MASK);
+}
+
+/* Event pipeline maximum size - use value from lll.h if available */
+#ifndef EVENT_PIPELINE_MAX
+#define EVENT_PIPELINE_MAX (7U + (EVENT_DEFER_MAX))
+#endif
+
+#define EVENT_PIPELINE_EVENT_SIZE (sizeof(struct lll_event) + sizeof(void *))
+
+/* Prepare pipeline structure */
+static struct {
+	struct {
+		void *free;
+		uint8_t pool[EVENT_PIPELINE_MAX * EVENT_PIPELINE_EVENT_SIZE];
+	} mem;
+	void **head;
+	void **tail;
+} pipeline;
+
+/* Initialize the prepare pipeline */
+void ull_prepare_pipeline_init(void)
+{
+	mem_init(pipeline.mem.pool, EVENT_PIPELINE_EVENT_SIZE,
+		 sizeof(pipeline.mem.pool) / EVENT_PIPELINE_EVENT_SIZE,
+		 &pipeline.mem.free);
+	pipeline.head = NULL;
+	pipeline.tail = NULL;
+}
+
+/* Reset/cleanup the prepare pipeline */
+void ull_prepare_pipeline_cleanup(void)
+{
+	/* Free all allocated events */
+	void **curr = pipeline.head;
+	while (curr) {
+		void **next = *curr;
+		mem_release(curr, &pipeline.mem.free);
+		curr = next;
+	}
+	
+	pipeline.head = NULL;
+	pipeline.tail = NULL;
+}
+
+struct lll_event *ull_prepare_enqueue(lll_is_abort_cb_t is_abort_cb,
+				      lll_abort_cb_t abort_cb,
+				      struct lll_prepare_param *prepare_param,
+				      lll_prepare_cb_t prepare_cb,
+				      uint8_t is_resume)
+{
+	struct lll_event *e;
+	void **next;
+
+	/* Allocate lll_event */
+	next = mem_acquire(&pipeline.mem.free);
+	if (!next) {
+		return NULL;
+	}
+
+	e = (void *)((uint8_t *)next + sizeof(void *));
+
+	memcpy(&e->prepare_param, prepare_param, sizeof(e->prepare_param));
+	e->prepare_cb = prepare_cb;
+	e->is_abort_cb = is_abort_cb;
+	e->abort_cb = abort_cb;
+	e->is_resume = is_resume;
+	e->is_aborted = 0U;
+
+	/* Enqueue lll_event */
+	*next = NULL;
+	if (pipeline.tail) {
+		struct lll_event *e_curr;
+		uint32_t diff;
+
+		/* Should the prepare be placed as the tail? */
+		e_curr = (void *)((uint8_t *)pipeline.tail + sizeof(void *));
+		diff = ticker_ticks_diff_get(prepare_param->ticks_at_expire,
+					     e_curr->prepare_param.ticks_at_expire);
+		if (is_resume ||
+		    (!e_curr->is_aborted && !e_curr->is_resume &&
+		     ((diff & BIT(HAL_TICKER_CNTR_MSBIT)) == 0U))) {
+			*pipeline.tail = next;
+			pipeline.tail = next;
+		} else {
+			/* Should the prepare be placed as the head? */
+			e_curr = (void *)((uint8_t *)pipeline.head + sizeof(void *));
+			diff = ticker_ticks_diff_get(e_curr->prepare_param.ticks_at_expire,
+						     prepare_param->ticks_at_expire);
+			if (!e_curr->is_aborted &&
+			    (e_curr->is_resume ||
+			     (diff && ((diff & BIT(HAL_TICKER_CNTR_MSBIT)) == 0U)))) {
+				*next = pipeline.head;
+				pipeline.head = next;
+			} else {
+				void **prev;
+				void **curr;
+
+				prev = NULL;
+				curr = pipeline.head;
+				e_curr = (void *)((uint8_t *)curr + sizeof(void *));
+				do {
+					if (!e_curr->is_aborted && !e_curr->is_resume) {
+						prev = curr;
+					}
+
+					curr = *curr;
+					if (!curr) {
+						break;
+					}
+
+					e_curr = (void *)((uint8_t *)curr + sizeof(void *));
+					diff = ticker_ticks_diff_get(
+							prepare_param->ticks_at_expire,
+							e_curr->prepare_param.ticks_at_expire);
+				} while (!e_curr->is_resume &&
+					 (e_curr->is_aborted ||
+					  ((diff & BIT(HAL_TICKER_CNTR_MSBIT)) == 0U)));
+
+				if (!prev) {
+					*next = pipeline.head;
+					pipeline.head = next;
+					if (!*next) {
+						pipeline.tail = next;
+					}
+				} else {
+					*next = *prev;
+					*prev = next;
+					if (!*next) {
+						pipeline.tail = next;
+					}
+				}
+			}
+		}
+	} else {
+		pipeline.head = next;
+		pipeline.tail = next;
+	}
+
+	return e;
+}
+
+void *ull_prepare_dequeue_get(void)
+{
+	void *e;
+
+	/* peak lll_event */
+	if (pipeline.head) {
+		e = (uint8_t *)pipeline.head + sizeof(void *);
+	} else {
+		e = NULL;
+	}
+
+	return e;
+}
+
+void *ull_prepare_dequeue_iter(void **idx)
+{
+	void *e;
+
+	/* Start at the head */
+	if (!*idx) {
+		*idx = pipeline.head;
+	}
+
+	/* No more in the list */
+	if (!*idx) {
+		return NULL;
+	}
+
+	/* Peak lll_event */
+	e = (uint8_t *)*idx + sizeof(void *);
+
+	/* Proceed to next */
+	*idx = *((void **)*idx);
+
+	return e;
+}
+
+void ull_prepare_dequeue(uint8_t caller_id)
+{
+	/* For testing, we just need a stub implementation
+	 * Full implementation would require mayfly, ticker, etc.
+	 */
+	(void)caller_id;
+}