extmod/zephyr_ble: Remove dead code from HAL shim files.

Cleanup unused functions, macros and debug helpers that were never called
or only conditionally compiled behind disabled feature flags. Removes dead
registry system, PSA crypto stubs, LIFO operations, and various unused
helper functions and inlines from kernel/device/config headers. Also
deletes gatt_pragma.h which is unreferenced.

Signed-off-by: Andrew Leech <andrew.leech@planetinnovation.com.au>

Author: pi-anl

extmod/zephyr_ble/gatt_pragma.h

@@ -54,18 +54,6 @@ static inline sys_snode_t *item_to_snode(void *item) {
 
 // --- k_queue API Implementation (underlying FIFO implementation) ---
 
-// Enable debug output (called after boot to avoid interfering with initialization)
-void mp_bluetooth_zephyr_fifo_enable_debug(void) {
-    debug_enabled = 1;
-    mp_printf(&mp_plat_print, "[FIFO] Debug output enabled\n");
-}
-
-void k_queue_init(struct k_queue *queue) {
-    DEBUG_FIFO("k_queue_init(%p)", queue);
-    queue->data_q.head = NULL;
-    queue->data_q.tail = NULL;
-    queue->lock.unused = 0;  // Initialize spinlock for completeness
-}
 
 void k_queue_append(struct k_queue *queue, void *data) {
     sys_snode_t *node = item_to_snode(data);

extmod/zephyr_ble/hal/zephyr_ble_fifo.c

@@ -46,36 +46,9 @@ static inline void k_yield(void) {
     // No-op in MicroPython scheduler
 }
 
-// Busy wait for short delays (microseconds)
-static inline void k_busy_wait(uint32_t usec_to_wait) {
-    mp_hal_delay_us(usec_to_wait);
-}
 
 // --- Uptime and Timing ---
 
-// Get system uptime in milliseconds
-static inline int64_t k_uptime_get(void) {
-    return (int64_t)mp_hal_ticks_ms();
-}
-
-// Get system uptime in 32-bit milliseconds (wraps at ~49 days)
-static inline uint32_t k_uptime_get_32(void) {
-    return mp_hal_ticks_ms();
-}
-
-// Convert uptime to ticks (1:1 mapping in MicroPython, both are milliseconds)
-static inline int64_t k_uptime_ticks(void) {
-    return (int64_t)mp_hal_ticks_ms();
-}
-
-// Get current cycle count (if available, otherwise return uptime in ms)
-static inline uint32_t k_cycle_get_32(void) {
-    #ifdef mp_hal_ticks_cpu
-    return mp_hal_ticks_cpu();
-    #else
-    return mp_hal_ticks_ms();
-    #endif
-}
 
 // --- Thread Info (No-op in MicroPython) ---
 
@@ -105,10 +78,6 @@ static inline bool k_is_in_isr(void) {
     return false;
 }
 
-// Check if pre-emptible (always returns false, no preemption in scheduler)
-static inline bool k_is_preempt_thread(void) {
-    return false;
-}
 
 // --- System State ---
 
@@ -117,10 +86,6 @@ static inline bool k_is_preempt_thread(void) {
 #define KERNEL_VERSION_MINOR 7
 #define KERNEL_VERSION_PATCHLEVEL 0
 
-// System state (always running in MicroPython)
-static inline bool k_is_pre_kernel(void) {
-    return false;
-}
 
 // --- Fatal Error Handlers ---
 

extmod/zephyr_ble/hal/zephyr_ble_kernel.h

@@ -40,11 +40,6 @@ static volatile int debug_enabled = 0;
         } \
     } while (0)
 
-// Enable debug output
-void mp_bluetooth_zephyr_mem_slab_enable_debug(void) {
-    debug_enabled = 1;
-    mp_printf(&mp_plat_print, "[SLAB] Debug output enabled\n");
-}
 
 // Initialize a memory slab (called by K_MEM_SLAB_DEFINE_STATIC macro)
 void k_mem_slab_init(struct k_mem_slab *slab, void *buffer, size_t block_size, uint32_t num_blocks) {

extmod/zephyr_ble/hal/zephyr_ble_mem_slab.c

@@ -142,15 +142,6 @@ void mp_bluetooth_zephyr_hci_uart_wfi(void) {
 
 // --- Polling Functions ---
 
-void mp_bluetooth_zephyr_poll_init(void) {
-    // Currently nothing to initialize
-    // Timers and work queues are initialized on first use
-}
-
-void mp_bluetooth_zephyr_poll_deinit(void) {
-    // Currently nothing to deinitialize
-    // In the future, this might clean up global state
-}
 
 void mp_bluetooth_zephyr_poll(void) {
     // Process HCI UART first (if implemented)

extmod/zephyr_ble/hal/zephyr_ble_poll.c

@@ -153,7 +153,3 @@ unsigned int k_sem_count_get(struct k_sem *sem) {
     return sem->count;
 }
 
-void k_sem_reset(struct k_sem *sem) {
-    DEBUG_SEM_printf("k_sem_reset(%p)\n", sem);
-    sem->count = 0;
-}

extmod/zephyr_ble/hal/zephyr_ble_psa_crypto.c

@@ -33,8 +33,6 @@
 
 #include <stddef.h>
 
-// Debug counter for tracking execution (avoids printf blocking issues)
-volatile int ble_work_debug_step = 0;
 
 // Flag to indicate we're in the bt_enable() init phase
 // During this phase, mp_bluetooth_zephyr_init_work_get() will get work from k_sys_work_q
@@ -222,11 +220,6 @@ int k_work_cancel(struct k_work *work) {
     return 1;
 }
 
-int k_work_cancel_sync(struct k_work *work, void *sync) {
-    // sync parameter is for synchronization with other threads, not needed in MicroPython
-    (void)sync;
-    return k_work_cancel(work);
-}
 
 bool k_work_is_pending(const struct k_work *work) {
     return work->pending;
@@ -286,19 +279,13 @@ int k_work_schedule(struct k_work_delayable *dwork, k_timeout_t delay) {
     return k_work_schedule_for_queue(&k_sys_work_q, dwork, delay);
 }
 
-int k_work_reschedule_for_queue(struct k_work_q *queue, struct k_work_delayable *dwork, k_timeout_t delay) {
-    DEBUG_WORK_printf("k_work_reschedule_for_queue(%p, %p, %u)\n", queue, dwork, delay.ticks);
-
-    // Reschedule is the same as schedule in our implementation
-    return k_work_schedule_for_queue(queue, dwork, delay);
-}
 
 int k_work_reschedule(struct k_work_delayable *dwork, k_timeout_t delay) {
     if (!k_sys_work_q.head && !k_sys_work_q.nextq) {
         k_work_queue_init(&k_sys_work_q);
         k_sys_work_q.name = "SYS WQ";
     }
-    return k_work_reschedule_for_queue(&k_sys_work_q, dwork, delay);
+    return k_work_schedule_for_queue(&k_sys_work_q, dwork, delay);
 }
 
 int k_work_cancel_delayable(struct k_work_delayable *dwork) {
@@ -441,48 +428,6 @@ void mp_bluetooth_zephyr_work_process(void) {
     work_process_depth--;
 }
 
-// Called by mp_bluetooth_init() wait loop to process initialization work synchronously
-void mp_bluetooth_zephyr_work_process_init(void) {
-    // Prevent recursion (though unlikely since init work should be synchronous)
-    if (init_work_processor_running) {
-        DEBUG_WORK_printf("init_work_process: already running, skipping\n");
-        return;
-    }
-
-    init_work_processor_running = true;
-
-    // Process ONLY the initialization work queue
-    struct k_work_q *q = &k_init_work_q;
-
-    while (q->head != NULL) {
-        // Dequeue work item
-        struct k_work *work = q->head;
-        q->head = work->next;
-
-        if (q->head) {
-            q->head->prev = NULL;
-        }
-
-        work->next = NULL;
-        work->prev = NULL;
-        work->pending = false;
-
-        // Execute work handler
-        DEBUG_WORK_printf("init_work_execute(%p, handler=%p)\n", work, work->handler);
-        if (work->handler) {
-            work->handler(work);
-        }
-        DEBUG_WORK_printf("init_work_execute(%p) done\n", work);
-
-        // Check if work was re-enqueued during execution
-        if (work->pending) {
-            DEBUG_WORK_printf("  --> init work re-enqueued, stopping queue processing\n");
-            break;
-        }
-    }
-
-    init_work_processor_running = false;
-}
 
 // --- Init Work Helper Functions ---
 
@@ -543,74 +488,7 @@ struct k_work *mp_bluetooth_zephyr_init_work_get(void) {
     return work;
 }
 
-// Debug function to report work processing statistics
-void mp_bluetooth_zephyr_work_debug_stats(void) {
-    mp_printf(&mp_plat_print, "WORK STATS: process() called %d times, %d items processed\n",
-        work_process_call_count, work_items_processed);
-}
-
-// Process all pending work in all queues (except during init phase).
-// Used by the FreeRTOS work queue thread (added in zephyr_ble_freertos branch).
-#if MICROPY_BLUETOOTH_ZEPHYR_USE_FREERTOS
-static void ble_work_process_all(void) {
-    ble_work_debug_step = 10;  // Entered ble_work_process_all
 
-    // During init phase, main loop handles all work processing
-    // to ensure proper sequencing of bt_enable() initialization
-    if (mp_bluetooth_zephyr_in_init_phase()) {
-        ble_work_debug_step = 11;  // Skip due to init phase
-        return;
-    }
-    ble_work_debug_step = 12;  // Processing work
-
-    for (struct k_work_q *q = global_work_q; q != NULL; q = q->nextq) {
-        // Skip initialization work queue (processed separately)
-        if (q == &k_init_work_q) {
-            continue;
-        }
-
-        // Process all work items in this queue
-        // Note: Must check q->head inside critical section to avoid race
-        for (;;) {
-            // Dequeue work item atomically
-            MICROPY_PY_BLUETOOTH_ENTER
-            struct k_work *work = q->head;
-            if (work == NULL) {
-                MICROPY_PY_BLUETOOTH_EXIT
-                break;  // Queue empty
-            }
-            q->head = work->next;
-            if (q->head) {
-                q->head->prev = NULL;
-            }
-            work->next = NULL;
-            work->prev = NULL;
-            work->pending = false;
-            MICROPY_PY_BLUETOOTH_EXIT
-
-            // Execute work handler outside critical section
-                work_items_processed++;
-            ble_work_debug_step = 20;  // About to execute work handler
-
-            if (work->handler) {
-                // Set context flag if processing system work queue
-                bool is_sys_wq = (q == &k_sys_work_q);
-                if (is_sys_wq) {
-                    in_sys_work_q_context = true;
-                }
-                ble_work_debug_step = 21;  // Calling handler
-                work->handler(work);
-                ble_work_debug_step = 22;  // Handler returned
-                if (is_sys_wq) {
-                    in_sys_work_q_context = false;
-                }
-            }
-
-            ble_work_debug_step = 23;  // Work done
-        }
-    }
-}
-#endif // MICROPY_BLUETOOTH_ZEPHYR_USE_FREERTOS
 
 // Stub implementations — work processed via cooperative polling, no dedicated work thread.
 void mp_bluetooth_zephyr_work_thread_start(void) {