From 75bd5af1e3e64e776f5c1239908213f7144d015e Mon Sep 17 00:00:00 2001 From: weicheng Date: Wed, 24 May 2023 12:56:45 +0800 Subject: [PATCH] fix asr platform issue (#26645) * fix asr platform issue: 1,modify PlatformManagerImpl implementation 2,bump third_party/asr/xxx/asr_sdk 3,remove unless code in SystemTimeSupport * keep queue and mutex when shut down * remove unused implemention in diagnosticdata --- src/platform/ASR/ASRConfig.cpp | 4 +- .../ASR/DiagnosticDataProviderImpl.cpp | 58 +--- src/platform/ASR/DiagnosticDataProviderImpl.h | 25 -- src/platform/ASR/PlatformManagerImpl.cpp | 260 +++++++----------- src/platform/ASR/PlatformManagerImpl.h | 23 +- src/platform/ASR/SystemTimeSupport.cpp | 20 +- third_party/asr/asr582x/asr_sdk | 2 +- third_party/asr/asr595x/asr_sdk | 2 +- 8 files changed, 118 insertions(+), 276 deletions(-) diff --git a/src/platform/ASR/ASRConfig.cpp b/src/platform/ASR/ASRConfig.cpp index af8eea30782480..86eb4ec9582ebf 100644 --- a/src/platform/ASR/ASRConfig.cpp +++ b/src/platform/ASR/ASRConfig.cpp @@ -226,7 +226,7 @@ CHIP_ERROR ASRConfig::ReadFactoryConfigValue(asr_matter_partition_t matter_parti ret = asr_factory_config_read(matter_partition, buf, (uint32_t) bufSize, (uint32_t *) &outLen); if (ret != 0) - ChipLogProgress(DeviceLayer, "asr_factory_config_read: %d failed, ret = %d\n", matter_partition, ret); + ChipLogProgress(DeviceLayer, "asr_factory_config_read: %d failed, ret = %d\n", matter_partition, static_cast(ret)); if (ret == 0) { @@ -251,7 +251,7 @@ CHIP_ERROR ASRConfig::ReadFactoryConfigValue(asr_matter_partition_t matter_parti ret = -1; if (ret != 0) - ChipLogProgress(DeviceLayer, "asr_factory_config_read: %d failed, ret = %d\n", matter_partition, ret); + ChipLogProgress(DeviceLayer, "asr_factory_config_read: %d failed, ret = %d\n", matter_partition, static_cast(ret)); if (ret == 0) { diff --git a/src/platform/ASR/DiagnosticDataProviderImpl.cpp b/src/platform/ASR/DiagnosticDataProviderImpl.cpp index cc311958cf3636..735c6476b803ed 100644 --- a/src/platform/ASR/DiagnosticDataProviderImpl.cpp +++ b/src/platform/ASR/DiagnosticDataProviderImpl.cpp @@ -257,10 +257,7 @@ CHIP_ERROR DiagnosticDataProviderImpl::GetWiFiSecurityType(app::Clusters::WiFiNe CHIP_ERROR DiagnosticDataProviderImpl::GetWiFiVersion(app::Clusters::WiFiNetworkDiagnostics::WiFiVersionEnum & wifiVersion) { - // Support 802.11a/n Wi-Fi in Beken chipset - // TODO: https://github.com/project-chip/connectedhomeip/issues/25543 - wifiVersion = app::Clusters::WiFiNetworkDiagnostics::WiFiVersionEnum::kN; - return CHIP_NO_ERROR; + return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE; } CHIP_ERROR DiagnosticDataProviderImpl::GetWiFiChannelNumber(uint16_t & channelNumber) @@ -289,59 +286,6 @@ CHIP_ERROR DiagnosticDataProviderImpl::GetWiFiRssi(int8_t & rssi) return CHIP_NO_ERROR; } -CHIP_ERROR DiagnosticDataProviderImpl::GetWiFiBeaconRxCount(uint32_t & beaconRxCount) -{ - beaconRxCount = 0; - return CHIP_NO_ERROR; -} - -CHIP_ERROR DiagnosticDataProviderImpl::GetWiFiBeaconLostCount(uint32_t & beaconLostCount) -{ - beaconLostCount = 0; - return CHIP_NO_ERROR; -} - -CHIP_ERROR DiagnosticDataProviderImpl::GetWiFiCurrentMaxRate(uint64_t & currentMaxRate) -{ - currentMaxRate = 0; - return CHIP_NO_ERROR; -} - -CHIP_ERROR DiagnosticDataProviderImpl::GetWiFiPacketMulticastRxCount(uint32_t & packetMulticastRxCount) -{ - packetMulticastRxCount = 0; - return CHIP_NO_ERROR; -} - -CHIP_ERROR DiagnosticDataProviderImpl::GetWiFiPacketMulticastTxCount(uint32_t & packetMulticastTxCount) -{ - packetMulticastTxCount = 0; - return CHIP_NO_ERROR; -} - -CHIP_ERROR DiagnosticDataProviderImpl::GetWiFiPacketUnicastRxCount(uint32_t & packetUnicastRxCount) -{ - packetUnicastRxCount = 0; - return CHIP_NO_ERROR; -} - -CHIP_ERROR DiagnosticDataProviderImpl::GetWiFiPacketUnicastTxCount(uint32_t & packetUnicastTxCount) -{ - packetUnicastTxCount = 0; - return CHIP_NO_ERROR; -} - -CHIP_ERROR DiagnosticDataProviderImpl::GetWiFiOverrunCount(uint64_t & overrunCount) -{ - overrunCount = 0; - return CHIP_NO_ERROR; -} - -CHIP_ERROR DiagnosticDataProviderImpl::ResetWiFiNetworkDiagnosticsCounts() -{ - return CHIP_NO_ERROR; -} - DiagnosticDataProvider & GetDiagnosticDataProviderImpl() { return DiagnosticDataProviderImpl::GetDefaultInstance(); diff --git a/src/platform/ASR/DiagnosticDataProviderImpl.h b/src/platform/ASR/DiagnosticDataProviderImpl.h index b60aa27b57ec93..8314c587d5eea3 100644 --- a/src/platform/ASR/DiagnosticDataProviderImpl.h +++ b/src/platform/ASR/DiagnosticDataProviderImpl.h @@ -50,31 +50,6 @@ class DiagnosticDataProviderImpl : public DiagnosticDataProvider CHIP_ERROR GetWiFiVersion(app::Clusters::WiFiNetworkDiagnostics::WiFiVersionEnum & wifiVersion) override; CHIP_ERROR GetWiFiChannelNumber(uint16_t & channelNumber) override; CHIP_ERROR GetWiFiRssi(int8_t & rssi) override; - CHIP_ERROR GetWiFiBeaconRxCount(uint32_t & beaconRxCount) override; - CHIP_ERROR GetWiFiBeaconLostCount(uint32_t & beaconLostCount) override; - CHIP_ERROR GetWiFiPacketMulticastRxCount(uint32_t & packetMulticastRxCount) override; - CHIP_ERROR GetWiFiPacketMulticastTxCount(uint32_t & packetMulticastTxCount) override; - CHIP_ERROR GetWiFiPacketUnicastRxCount(uint32_t & packetUnicastRxCount) override; - CHIP_ERROR GetWiFiPacketUnicastTxCount(uint32_t & packetUnicastTxCount) override; - CHIP_ERROR GetWiFiCurrentMaxRate(uint64_t & currentMaxRate) override; - CHIP_ERROR GetWiFiOverrunCount(uint64_t & overrunCount) override; - CHIP_ERROR ResetWiFiNetworkDiagnosticsCounts() override; - /* These variables will be set to 0 during start up and will be updated when reset-counts - * zcl command is received. - * These are considered as base for below attributes of WiFi Diagnostics Cluster: - * BeaconLostCount, BeaconRxCount, PacketMulticastRxCount, PacketMulticastTxCount, - * PacketUnicastRxCount, PacketUnicastTxCount, OverrunCount. - * Each attributes read will be difference of WLAN counters minus equivalent variables below. - */ - uint32_t mBeaconRxCount = 0; - uint32_t mBeaconLostCount = 0; - uint32_t mPacketMulticastRxCount = 0; - uint32_t mPacketMulticastTxCount = 0; - uint32_t mPacketUnicastRxCount = 0; - uint32_t mPacketUnicastTxCount = 0; - uint64_t mOverrunCount = 0; - bool mipv4_offpremise = false; - bool mipv6_offpremise = false; }; /** diff --git a/src/platform/ASR/PlatformManagerImpl.cpp b/src/platform/ASR/PlatformManagerImpl.cpp index 31172ae5f94a17..e3ac8a874beb77 100644 --- a/src/platform/ASR/PlatformManagerImpl.cpp +++ b/src/platform/ASR/PlatformManagerImpl.cpp @@ -51,24 +51,25 @@ CHIP_ERROR PlatformManagerImpl::_InitChipStack(void) err = Internal::InitLwIPCoreLock(); SuccessOrExit(err); - /* Initialize the event flags. */ - result = lega_rtos_init_event_flags(&mEventFlags); - VerifyOrExit(result == kNoErr, err = CHIP_ERROR_NO_MEMORY); - - /* Initialize the event queue. */ - result = lega_rtos_init_queue(&mEventQueue, "EventQueue", sizeof(ChipDeviceEvent), CHIP_DEVICE_CONFIG_MAX_EVENT_QUEUE_SIZE); - VerifyOrExit(result == kNoErr, err = CHIP_ERROR_NO_MEMORY); + if (mEventQueue == NULL) + { + /* Initialize the event queue. */ + result = lega_rtos_init_queue(&mEventQueue, "EventQueue", sizeof(ChipDeviceEvent), CHIP_DEVICE_CONFIG_MAX_EVENT_QUEUE_SIZE); + VerifyOrExit(result == kNoErr, err = CHIP_ERROR_NO_MEMORY); + } - /* Initialize the timer. */ - result = lega_rtos_init_timer(&mTimer, 1000, (timer_handler_t) TimerCallback, (void *) this); - VerifyOrExit(result == kNoErr, err = CHIP_ERROR_INTERNAL); + /* Initialize the timeout. */ + lega_rtos_set_timeout(&mNextTimerBaseTime); - /* Initialize the mutex. */ - result = lega_rtos_init_mutex(&mChipMutex); - VerifyOrExit(result == kNoErr, err = CHIP_ERROR_INTERNAL); + if (mChipMutex == NULL) + { + /* Initialize the mutex. */ + result = lega_rtos_init_mutex(&mChipMutex); + VerifyOrExit(result == kNoErr, err = CHIP_ERROR_INTERNAL); + } - result = lega_rtos_init_mutex(&mEventMutex); - VerifyOrExit(result == kNoErr, err = CHIP_ERROR_INTERNAL); + mChipTimerActive = false; + mShouldRunEventLoop.store(false); ReturnErrorOnFailure(GenericPlatformManagerImpl::_InitChipStack()); #else @@ -93,45 +94,81 @@ CHIP_ERROR PlatformManagerImpl::_InitChipStack(void) void PlatformManagerImpl::_RunEventLoop() { - kTaskRunningEventFlag = 1; - RunEventLoopInternal(); } void PlatformManagerImpl::RunEventLoopInternal(void) { - while (true) - { - uint32_t flags_set = 0; + CHIP_ERROR err; + ChipDeviceEvent event; - OSStatus result = lega_rtos_wait_for_event_flags(&mEventFlags, kPostEventFlag | kTimerEventFlag | kTaskStopEventFlag, - &flags_set, TRUE, WAIT_FOR_ANY_EVENT, LEGA_WAIT_FOREVER); + // Lock the CHIP stack. + StackLock lock; - if (result != kNoErr) - { - ChipLogError(DeviceLayer, "lega_rtos_wait_for_event_flags 0x%08x", result); - continue; - } + bool oldShouldRunEventLoop = false; + if (!mShouldRunEventLoop.compare_exchange_strong(oldShouldRunEventLoop /* expected */, true /* desired */)) + { + ChipLogError(DeviceLayer, "Error trying to run the event loop while it is already running"); + return; + } + + while (mShouldRunEventLoop.load()) + { + uint32_t waitTime; - if (flags_set & kTaskStopEventFlag) + // If one or more CHIP timers are active... + if (mChipTimerActive) { - kTaskRunningEventFlag = 0; - break; + // Adjust the base time and remaining duration for the next scheduled timer based on the + // amount of time that has elapsed since it was started. + // IF the timer's expiration time has already arrived... + if (lega_rtos_check_timeout(&mNextTimerBaseTime, &mNextTimerDurationTicks) == TRUE) + { + // Reset the 'timer active' flag. This will be set to true again by _StartChipTimer() + // if there are further timers beyond the expired one that are still active. + mChipTimerActive = false; + + // Call into the system layer to dispatch the callback functions for all timers + // that have expired. + err = static_cast(DeviceLayer::SystemLayer()).HandlePlatformTimer(); + if (err != CHIP_NO_ERROR) + { + ChipLogError(DeviceLayer, "Error handling CHIP timers: %" CHIP_ERROR_FORMAT, err.Format()); + } + + // When processing the event queue below, do not wait if the queue is empty. Instead + // immediately loop around and process timers again + waitTime = 0; + } + + // If there is still time before the next timer expires, arrange to wait on the event queue + // until that timer expires. + else + { + waitTime = mNextTimerDurationTicks; + } } - if (flags_set & kTimerEventFlag) + // Otherwise no CHIP timers are active, so wait indefinitely for an event to arrive on the event + // queue. + else { - HandleTimerEvent(); + waitTime = LEGA_WAIT_FOREVER; } - if (flags_set & kPostEventFlag) + OSStatus result; { - HandlePostEvent(); + // Unlock the CHIP stack, allowing other threads to enter CHIP while + // the event loop thread is sleeping. + StackUnlock unlock; + result = lega_rtos_pop_from_queue(&mEventQueue, &event, waitTime); } - if (kTaskRunningEventFlag == 0) + // If an event was received, dispatch it and continue until the queue is empty. + while (result == kNoErr) { - break; + DispatchEvent(&event); + result = lega_rtos_pop_from_queue(&mEventQueue, &event, LEGA_NO_WAIT); } } } @@ -140,45 +177,22 @@ CHIP_ERROR PlatformManagerImpl::_StartEventLoopTask(void) { lega_task_config_t cfg; - lega_rtos_lock_mutex(&mEventMutex, LEGA_WAIT_FOREVER); - - if (kTaskRunningEventFlag == 1) - { - lega_rtos_unlock_mutex(&mEventMutex); - return CHIP_ERROR_BUSY; - } - MatterInitializer::Matter_Task_Config(&cfg); - kTaskRunningEventFlag = 1; - OSStatus result = lega_rtos_create_thread(&mThread, cfg.task_priority, CHIP_DEVICE_CONFIG_CHIP_TASK_NAME, (lega_thread_function_t) EventLoopTaskMain, cfg.stack_size, (lega_thread_arg_t) this); if (result != kNoErr) { - lega_rtos_unlock_mutex(&mEventMutex); return CHIP_ERROR_INTERNAL; } - lega_rtos_unlock_mutex(&mEventMutex); - return CHIP_NO_ERROR; } CHIP_ERROR PlatformManagerImpl::_StopEventLoopTask() { - lega_rtos_lock_mutex(&mEventMutex, LEGA_WAIT_FOREVER); - - if (kTaskRunningEventFlag == 0) - { - lega_rtos_unlock_mutex(&mEventMutex); - return CHIP_ERROR_INCORRECT_STATE; - } - - PlatformMgrImpl().SetEventFlags(kTaskStopEventFlag); - - lega_rtos_unlock_mutex(&mEventMutex); + mShouldRunEventLoop.store(false); return CHIP_NO_ERROR; } @@ -189,6 +203,18 @@ void PlatformManagerImpl::_LockChipStack(void) VerifyOrReturn(result == kNoErr, ChipLogError(DeviceLayer, "%s %x", __func__, result)); } +bool PlatformManagerImpl::_TryLockChipStack(void) +{ + if (lega_rtos_lock_mutex(&mChipMutex, LEGA_NO_WAIT) == kNoErr) + { + return true; + } + else + { + return false; + } +} + void PlatformManagerImpl::_UnlockChipStack(void) { OSStatus result = lega_rtos_unlock_mutex(&mChipMutex); @@ -204,30 +230,32 @@ CHIP_ERROR PlatformManagerImpl::_PostEvent(const ChipDeviceEvent * event) return CHIP_ERROR_INTERNAL; } - PlatformMgrImpl().SetEventFlags(kPostEventFlag); - return CHIP_NO_ERROR; } CHIP_ERROR PlatformManagerImpl::_StartChipTimer(System::Clock::Timeout durationMS) { - if (durationMS.count() == 0) + mChipTimerActive = true; + lega_rtos_set_timeout(&mNextTimerBaseTime); + mNextTimerDurationTicks = (lega_tick_t) ms_to_tick(System::Clock::Milliseconds64(durationMS).count()); + // If the platform timer is being updated by a thread other than the event loop thread, + // trigger the event loop thread to recalculate its wait time by posting a no-op event + // to the event queue. + if (lega_rtos_get_current_thread() != mThread) { - TimerCallback(0); - } - else - { - lega_rtos_deinit_timer(&mTimer); - lega_rtos_init_timer(&mTimer, durationMS.count(), (timer_handler_t) TimerCallback, (void *) this); - OSStatus result = lega_rtos_start_timer(&mTimer); - if (kNoErr != result) - { - ChipLogError(DeviceLayer, "wiced_start_timer 0x%02x", result); - return CHIP_ERROR_INTERNAL; - } + ChipDeviceEvent noop{ .Type = DeviceEventType::kNoOp }; + ReturnErrorOnFailure(PostEvent(&noop)); } + return CHIP_NO_ERROR; } + +void PlatformManagerImpl::EventLoopTaskMain(uint32_t arg) +{ + ChipLogDetail(DeviceLayer, "CHIP task running"); + PlatformMgrImpl().RunEventLoopInternal(); + lega_rtos_delete_thread(NULL); +} #else CHIP_ERROR PlatformManagerImpl::InitLwIPCoreLock(void) { @@ -261,93 +289,11 @@ void PlatformManagerImpl::_Shutdown() // Call up to the base class _Shutdown() to perform the actual stack de-initialization // and clean-up // - - (void) _StopEventLoopTask(); - - // the task thread is self terminating, we might have to wait if it's still processing - while (true) - { - if (kTaskRunningEventFlag == 0) - { - break; - } - lega_rtos_delay_milliseconds(1); - } - - ChipLogError(DeviceLayer, "StopEventLoopTask done."); - - lega_rtos_deinit_event_flags(&mEventFlags); - lega_rtos_deinit_queue(&mEventQueue); - lega_rtos_deinit_timer(&mTimer); - lega_rtos_deinit_mutex(&mChipMutex); - lega_rtos_deinit_mutex(&mEventMutex); - Internal::GenericPlatformManagerImpl::_Shutdown(); #else Internal::GenericPlatformManagerImpl_FreeRTOS::_Shutdown(); #endif } -#if CONFIG_ENABLE_ASR_LEGA_RTOS -void PlatformManagerImpl::SetEventFlags(uint32_t flags) -{ - if (lega_rtos_set_event_flags(&mEventFlags, flags) != kNoErr) - { - ChipLogError(DeviceLayer, "%s lega_rtos_set_event_flags %08lx", __func__, flags); - } -} - -void PlatformManagerImpl::HandleTimerEvent(void) -{ - const CHIP_ERROR err = static_cast(DeviceLayer::SystemLayer()).HandlePlatformTimer(); - if (err != CHIP_NO_ERROR) - { - ChipLogError(DeviceLayer, "HandlePlatformTimer %ld", err.AsInteger()); - } -} - -void PlatformManagerImpl::HandlePostEvent(void) -{ - OSStatus result; - ChipDeviceEvent event; - - /* Check the event queue. */ - if (lega_rtos_is_queue_empty(&mEventQueue)) - { - return; - } - - /* Pop one event from the event queue. */ - result = lega_rtos_pop_from_queue(&mEventQueue, &event, LEGA_WAIT_FOREVER); - - if (kNoErr != result) - { - ChipLogError(DeviceLayer, "lega_rtos_pop_from_queue %u", result); - return; - } - - /* Process this event. */ - DispatchEvent(&event); - - /* Set another application thread event if the event queue is not empty. */ - if (!lega_rtos_is_queue_empty(&mEventQueue)) - { - PlatformMgrImpl().SetEventFlags(kPostEventFlag); - } -} - -void PlatformManagerImpl::EventLoopTaskMain(uint32_t arg) -{ - ChipLogDetail(DeviceLayer, "CHIP task running"); - PlatformMgrImpl().RunEventLoopInternal(); - lega_rtos_delete_thread(NULL); -} - -void PlatformManagerImpl::TimerCallback(void * params) -{ - PlatformMgrImpl().SetEventFlags(kTimerEventFlag); -} -#endif - } // namespace DeviceLayer } // namespace chip diff --git a/src/platform/ASR/PlatformManagerImpl.h b/src/platform/ASR/PlatformManagerImpl.h index c3d5388a23c129..890fefd72f74de 100644 --- a/src/platform/ASR/PlatformManagerImpl.h +++ b/src/platform/ASR/PlatformManagerImpl.h @@ -28,6 +28,7 @@ #else #include #endif +#include namespace chip { namespace DeviceLayer { @@ -83,23 +84,15 @@ class PlatformManagerImpl final : public PlatformManager, public Internal::Gener void _UnlockChipStack(void); CHIP_ERROR _PostEvent(const ChipDeviceEvent * event); CHIP_ERROR _StartChipTimer(System::Clock::Timeout durationMS); - void SetEventFlags(uint32_t flags); - void HandleTimerEvent(void); - void HandlePostEvent(void); - - lega_thread_t mThread; - lega_event_flags_t mEventFlags; - lega_queue_t mEventQueue; - lega_timer_t mTimer; - lega_mutex_t mChipMutex; - lega_mutex_t mEventMutex; + std::atomic mShouldRunEventLoop; + bool mChipTimerActive; + lega_thread_t mThread = NULL; + lega_queue_t mEventQueue = NULL; + lega_mutex_t mChipMutex = NULL; + lega_timeout_t mNextTimerBaseTime; + lega_tick_t mNextTimerDurationTicks; static void EventLoopTaskMain(uint32_t arg); void RunEventLoopInternal(void); - static void TimerCallback(void * params); - uint32_t kTaskRunningEventFlag; - static constexpr uint32_t kTaskStopEventFlag = 1 << 0; - static constexpr uint32_t kPostEventFlag = 1 << 1; - static constexpr uint32_t kTimerEventFlag = 1 << 2; #endif }; diff --git a/src/platform/ASR/SystemTimeSupport.cpp b/src/platform/ASR/SystemTimeSupport.cpp index 8b729a86dd50a3..58ba00d883ff0b 100644 --- a/src/platform/ASR/SystemTimeSupport.cpp +++ b/src/platform/ASR/SystemTimeSupport.cpp @@ -47,38 +47,22 @@ Milliseconds64 ClockImpl::GetMonotonicMilliseconds64(void) CHIP_ERROR ClockImpl::GetClock_RealTime(Microseconds64 & aCurTime) { - // TODO(19081): This platform does not properly error out if wall clock has - // not been set. For now, short circuit this. return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE; } CHIP_ERROR ClockImpl::GetClock_RealTimeMS(Milliseconds64 & aCurTime) { - Microseconds64 curTimeUs; - auto err = GetClock_RealTime(curTimeUs); - aCurTime = std::chrono::duration_cast(curTimeUs); - return err; + return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE; } CHIP_ERROR ClockImpl::SetClock_RealTime(Microseconds64 aNewCurTime) { - struct timeval tv; - tv.tv_sec = static_cast(aNewCurTime.count() / UINT64_C(1000000)); - tv.tv_usec = static_cast(aNewCurTime.count() % UINT64_C(1000000)); - return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE; } CHIP_ERROR InitClock_RealTime() { - Clock::Microseconds64 curTime = - Clock::Microseconds64((static_cast(CHIP_SYSTEM_CONFIG_VALID_REAL_TIME_THRESHOLD) * UINT64_C(1000000))); - // Use CHIP_SYSTEM_CONFIG_VALID_REAL_TIME_THRESHOLD as the initial value of RealTime. - // Then the RealTime obtained from GetClock_RealTime will be always valid. - // - // TODO(19081): This is broken because it causes the platform to report - // that it does have wall clock time when it actually doesn't. - return System::SystemClock().SetClock_RealTime(curTime); + return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE; } } // namespace Clock diff --git a/third_party/asr/asr582x/asr_sdk b/third_party/asr/asr582x/asr_sdk index 5773d8c2fa918d..3c26f86d72abbb 160000 --- a/third_party/asr/asr582x/asr_sdk +++ b/third_party/asr/asr582x/asr_sdk @@ -1 +1 @@ -Subproject commit 5773d8c2fa918d153d321a81fb237b8155384b75 +Subproject commit 3c26f86d72abbb167b6d6bed3d712a4790f8d023 diff --git a/third_party/asr/asr595x/asr_sdk b/third_party/asr/asr595x/asr_sdk index 3db19fcb8cfcd5..7f5547c5439121 160000 --- a/third_party/asr/asr595x/asr_sdk +++ b/third_party/asr/asr595x/asr_sdk @@ -1 +1 @@ -Subproject commit 3db19fcb8cfcd596c48b44df229e60a1bed30e8a +Subproject commit 7f5547c5439121ec81623be99fa40b37ffaf9f4c