Add comprehensive help descriptions to Kconfig files in libcpu and components

Co-authored-by: Rbb666 <64397326+Rbb666@users.noreply.github.com>

Author: Copilot

components/Kconfig

@@ -3,27 +3,120 @@ menu "RT-Thread Components"
 config RT_USING_COMPONENTS_INIT
     bool
     default n
+    help
+        Enable automatic component initialization framework.
+        
+        When enabled, components marked with INIT_EXPORT() macros will be
+        automatically initialized during system startup in proper order.
+        
+        Initialization levels (in order):
+        - INIT_BOARD_EXPORT: Board-level initialization (pins, clocks)
+        - INIT_PREV_EXPORT: Early driver initialization
+        - INIT_DEVICE_EXPORT: Device driver initialization
+        - INIT_COMPONENT_EXPORT: Component initialization
+        - INIT_ENV_EXPORT: Environment initialization
+        - INIT_APP_EXPORT: Application initialization
+        
+        Benefits:
+        - Automatic dependency ordering
+        - Cleaner code (no manual init function calls)
+        - Consistent initialization across components
+        
+        Note: Most RT-Thread components rely on this. Usually enabled automatically
+        by build system.
 
 config RT_USING_USER_MAIN
     bool
     default n
+    help
+        Use user-defined main() function as entry point.
+        
+        When enabled, RT-Thread creates a main thread that calls your main() function,
+        allowing traditional C programming style entry point.
+        
+        Without this option: You must manually create threads from application
+        With this option: Your main() function runs in a dedicated main thread
+        
+        The main thread:
+        - Runs after system initialization
+        - Has configurable stack size and priority
+        - Can use RT-Thread APIs like any other thread
+        - Can create additional threads
+        
+        Enable this for easier application development and familiar entry point.
 
     if RT_USING_USER_MAIN
         config RT_MAIN_THREAD_STACK_SIZE
             int "Set main thread stack size"
             default 6144 if ARCH_CPU_64BIT
             default 2048
+            help
+                Stack size in bytes for the main thread.
+                
+                Default values:
+                - 64-bit architectures: 6144 bytes (6KB)
+                - 32-bit architectures: 2048 bytes (2KB)
+                
+                Increase if:
+                - Deep recursion in main()
+                - Large local variables
+                - Stack overflow in main thread
+                - Complex initialization requiring more stack
+                
+                Decrease for memory-constrained systems if main() is simple.
+                
+                Note: Each thread's stack is separate. This only affects main thread.
 
         config RT_MAIN_THREAD_PRIORITY
             int "Set main thread priority"
             default 4   if RT_THREAD_PRIORITY_8
             default 10  if RT_THREAD_PRIORITY_32
             default 85  if RT_THREAD_PRIORITY_256
+            help
+                Priority of the main thread (lower number = higher priority).
+                
+                Default values scale with priority levels:
+                - 8 levels: Priority 4 (middle-low priority)
+                - 32 levels: Priority 10 (medium priority)
+                - 256 levels: Priority 85 (medium-low priority)
+                
+                Lower values (higher priority) if:
+                - Main thread needs to preempt other tasks
+                - Time-critical initialization in main()
+                
+                Higher values (lower priority) if:
+                - Main thread is just coordination/monitoring
+                - Other threads need priority over main
+                
+                Note: Priority 0 is highest, maximum is configured by RT_THREAD_PRIORITY_MAX.
     endif
 
 config RT_USING_LEGACY
     bool "Support legacy version for compatibility"
     default n
+    help
+        Enable compatibility layer for legacy RT-Thread versions.
+        
+        Provides deprecated APIs and compatibility shims for older code,
+        allowing gradual migration to newer RT-Thread versions.
+        
+        Includes:
+        - Deprecated API wrappers
+        - Legacy component interfaces
+        - Backward-compatible behavior
+        
+        Enable if:
+        - Porting code from older RT-Thread versions
+        - Using third-party libraries requiring legacy APIs
+        - Gradual migration strategy
+        
+        Disable for:
+        - New projects (use modern APIs)
+        - Smaller code size
+        - Better performance (no compatibility overhead)
+        
+        Note: Legacy support may be removed in future versions.
+        Plan to migrate to current APIs.
 
 if RT_USING_CONSOLE
 rsource "finsh/Kconfig"

components/mprotect/Kconfig

@@ -4,25 +4,165 @@ config RT_USING_MEM_PROTECTION
     bool "Enable memory protection"
     default n
     select RT_USING_HEAP
+    help
+        Enable memory protection framework using MPU (Memory Protection Unit).
+        
+        Provides hardware-based memory protection to prevent:
+        - Stack overflow and underflow
+        - Buffer overruns
+        - Unauthorized access to memory regions
+        - Corruption of kernel data structures
+        
+        Features:
+        - Per-thread memory protection
+        - Stack guard regions
+        - Configurable memory regions with access permissions
+        - Exclusive regions for sensitive data
+        
+        Requirements:
+        - CPU with MPU support (Cortex-M3/M4/M7/M33/R52, etc.)
+        - ARCH_MM_MPU or ARCH_ARM_MPU enabled
+        - RT_USING_HEAP (dynamic memory)
+        
+        Benefits:
+        - Catch memory bugs early (development)
+        - Improve system safety (production)
+        - Isolate thread memory spaces
+        
+        Costs:
+        - Context switch overhead (save/restore MPU regions)
+        - Configuration complexity
+        - Slight runtime overhead
+        
+        Ideal for safety-critical applications and debugging memory issues.
 
 config RT_USING_HW_STACK_GUARD
     bool "Enable hardware stack guard"
     default n
     select RT_USING_MEM_PROTECTION
