[thread-direct] add NCP/Spinel Thread Direct Wake property handlers

Extends `spinel.h` with new Thread Direct Wake property IDs.

Author: suveshpratapa

src/lib/spinel/spinel.c

@@ -1365,7 +1365,14 @@ const char *spinel_prop_key_to_cstr(spinel_prop_key_t prop_key)
         {SPINEL_PROP_THREAD_BACKBONE_ROUTER_LOCAL_REGISTRATION_JITTER,
          "THREAD_BACKBONE_ROUTER_LOCAL_REGISTRATION_JITTER"},
         {SPINEL_PROP_THREAD_MGMT_SET_PENDING_DATASET_TLVS, "THREAD_MGMT_SET_PENDING_DATASET_TLVS"},
-        {SPINEL_PROP_THREAD_DIRECT_WAKE_CHANNEL, "THREAD_WAKEUP_CHANNEL"},
+        {SPINEL_PROP_THREAD_DIRECT_WAKE_CHANNEL, "THREAD_DIRECT_WAKE_CHANNEL"},
+        {SPINEL_PROP_THREAD_DIRECT_WAKE_LISTEN_ENABLED, "THREAD_DIRECT_WAKE_LISTEN_ENABLED"},
+        {SPINEL_PROP_THREAD_DIRECT_WAKE_LISTEN_PARAMS, "THREAD_DIRECT_WAKE_LISTEN_PARAMS"},
+        {SPINEL_PROP_THREAD_DIRECT_WAKE, "THREAD_DIRECT_WAKE"},
+        {SPINEL_PROP_THREAD_DIRECT_GUEST_WAKE_KEY, "THREAD_DIRECT_GUEST_WAKE_KEY"},
+        {SPINEL_PROP_THREAD_DIRECT_LINK_EVENT, "THREAD_DIRECT_LINK_EVENT"},
+        {SPINEL_PROP_THREAD_DIRECT_WAKE_BURST_ACTIVE, "THREAD_DIRECT_WAKE_BURST_ACTIVE"},
+        {SPINEL_PROP_THREAD_DIRECT_WAKE_FRAME_COUNTER, "THREAD_DIRECT_WAKE_FRAME_COUNTER"},
         {SPINEL_PROP_MESHCOP_JOINER_STATE, "MESHCOP_JOINER_STATE"},
         {SPINEL_PROP_MESHCOP_JOINER_COMMISSIONING, "MESHCOP_JOINER_COMMISSIONING"},
         {SPINEL_PROP_IPV6_LL_ADDR, "IPV6_LL_ADDR"},

src/lib/spinel/spinel.h

@@ -3310,6 +3310,73 @@ enum
      */
     SPINEL_PROP_THREAD_DIRECT_WAKE_CHANNEL = SPINEL_PROP_THREAD_EXT__BEGIN + 63,
 
