fix(fl): report error when enable fails on single comp, add patch_mode tracking

fl_cmd_enable reported [FLOK] even when fpb_enable_patch failed for a
single comparator (e.g. enabling an unset patch). Now it checks the
return value and reports [FLERR] with FL_ERR_HW on failure.

Also add fl_patch_mode_t to fl_slot_state_t so info display can show
the actual patch mode (remap/trampoline/debugmon) from slot state
instead of relying on hardware COMP register readback which may be
unreliable on FPBv2.

Author: FASTSHIFT

App/func_loader/fl.h

@@ -57,11 +57,22 @@ typedef void (*fl_free_cb_t)(void* ptr);
 typedef void (*fl_flush_dcache_cb_t)(uintptr_t start, uintptr_t end);
 typedef void (*fl_invalidate_icache_cb_t)(uintptr_t start, uintptr_t end);
 
+/**
+ * @brief Patch mode for slot tracking
+ */
+typedef enum {
+    FL_PATCH_MODE_NONE = 0,   /* Not patched */
+    FL_PATCH_MODE_REMAP,      /* FPB REMAP (patch command) */
+    FL_PATCH_MODE_TRAMPOLINE, /* FPB REMAP + trampoline (tpatch command) */
+    FL_PATCH_MODE_DEBUGMON,   /* FPB BKPT + DebugMonitor (dpatch command) */
+} fl_patch_mode_t;
+
 /**
  * @brief Slot state for tracking injection info
  */
 typedef struct {
     bool active;          /* Slot is in use */
+    fl_patch_mode_t mode; /* Patch mode used */
     uint32_t orig_addr;   /* Original function address */
     uint32_t target_addr; /* Injected code address */
     uint32_t code_size;   /* Injected code size */

App/func_loader/fl_cmd_patch.c

@@ -62,10 +62,18 @@ void fl_cmd_print_fpb_info(fl_context_t* ctx) {
                    (unsigned long)fpb_info.remap_base, fpb_info.remap_supported ? "supported" : "not supported");
 
         static const char* replace_mode_str[] = {"remap", "bp_lo", "bp_hi", "bp_both"};
+        static const char* patch_mode_str[] = {"none", "remap", "trampoline", "debugmon"};
         for (uint32_t i = 0; i < num_comps && i < FL_MAX_SLOTS && i < FPB_MAX_CODE_COMP; i++) {
             fl_slot_state_t* slot = &ctx->slots[i];
             fpb_comp_info_t* comp = &fpb_info.comp[i];
-            const char* mode_str = (comp->replace < 4) ? replace_mode_str[comp->replace] : "?";
+            const char* mode_str;
+
+            /* Use slot's patch mode if active, otherwise fall back to hardware REPLACE field */
+            if (slot->active && slot->mode < 4) {
+                mode_str = patch_mode_str[slot->mode];
+            } else {
+                mode_str = (comp->replace < 4) ? replace_mode_str[comp->replace] : "?";
+            }
 
             if (slot->active) {
                 fl_println("Slot[%u]: 0x%08lX -> 0x%08lX, %u bytes (COMP=0x%08lX, %s, %s)", (unsigned)i,
@@ -120,6 +128,7 @@ fl_error_t fl_cmd_patch(fl_context_t* ctx, const cmd_args_t* args) {
 
     /* Record slot state, transfer last_alloc ownership to slot */
     ctx->slots[args->comp].active = true;
+    ctx->slots[args->comp].mode = FL_PATCH_MODE_REMAP;
     ctx->slots[args->comp].orig_addr = args->orig;
     ctx->slots[args->comp].target_addr = args->target;
     ctx->slots[args->comp].code_size = ctx->last_alloc_size;
@@ -163,6 +172,7 @@ fl_error_t fl_cmd_tpatch(fl_context_t* ctx, const cmd_args_t* args) {
 
     /* Record slot state, transfer last_alloc ownership to slot */
     ctx->slots[args->comp].active = true;
+    ctx->slots[args->comp].mode = FL_PATCH_MODE_TRAMPOLINE;
     ctx->slots[args->comp].orig_addr = args->orig;
     ctx->slots[args->comp].target_addr = args->target;
     ctx->slots[args->comp].code_size = ctx->last_alloc_size;
@@ -211,6 +221,7 @@ fl_error_t fl_cmd_dpatch(fl_context_t* ctx, const cmd_args_t* args) {
 
     /* Record slot state, transfer last_alloc ownership to slot */
     ctx->slots[args->comp].active = true;
+    ctx->slots[args->comp].mode = FL_PATCH_MODE_DEBUGMON;
     ctx->slots[args->comp].orig_addr = args->orig;
     ctx->slots[args->comp].target_addr = args->target;
     ctx->slots[args->comp].code_size = ctx->last_alloc_size;
@@ -266,6 +277,7 @@ fl_error_t fl_cmd_unpatch(fl_context_t* ctx, const cmd_args_t* args) {
 
             /* Clear slot state */
             ctx->slots[i].active = false;
+            ctx->slots[i].mode = FL_PATCH_MODE_NONE;
             ctx->slots[i].orig_addr = 0;
             ctx->slots[i].target_addr = 0;
             ctx->slots[i].code_size = 0;
@@ -300,7 +312,6 @@ fl_error_t fl_cmd_enable(fl_context_t* ctx, const cmd_args_t* args) {
         }
     }
 
-    (void)ctx;
     bool en = args->enable != 0;
     bool all = args->all;
     uint32_t comp = (uint32_t)args->comp;
@@ -315,10 +326,16 @@ fl_error_t fl_cmd_enable(fl_context_t* ctx, const cmd_args_t* args) {
 
     uint32_t changed = 0;
     for (uint32_t i = start; i < end && i < FL_MAX_SLOTS; i++) {
+        if (all && !ctx->slots[i].active) {
+            continue; /* --all mode: skip inactive slots */
+        }
+
         fpb_result_t ret = fpb_enable_patch(i, en);
-        if (ret == FPB_OK) {
-            changed++;
+        if (ret != FPB_OK) {
+            fl_response(false, "Failed to %s patch %lu: %d", en ? "enable" : "disable", (unsigned long)i, ret);
+            return FL_ERR_HW;
         }
+        changed++;
     }
 
     if (all) {

App/tests/test_fl.c

@@ -1406,12 +1406,12 @@ void test_loader_cmd_enable_unset_patch(void) {
     setup_loader();
     fl_init(&test_ctx);
 
-    /* Try to enable a patch that was never set - should succeed but report 0 changed */
+    /* Try to enable a patch that was never set - should fail */
     const char* argv[] = {"fl", "--cmd", "enable", "--comp", "0", "--enable", "1"};
     fl_error_t result = fl_exec_cmd(&test_ctx, 7, argv);
 
-    /* fpb_enable_patch returns FPB_ERR_NOT_SET for unset patches, so changed=0 */
-    TEST_ASSERT_EQUAL(FL_OK, result);
+    TEST_ASSERT_EQUAL(FL_ERR_HW, result);
+    TEST_ASSERT(mock_output_contains("Failed to enable"));
 }
 
 /* ============================================================================
@@ -2011,6 +2011,18 @@ void test_loader_cmd_enable_with_crc(void) {
     setup_loader();
     fl_init(&test_ctx);
 
+    /* Set up a patch first so enable has something to work with */
+    const char* alloc_argv[] = {"fl", "--cmd", "alloc", "--size", "64"};
+    fl_exec_cmd(&test_ctx, 5, alloc_argv);
+
+    const char* patch_argv[]
+        = {"fl", "--cmd", "patch", "--comp", "0", "--orig", "0x08001000", "--target", "0x20000100"};
+    fl_exec_cmd(&test_ctx, 9, patch_argv);
+
+    /* Disable first so we can test re-enable with CRC */
+    const char* disable_argv[] = {"fl", "--cmd", "enable", "--comp", "0", "--enable", "0"};
+    fl_exec_cmd(&test_ctx, 7, disable_argv);
+
     /* CRC of comp=0 + enable=1 */
     uint32_t comp32 = 0;
     uint32_t enable32 = 1;