+    help
+        Enable hardware-based stack overflow protection using MPU.
+        
+        Automatically creates guard regions at the end of each thread's stack
+        to detect stack overflow at the moment it occurs.
+        
+        How it works:
+        - Configures MPU region below stack as no-access
+        - Stack overflow triggers immediate MPU fault
+        - Exception handler identifies the overflowing thread
+        
+        Benefits:
+        - Immediate detection (vs periodic checks)
+        - Precise identification of overflow location
+        - No runtime overhead (hardware-based)
+        - Catches stack corruption before it spreads
+        
+        Requirements:
+        - RT_USING_MEM_PROTECTION enabled
+        - Sufficient MPU regions (at least 1 per thread)
+        
+        Recommended for:
+        - Development and debugging
+        - Safety-critical systems
+        - Systems with limited stack space
+        
+        Note: Requires one MPU region per thread. Check NUM_MEM_REGIONS configuration.
 
 if RT_USING_MEM_PROTECTION
     config USE_MEM_PROTECTION_EXAMPLES
     bool "Use memory protection examples"
     default y
+    help
+        Build and include memory protection example code.
+        
+        Provides demonstration code showing how to:
+        - Configure memory protection regions
+        - Set up stack guards
+        - Add exclusive regions
+        - Handle protection faults
+        
+        Useful for:
+        - Learning memory protection concepts
+        - Testing MPU functionality
+        - Debugging protection configurations
+        
+        Disable for production builds to save code space.
 
     config NUM_MEM_REGIONS
     int "Total number of memory protection regions supported by hardware"
+    help
+        Total number of MPU regions available in hardware.
+        
+        This depends on your CPU architecture:
+        - Cortex-M3/M4: Typically 8 regions
+        - Cortex-M7: 8 or 16 regions
+        - Cortex-M33/M85: 8 or 16 regions (configurable in silicon)
+        - Cortex-R52: 16 or 32 regions
+        
+        Check your MCU datasheet or reference manual for exact count.
+        
+        Usage breakdown:
+        - Stack guard per thread: 1 region per thread
+        - Exclusive regions: NUM_EXCLUSIVE_REGIONS
+        - Configurable per thread: NUM_CONFIGURABLE_REGIONS
+        
+        Formula: NUM_MEM_REGIONS = 1 (stack) + NUM_EXCLUSIVE_REGIONS + NUM_CONFIGURABLE_REGIONS
+        
+        Example for 8-region MPU with 2 threads:
+        - Thread 1 stack guard: 1 region
+        - Thread 2 stack guard: 1 region
+        - Shared exclusive regions: 2 regions
+        - Per-thread config: 2 regions per thread
+        Total: 2 + 2 + 4 = 8 regions
 
     config NUM_EXCLUSIVE_REGIONS
     int "Total number of exclusive memory regions added using rt_mprotect_add_exclusive_region API"
+    help
+        Number of shared exclusive memory protection regions.
+        
+        Exclusive regions are memory areas with specific access permissions
+        shared across all threads (e.g., peripheral registers, kernel data).
+        
+        Use cases:
+        - Protect peripheral registers from thread access
+        - Mark flash memory as read-only/execute-only
+        - Protect kernel data structures
+        - Define shared memory with specific permissions
+        
+        Example configurations:
+        - Peripheral protection: 1-2 regions
+        - Kernel data protection: 1 region
+        - Shared buffers: 0-2 regions
+        
+        Note: These regions are configured once and apply to all threads.
+        Set based on your system's protection requirements.
 
     config NUM_CONFIGURABLE_REGIONS
     int "Maximum number of configurable memory regions for each thread, excluding stack guard and exclusive regions added using rt_mprotect_add_exclusive_region API"
+    help
+        Per-thread configurable memory protection regions.
+        
+        These regions are specific to each thread and can be configured independently
+        for thread-specific memory protection needs.
+        
+        Use cases:
+        - Protect thread's private data buffers
+        - Restrict access to thread-local peripherals
+        - Define custom memory permissions per thread
+        
+        Calculation:
+        NUM_CONFIGURABLE_REGIONS = NUM_MEM_REGIONS - 1 (stack) - NUM_EXCLUSIVE_REGIONS
+        
+        Example for 8-region MPU with 2 exclusive regions:
+        NUM_CONFIGURABLE_REGIONS = 8 - 1 - 2 = 5 regions per thread
+        
+        More regions = more flexibility but:
+        - Increased configuration complexity
+        - Longer context switch time
+        - More memory for region descriptors
+        
+        Set based on your application's per-thread protection needs.
+        Typical values: 1-4 regions per thread.
 endif
 
 endmenu