+    /// Thread Direct Wake Listener Enable
+    /** Format: `b` - Read-write
+     *
+     * Indicates whether the Wake Listener scheduled receive window is enabled.
+     * When enabled the device opens periodic listen windows on the wake channel
+     * according to the configured listen parameters.
+     */
+    SPINEL_PROP_THREAD_DIRECT_WAKE_LISTEN_ENABLED = SPINEL_PROP_THREAD_EXT__BEGIN + 64,
+
+    /// Thread Direct Wake Listener Parameters
+    /** Format: `LL` - Read-write
+     *
+     * Configures the Wake Listener scheduled receive window timing:
+     *   `L` - Listen interval in microseconds.
+     *   `L` - Listen window duration in microseconds.
+     */
+    SPINEL_PROP_THREAD_DIRECT_WAKE_LISTEN_PARAMS = SPINEL_PROP_THREAD_EXT__BEGIN + 65,
+
+    /// Thread Direct Wake (start wake burst)
+    /** Format: `ECSSCd` - Write only
+     *
+     * Starts a Thread Direct wake burst targeting the specified WL:
+     *   `E` - WL extended address.
+     *   `C` - Wake type (0=link, 1=poweroutage, 2=connectionless).
+     *   `S` - Inter-frame interval in us (0 = default).
+     *   `S` - Burst duration in ms (0 = default).
+     *   `C` - Key index (0 or 129 = default key; 130-192 = guest key provisioned via
+     *         SPINEL_PROP_THREAD_DIRECT_GUEST_WAKE_KEY).
+     *   `d` - Inline key (legacy field; must be zero-length; ignored).
+     *
+     * The result is reported asynchronously via SPINEL_PROP_THREAD_DIRECT_LINK_EVENT.
+     */
+    SPINEL_PROP_THREAD_DIRECT_WAKE = SPINEL_PROP_THREAD_EXT__BEGIN + 68,
+
+    /// Thread Direct Guest Wake Key
+    /** Format: `Cd` - Insert, `C` - Remove
+     *
+     * Manages the out-of-band guest wake key table:
+     *   Insert (`SPINEL_CMD_PROP_VALUE_INSERT`): `C` key index, `d` 16-byte key material.
+     *   Remove (`SPINEL_CMD_PROP_VALUE_REMOVE`): `C` key index.
+     */
+    SPINEL_PROP_THREAD_DIRECT_GUEST_WAKE_KEY = SPINEL_PROP_THREAD_EXT__BEGIN + 71,
+
+    /// Thread Direct Link Event Notification
+    /** Format: `CEb` - Unsolicited notify (PROP_VALUE_IS)
+     *
+     * Reports Thread Direct link events (`otThreadDirectEvent`):
+     *   `C` - Event: 0 = linked, 1 = link failed, 2 = unlinked, 3 = wake received.
+     *   `E` - Peer extended address (zero if none, e.g. some link-failed cases).
+     *   `b` - Success indicator: false only for event 1 (link failed); true otherwise.
+     */
+    SPINEL_PROP_THREAD_DIRECT_LINK_EVENT = SPINEL_PROP_THREAD_EXT__BEGIN + 72,
+
+    /// Thread Direct - WI wake burst active
+    /** Format: `b` - Read only
+     *
+     * TRUE when the WI has an active wake burst or open connection window.
+     */
+    SPINEL_PROP_THREAD_DIRECT_WAKE_BURST_ACTIVE = SPINEL_PROP_THREAD_EXT__BEGIN + 73,
+
+    /// Thread Direct Wake Frame Counter
+    /** Format: `L` - Read-write
+     *
+     * The current Thread Direct wake frame counter.
+     */
+    SPINEL_PROP_THREAD_DIRECT_WAKE_FRAME_COUNTER = SPINEL_PROP_THREAD_EXT__BEGIN + 75,
+
     SPINEL_PROP_THREAD_EXT__END = 0x1600,
 
     SPINEL_PROP_IPV6__BEGIN = 0x60,

src/ncp/ncp_base.cpp

@@ -43,6 +43,9 @@
 #include <openthread/logging.h>
 #include <openthread/ncp.h>
 #include <openthread/network_time.h>
+#if OPENTHREAD_CONFIG_THREAD_DIRECT_WAKE_INITIATOR_ENABLE || OPENTHREAD_CONFIG_THREAD_DIRECT_WAKE_LISTENER_ENABLE
+#include <openthread/thread_direct.h>
+#endif
 #include <openthread/platform/misc.h>
 #include <openthread/platform/radio.h>
 
@@ -360,6 +363,9 @@ NcpBase::NcpBase(Instance *aInstance)
 #if OPENTHREAD_CONFIG_TIME_SYNC_ENABLE
     otNetworkTimeSyncSetCallback(mInstance, &NcpBase::HandleTimeSyncUpdate, this);
 #endif // OPENTHREAD_CONFIG_TIME_SYNC_ENABLE
+#if OPENTHREAD_CONFIG_THREAD_DIRECT_WAKE_INITIATOR_ENABLE || OPENTHREAD_CONFIG_THREAD_DIRECT_WAKE_LISTENER_ENABLE
+    otThreadDirectSetEventCallback(mInstance, &NcpBase::HandleThreadDirectEvent, this);
+#endif
 #if OPENTHREAD_CONFIG_UDP_FORWARD_ENABLE
     otUdpForwardSetForwarder(mInstance, &NcpBase::HandleUdpForwardStream, this);
 #endif

src/ncp/ncp_base.hpp

@@ -53,6 +53,9 @@
 #if OPENTHREAD_CONFIG_SRP_CLIENT_ENABLE
 #include <openthread/srp_client.h>
 #endif
+#if OPENTHREAD_CONFIG_THREAD_DIRECT_WAKE_INITIATOR_ENABLE || OPENTHREAD_CONFIG_THREAD_DIRECT_WAKE_LISTENER_ENABLE
+#include <openthread/thread_direct.h>
+#endif
 #include <openthread/platform/dnssd.h>
 
 #include "changed_props_set.hpp"
