工具：FRDM-KL25Z開發板

問題：在除錯PWM驅動的過程中一直無法找到裝置節點。

1、查詢pwm註冊pwm_register的地方。

->board_app_initialize()
   ->kl_pwm_setup()
      ->pwm_register()

2、發現board_app_initialize在這裡被呼叫：

#ifdef CONFIG_BOARD_INITIALIZE
void board_initialize(void)
{
  /* Perform NSH initialization here instead of from the NSH.  This
   * alternative NSH initialization is necessary when NSH is ran in user-space
   * but the initialization function must run in kernel space.
   */

#if defined(CONFIG_NSH_LIBRARY) && !defined(CONFIG_LIB_BOARDCTL)
  (void)board_app_initialize(0);
#endif

  /* CC3000 wireless initialization */

#ifdef CONFIG_WL_CC3000
  wireless_archinitialize(0);
#endif
}
#endif
 

  │ CONFIG_BOARD_INITIALIZE:                                                                                                                                                                                  │
  │                                                                                                                                                                                                           │
  │ By default, there are three points in time where you can insert                                                                                                                                           │
  │ custom initialization logic:                                                                                                                                                                              │
  │                                                                                                                                                                                                           │
  │ 1) <arch>_boardinitialize():  This function is used only for                                                                                                                                              │
  │ initialization of very low-level things like configuration of                                                                                                                                             │
  │ GPIO pins, power setting.  The OS has not been initialized                                                                                                                                                │
  │ at this point, so you cannot allocate memory or initialize                                                                                                                                                │
  │ device drivers at this phase.                                                                                                                                                                             │
  │                                                                                                                                                                                                           │
  │ 2) The next level of initialization is performed by a call to                                                                                                                                             │
  │ up_initialize() (in arch/<arch>/src/common/up_initialize.c).                                                                                                                                              │
  │ The OS has been initialized at this point and it is okay to                                                                                                                                               │
  │ initialize drivers in this phase.                                                                                                                                                                         │
  │                                                                                                                                                                                                           │
  │ 3) And, finally, when the user application code starts.                                                                                                                                                   │
  │                                                                                                                                                                                                           │
  │ If BOARD_INITIALIZE is selected, then an additional initialization                                                                                                                                        │
  │ call will be performed in the boot-up sequence to a function                                                                                                                                              │
  │ called board_initialize().  board_initialize() will be                                                                                                                                                    │
  │ call between phases 2) and 3) above, immediately after                                                                                                                                                    │
  │ up_initialize() is called.  This additional initialization                                                                                                                                                │
  │ phase may be used, for example, to initialize board-specific                                                                                                                                              │
  │ device drivers.                                                                                                                                                                                           │
  │                                                                                                                                                                                                           │
  │ Symbol: BOARD_INITIALIZE [=n]                                                                                                                                                                             │
  │ Type  : boolean                                                                                                                                                                                           │
  │ Prompt: Custom board/driver initialization                                                                                                                                                                │
  │   Location:                                                                                                                                                                                               │
  │     -> RTOS Features                                                                                                                                                                                      │
  │       -> RTOS hooks                                                                                                                                                                                       │
  │   Defined at sched/Kconfig:970    
 

第一種情況是呼叫<arch>_boardinitialize()，這個函式只能進行一些低階的初始化，因為系統還沒有完全完成初始化，無法分配記憶體來完成裝置初始化。

第二種情況是呼叫up_initialize()，在這個時間節點，系統已經完成了初始化，可以進行裝置驅動的初始化。

第三種情況是在使用者應用程式中進行。

從以上的分析可以看出，很明顯在第二個階段和第三個階段中間是最適合進行板級裝置初始化的。而board_initialize()剛好就是用來完成這個任務的。

但是

board_app_initialize

依賴於

CONFIG_NSH_LIBRARY
!CONFIG_LIB_BOARDCTL
 

後來發現，之所以有這樣的限制，是因為BOARDCTL介面有同樣的功能。

3、BOARDCTL介面實現初始化

void nsh_initialize(void)
{
#if defined(CONFIG_NSH_READLINE) && defined(CONFIG_READLINE_TABCOMPLETION)
  /* Configure the NSH prompt */

  (void)readline_prompt(g_nshprompt);

#ifdef CONFIG_READLINE_HAVE_EXTMATCH
  /* Set up for tab completion on NSH commands */

  (void)readline_extmatch(&g_nsh_extmatch);
#endif
#endif

  /* Mount the /etc filesystem */

  (void)nsh_romfsetc();

#ifdef CONFIG_NSH_ARCHINIT
  /* Perform architecture-specific initialization (if configured) */

  (void)boardctl(BOARDIOC_INIT, 0);
#endif

  /* Bring up the network */

  (void)nsh_netinit();
}

int boardctl(unsigned int cmd, uintptr_t arg)
{
  int ret;

  switch (cmd)
    {
      /* CMD:           BOARDIOC_INIT
       * DESCRIPTION:   Perform one-time application initialization.
       * ARG:           The boardctl() argument is passed to the
       *                board_app_initialize() implementation without modification.
       *                The argument has no meaning to NuttX; the meaning of the
       *                argument is a contract between the board-specific
       *                initalization logic and the matching application logic.
       *                The value cold be such things as a mode enumeration value,
       *                a set of DIP switch switch settings, a pointer to
       *                configuration data read from a file or serial FLASH, or
       *                whatever you would like to do with it.  Every
       *                implementation should accept zero/NULL as a default
       *                configuration.
       * CONFIGURATION: CONFIG_LIB_BOARDCTL
       * DEPENDENCIES:  Board logic must provide board_app_initialization
       */

      case BOARDIOC_INIT:
        {
          ret = board_app_initialize(arg);
        }
        break;

        ... ...
}

這兩種方式裝置驅動初始化有什麼區別呢？暫時還沒有了解到。