@@ -474,6 +477,13 @@ class NcpBase
     static void HandleTimeSyncUpdate(void *aContext);
     void        HandleTimeSyncUpdate(void);
 
+#if OPENTHREAD_CONFIG_THREAD_DIRECT_WAKE_INITIATOR_ENABLE || OPENTHREAD_CONFIG_THREAD_DIRECT_WAKE_LISTENER_ENABLE
+    static void HandleThreadDirectEvent(otThreadDirectEvent           aEvent,
+                                        const otThreadDirectPeerInfo *aPeerInfo,
+                                        void                         *aContext);
+    void        HandleThreadDirectEvent(otThreadDirectEvent aEvent, const otThreadDirectPeerInfo *aPeerInfo);
+#endif
+
 #if OPENTHREAD_FTD
     static void HandleNeighborTableChanged(otNeighborTableEvent aEvent, const otNeighborTableEntryInfo *aEntry);
     void        HandleNeighborTableChanged(otNeighborTableEvent aEvent, const otNeighborTableEntryInfo &aEntry);

src/ncp/ncp_base_dispatcher.cpp

@@ -349,7 +349,17 @@ NcpBase::PropertyHandler NcpBase::FindGetPropertyHandler(spinel_prop_key_t aKey)
         OT_NCP_GET_HANDLER_ENTRY(SPINEL_PROP_THREAD_PENDING_DATASET_TLVS),
         OT_NCP_GET_HANDLER_ENTRY(SPINEL_PROP_THREAD_MGMT_SET_PENDING_DATASET_TLVS),
 #if OPENTHREAD_CONFIG_THREAD_DIRECT_WAKE_INITIATOR_ENABLE || OPENTHREAD_CONFIG_THREAD_DIRECT_WAKE_LISTENER_ENABLE
-        OT_NCP_GET_HANDLER_ENTRY(SPINEL_PROP_THREAD_DIRECT_WAKE_CHANNEL),
+        OT_NCP_GET_HANDLER_ENTRY(SPINEL_PROP_THREAD_DIRECT_WAKE_CHANNEL), // 63
+#endif
+#if OPENTHREAD_CONFIG_THREAD_DIRECT_WAKE_LISTENER_ENABLE
+        OT_NCP_GET_HANDLER_ENTRY(SPINEL_PROP_THREAD_DIRECT_WAKE_LISTEN_ENABLED), // 64
+        OT_NCP_GET_HANDLER_ENTRY(SPINEL_PROP_THREAD_DIRECT_WAKE_LISTEN_PARAMS),  // 65
+#endif
+#if OPENTHREAD_CONFIG_THREAD_DIRECT_WAKE_INITIATOR_ENABLE
+        OT_NCP_GET_HANDLER_ENTRY(SPINEL_PROP_THREAD_DIRECT_WAKE_BURST_ACTIVE), // 73
+#endif
+#if OPENTHREAD_CONFIG_THREAD_DIRECT_WAKE_INITIATOR_ENABLE
+        OT_NCP_GET_HANDLER_ENTRY(SPINEL_PROP_THREAD_DIRECT_WAKE_FRAME_COUNTER), // 75
 #endif
 #if OPENTHREAD_CONFIG_CHANNEL_MANAGER_ENABLE
         OT_NCP_GET_HANDLER_ENTRY(SPINEL_PROP_CHANNEL_MANAGER_NEW_CHANNEL),
@@ -659,7 +669,17 @@ NcpBase::PropertyHandler NcpBase::FindSetPropertyHandler(spinel_prop_key_t aKey)
         OT_NCP_SET_HANDLER_ENTRY(SPINEL_PROP_THREAD_PENDING_DATASET_TLVS),
         OT_NCP_SET_HANDLER_ENTRY(SPINEL_PROP_THREAD_MGMT_SET_PENDING_DATASET_TLVS),
 #if OPENTHREAD_CONFIG_THREAD_DIRECT_WAKE_INITIATOR_ENABLE || OPENTHREAD_CONFIG_THREAD_DIRECT_WAKE_LISTENER_ENABLE
-        OT_NCP_SET_HANDLER_ENTRY(SPINEL_PROP_THREAD_DIRECT_WAKE_CHANNEL),
+        OT_NCP_SET_HANDLER_ENTRY(SPINEL_PROP_THREAD_DIRECT_WAKE_CHANNEL), // 63
+#endif
+#if OPENTHREAD_CONFIG_THREAD_DIRECT_WAKE_LISTENER_ENABLE
+        OT_NCP_SET_HANDLER_ENTRY(SPINEL_PROP_THREAD_DIRECT_WAKE_LISTEN_ENABLED), // 64
+        OT_NCP_SET_HANDLER_ENTRY(SPINEL_PROP_THREAD_DIRECT_WAKE_LISTEN_PARAMS),  // 65
+#endif
+#if OPENTHREAD_CONFIG_THREAD_DIRECT_WAKE_INITIATOR_ENABLE
+        OT_NCP_SET_HANDLER_ENTRY(SPINEL_PROP_THREAD_DIRECT_WAKE), // 68
+#endif
+#if OPENTHREAD_CONFIG_THREAD_DIRECT_WAKE_INITIATOR_ENABLE
+        OT_NCP_SET_HANDLER_ENTRY(SPINEL_PROP_THREAD_DIRECT_WAKE_FRAME_COUNTER), // 75
 #endif
 #if OPENTHREAD_CONFIG_COMMISSIONER_ENABLE
         OT_NCP_SET_HANDLER_ENTRY(SPINEL_PROP_MESHCOP_COMMISSIONER_ANNOUNCE_BEGIN),
@@ -757,6 +777,9 @@ NcpBase::PropertyHandler NcpBase::FindInsertPropertyHandler(spinel_prop_key_t aK
 #if OPENTHREAD_FTD && OPENTHREAD_CONFIG_COMMISSIONER_ENABLE
         OT_NCP_INSERT_HANDLER_ENTRY(SPINEL_PROP_THREAD_JOINERS),
 #endif
+#if OPENTHREAD_CONFIG_THREAD_DIRECT_WAKE_INITIATOR_ENABLE || OPENTHREAD_CONFIG_THREAD_DIRECT_WAKE_LISTENER_ENABLE
+        OT_NCP_INSERT_HANDLER_ENTRY(SPINEL_PROP_THREAD_DIRECT_GUEST_WAKE_KEY), // 71
+#endif
 #if OPENTHREAD_FTD || OPENTHREAD_MTD
 #if OPENTHREAD_CONFIG_SRP_CLIENT_ENABLE
         OT_NCP_INSERT_HANDLER_ENTRY(SPINEL_PROP_SRP_CLIENT_SERVICES),
@@ -807,6 +830,9 @@ NcpBase::PropertyHandler NcpBase::FindRemovePropertyHandler(spinel_prop_key_t aK
 #if OPENTHREAD_FTD
         OT_NCP_REMOVE_HANDLER_ENTRY(SPINEL_PROP_THREAD_ACTIVE_ROUTER_IDS),
 #endif
+#if OPENTHREAD_CONFIG_THREAD_DIRECT_WAKE_INITIATOR_ENABLE || OPENTHREAD_CONFIG_THREAD_DIRECT_WAKE_LISTENER_ENABLE
+        OT_NCP_REMOVE_HANDLER_ENTRY(SPINEL_PROP_THREAD_DIRECT_GUEST_WAKE_KEY), // 71
+#endif
 #if OPENTHREAD_FTD || OPENTHREAD_MTD
 #if OPENTHREAD_CONFIG_SRP_CLIENT_ENABLE
         OT_NCP_REMOVE_HANDLER_ENTRY(SPINEL_PROP_SRP_CLIENT_SERVICES),

src/ncp/ncp_base_mtd.cpp

@@ -56,6 +56,9 @@
 #if OPENTHREAD_FTD
 #include <openthread/thread_ftd.h>
 #endif
+#if OPENTHREAD_CONFIG_THREAD_DIRECT_WAKE_INITIATOR_ENABLE || OPENTHREAD_CONFIG_THREAD_DIRECT_WAKE_LISTENER_ENABLE
+#include <openthread/thread_direct.h>
+#endif
 #if OPENTHREAD_CONFIG_TMF_NETDATA_SERVICE_ENABLE
 #include <openthread/server.h>
 #endif
@@ -4831,12 +4834,11 @@ void NcpBase::ProcessThreadChangedFlags(void)
 #if OPENTHREAD_CONFIG_THREAD_DIRECT_WAKE_INITIATOR_ENABLE || OPENTHREAD_CONFIG_THREAD_DIRECT_WAKE_LISTENER_ENABLE
 template <> otError NcpBase::HandlePropertySet<SPINEL_PROP_THREAD_DIRECT_WAKE_CHANNEL>(void)
 {
-    uint8_t wakeupChannel;
+    uint8_t wakeChannel;
     otError error = OT_ERROR_NONE;
 
-    SuccessOrExit(error = mDecoder.ReadUint8(wakeupChannel));
-
-    error = otLinkSetWakeupChannel(mInstance, wakeupChannel);
+    SuccessOrExit(error = mDecoder.ReadUint8(wakeChannel));
+    error = otLinkSetWakeupChannel(mInstance, wakeChannel);
 
 exit:
     return error;
@@ -4846,7 +4848,163 @@ template <> otError NcpBase::HandlePropertyGet<SPINEL_PROP_THREAD_DIRECT_WAKE_CH
 {
     return mEncoder.WriteUint8(otLinkGetWakeupChannel(mInstance));
 }
-#endif
+
+#if OPENTHREAD_CONFIG_THREAD_DIRECT_WAKE_LISTENER_ENABLE
+template <> otError NcpBase::HandlePropertyGet<SPINEL_PROP_THREAD_DIRECT_WAKE_LISTEN_ENABLED>(void)
+{
+    return mEncoder.WriteBool(otThreadDirectIsWakeListenerEnabled(mInstance));
+}
+
+template <> otError NcpBase::HandlePropertySet<SPINEL_PROP_THREAD_DIRECT_WAKE_LISTEN_ENABLED>(void)
+{
+    bool    enable;
+    otError error = OT_ERROR_NONE;
+
+    SuccessOrExit(error = mDecoder.ReadBool(enable));
+    error = otThreadDirectWakeListenerEnable(mInstance, enable);
+
+exit:
+    return error;
+}
+
+template <> otError NcpBase::HandlePropertyGet<SPINEL_PROP_THREAD_DIRECT_WAKE_LISTEN_PARAMS>(void)
+{
+    uint32_t interval;
+    uint32_t duration;
+
+    otLinkGetWakeupListenParameters(mInstance, &interval, &duration);
+    SuccessOrExit(mEncoder.WriteUint32(interval));
+    SuccessOrExit(mEncoder.WriteUint32(duration));
+
+exit:
+    return OT_ERROR_NONE;
+}
+
+template <> otError NcpBase::HandlePropertySet<SPINEL_PROP_THREAD_DIRECT_WAKE_LISTEN_PARAMS>(void)
+{
+    uint32_t interval;
+    uint32_t duration;
+    otError  error = OT_ERROR_NONE;
+
+    SuccessOrExit(error = mDecoder.ReadUint32(interval));
+    SuccessOrExit(error = mDecoder.ReadUint32(duration));
+    error = otLinkSetWakeupListenParameters(mInstance, interval, duration);
+
+exit:
+    return error;
+}
+#endif // OPENTHREAD_CONFIG_THREAD_DIRECT_WAKE_LISTENER_ENABLE
+
+#if OPENTHREAD_CONFIG_THREAD_DIRECT_WAKE_INITIATOR_ENABLE
+template <> otError NcpBase::HandlePropertySet<SPINEL_PROP_THREAD_DIRECT_WAKE>(void)
+{
+    otExtAddress   extAddress;
+    uint8_t        wakeType;
+    uint16_t       intervalUs;
+    uint16_t       durationMs;
+    uint8_t        keyIndex;
+    const uint8_t *keyData;
+    uint16_t       keyLength;
+    otError        error = OT_ERROR_NONE;
+
+    SuccessOrExit(error = mDecoder.ReadEui64(extAddress));
+    SuccessOrExit(error = mDecoder.ReadUint8(wakeType));
+    SuccessOrExit(error = mDecoder.ReadUint16(intervalUs));
+    SuccessOrExit(error = mDecoder.ReadUint16(durationMs));
+    SuccessOrExit(error = mDecoder.ReadUint8(keyIndex));
+    // Consume the inline-key data field for wire compatibility; guest keys must be
+    // provisioned via SPINEL_PROP_THREAD_DIRECT_GUEST_WAKE_KEY before calling this property.
+    SuccessOrExit(error = mDecoder.ReadDataWithLen(keyData, keyLength));
+    OT_UNUSED_VARIABLE(keyData);
+    OT_UNUSED_VARIABLE(keyLength);
+
+    error = otThreadDirectWakeup(mInstance, &extAddress, static_cast<otThreadDirectWakeType>(wakeType), intervalUs,
+                                 durationMs, keyIndex);
+
+exit:
+    return error;
+}
+#endif // OPENTHREAD_CONFIG_THREAD_DIRECT_WAKE_INITIATOR_ENABLE
+
+template <> otError NcpBase::HandlePropertyInsert<SPINEL_PROP_THREAD_DIRECT_GUEST_WAKE_KEY>(void)
+{
+    uint8_t               keyIndex;
+    const uint8_t        *keyData;
+    uint16_t              keyLength;
+    otThreadDirectWakeKey key;
+    otError               error = OT_ERROR_NONE;
+
+    SuccessOrExit(error = mDecoder.ReadUint8(keyIndex));
+    SuccessOrExit(error = mDecoder.ReadDataWithLen(keyData, keyLength));
+    VerifyOrExit(keyLength == sizeof(key.m8), error = OT_ERROR_PARSE);
+    memcpy(key.m8, keyData, sizeof(key.m8));
+    error = otThreadDirectSetGuestWakeKey(mInstance, keyIndex, &key);
+
+exit:
+    return error;
+}
+
+template <> otError NcpBase::HandlePropertyRemove<SPINEL_PROP_THREAD_DIRECT_GUEST_WAKE_KEY>(void)
+{
+    uint8_t keyIndex;
+    otError error = OT_ERROR_NONE;
+
+    SuccessOrExit(error = mDecoder.ReadUint8(keyIndex));
+    error = otThreadDirectRemoveGuestWakeKey(mInstance, keyIndex);
+
+exit:
+    return error;
+}
+
+#if OPENTHREAD_CONFIG_THREAD_DIRECT_WAKE_INITIATOR_ENABLE
+template <> otError NcpBase::HandlePropertyGet<SPINEL_PROP_THREAD_DIRECT_WAKE_BURST_ACTIVE>(void)
+{
+    return mEncoder.WriteBool(otThreadDirectIsWakeBurstActive(mInstance));
+}
+
+template <> otError NcpBase::HandlePropertyGet<SPINEL_PROP_THREAD_DIRECT_WAKE_FRAME_COUNTER>(void)
+{
+    return mEncoder.WriteUint32(mInstance->Get<Mac::SubMac>().GetWakeFrameCounter());
+}
+
+template <> otError NcpBase::HandlePropertySet<SPINEL_PROP_THREAD_DIRECT_WAKE_FRAME_COUNTER>(void)
+{
+    uint32_t counter;
+    otError  error = OT_ERROR_NONE;
+
+    SuccessOrExit(error = mDecoder.ReadUint32(counter));
+    mInstance->Get<Mac::SubMac>().SetWakeFrameCounter(counter, /* aSetIfLarger */ false);
+
+exit:
+    return error;
+}
+#endif // OPENTHREAD_CONFIG_THREAD_DIRECT_WAKE_INITIATOR_ENABLE
+
+void NcpBase::HandleThreadDirectEvent(otThreadDirectEvent           aEvent,
+                                      const otThreadDirectPeerInfo *aPeerInfo,
+                                      void                         *aContext)
+{
+    static_cast<NcpBase *>(aContext)->HandleThreadDirectEvent(aEvent, aPeerInfo);
+}
+
+void NcpBase::HandleThreadDirectEvent(otThreadDirectEvent aEvent, const otThreadDirectPeerInfo *aPeerInfo)
+{
+    otExtAddress noAddr;
+    otError      error = OT_ERROR_NONE;
+
+    memset(&noAddr, 0, sizeof(noAddr));
+
+    SuccessOrExit(error = mEncoder.BeginFrame(SPINEL_HEADER_FLAG | SPINEL_HEADER_IID_0, SPINEL_CMD_PROP_VALUE_IS,
+                                              SPINEL_PROP_THREAD_DIRECT_LINK_EVENT));
+    SuccessOrExit(error = mEncoder.WriteUint8(static_cast<uint8_t>(aEvent)));
+    SuccessOrExit(error = mEncoder.WriteEui64(aPeerInfo != nullptr ? aPeerInfo->mExtAddress : noAddr));
+    SuccessOrExit(error = mEncoder.WriteBool(aEvent != OT_THREAD_DIRECT_EVENT_LINK_FAILED));
+    SuccessOrExit(error = mEncoder.EndFrame());
+
+exit:
+    return;
+}
+#endif // OPENTHREAD_CONFIG_THREAD_DIRECT_WAKE_INITIATOR_ENABLE || ...WAKE_LISTENER_ENABLE
 
 } // namespace Ncp
 } // namespace ot