[release] v1.7.0

* Handle possible failure of mdns_resp_add_service

* One more place where mdns_resp_add_service may fail

* addServiceImpl should always store services

* Register in services when new netif is added

* Refactored handling of cached services.

---------

Co-authored-by: Kuba Szczodrzyński <kuba@szczodrzynski.pl>

.clang-format

@@ -1,3 +1,4 @@
+# 2024-07-30
 Language: Cpp
 BasedOnStyle: LLVM
 AlignAfterOpenBracket: BlockIndent
@@ -6,6 +7,7 @@ AlignConsecutiveAssignments: true
 AlignConsecutiveMacros: AcrossComments
 AlignTrailingComments: true
 AllowAllArgumentsOnNextLine: false
+AllowAllParametersOfDeclarationOnNextLine: false
 AllowShortBlocksOnASingleLine: Empty
 AllowShortFunctionsOnASingleLine: Empty
 AlwaysBreakTemplateDeclarations: Yes
@@ -21,6 +23,7 @@ IndentCaseLabels: true
 IndentWidth: 4
 LambdaBodyIndentation: Signature
 MaxEmptyLinesToKeep: 1
+PenaltyReturnTypeOnItsOwnLine: 1000
 # PointerAlignment: Left # TODO enable this and reformat project
 QualifierAlignment: Left
 ReflowComments: true

cores/beken-72xx/arduino/libraries/WiFi/WiFiGeneric.cpp

@@ -80,7 +80,30 @@ IPAddress WiFiClass::hostByName(const char *hostname) {
 	ip_addr_t ip;
 	int ret = netconn_gethostbyname(hostname, &ip);
 	if (ret == ERR_OK) {
-		return ip.addr;
+#ifdef CONFIG_IPV6
+		if (IP_IS_V6(&ip)) {
+			ip6_addr_t *ip6 = ip_2_ip6(&ip);
+			return IPAddress(
+				IP6_ADDR_BLOCK1(ip6) >> 8,
+				IP6_ADDR_BLOCK1(ip6) & 0xff,
+				IP6_ADDR_BLOCK2(ip6) >> 8,
+				IP6_ADDR_BLOCK2(ip6) & 0xff,
+				IP6_ADDR_BLOCK3(ip6) >> 8,
+				IP6_ADDR_BLOCK3(ip6) & 0xff,
+				IP6_ADDR_BLOCK4(ip6) >> 8,
+				IP6_ADDR_BLOCK4(ip6) & 0xff,
+				IP6_ADDR_BLOCK5(ip6) >> 8,
+				IP6_ADDR_BLOCK5(ip6) & 0xff,
+				IP6_ADDR_BLOCK6(ip6) >> 8,
+				IP6_ADDR_BLOCK6(ip6) & 0xff,
+				IP6_ADDR_BLOCK7(ip6) >> 8,
+				IP6_ADDR_BLOCK7(ip6) & 0xff,
+				IP6_ADDR_BLOCK8(ip6) >> 8,
+				IP6_ADDR_BLOCK8(ip6) & 0xff
+			);
+		}
+#endif
+		return IPAddress(ip_addr_get_ip4_u32(&ip));
 	}
 	return IPAddress();
 }

cores/beken-72xx/arduino/libraries/WiFi/WiFiSTA.cpp

@@ -2,8 +2,13 @@
 
 #include "WiFiPrivate.h"
 
-WiFiStatus
-WiFiClass::begin(const char *ssid, const char *passphrase, int32_t channel, const uint8_t *bssid, bool connect) {
+WiFiStatus WiFiClass::begin(
+	const char *ssid,
+	const char *passphrase,
+	int32_t channel,
+	const uint8_t *bssid,
+	bool connect
+) {
 	if (!enableSTA(true))
 		return WL_CONNECT_FAILED;
 	if (!validate(ssid, passphrase))
@@ -246,3 +251,41 @@ WiFiAuthMode WiFiClass::getEncryption() {
 	STA_GET_LINK_STATUS_RETURN(WIFI_AUTH_INVALID);
 	return securityTypeToAuthMode(LINK_STATUS.security);
 }
+#ifdef CONFIG_IPV6
+bool WiFiClass::enableIpV6() {
+	return true;
+}
+
+IPv6Address WiFiClass::localIPv6() {
+	struct netif *ifs = (struct netif *)net_get_sta_handle();
+	std::vector<IPv6Address> result;
+	struct wlan_ip_config addr;
+	int nr_addresses = 0;
+
+	if (sta_ip_is_start())
+		nr_addresses = net_get_if_ipv6_pref_addr(&addr, ifs);
+
+	for (int i = 0; i < nr_addresses; i++) {
+		if (ip6_addr_islinklocal(&addr.ipv6[i]))
+			return IPv6Address(addr.ipv6[i].addr);
+	}
+
+	return IPv6Address();
+}
+
+std::vector<IPv6Address> WiFiClass::allLocalIPv6() {
+	struct netif *ifs = (struct netif *)net_get_sta_handle();
+	std::vector<IPv6Address> result;
+	struct wlan_ip_config addr;
+	int nr_addresses = 0;
+
+	if (sta_ip_is_start())
+		nr_addresses = net_get_if_ipv6_pref_addr(&addr, ifs);
+
+	for (int i = 0; i < nr_addresses; i++) {
+		result.push_back(IPv6Address(addr.ipv6[i].addr));
+	}
+
+	return result;
+}
+#endif

cores/beken-72xx/arduino/src/wiring_irq.c

@@ -9,19 +9,19 @@ static void irqHandler(unsigned char gpio) {
 	PinData *data = pinData(pin);
 	if (!data->irqHandler)
 		return;
-	if (data->irqChange) {
-		if (data->gpioMode == INPUT_PULLDOWN) {
-			data->gpioMode = INPUT_PULLUP;
-			gpio_int_enable(pin->gpio, GPIO_INT_LEVEL_FALLING, irqHandler);
-		} else if (data->gpioMode == INPUT_PULLUP) {
-			data->gpioMode = INPUT_PULLDOWN;
-			gpio_int_enable(pin->gpio, GPIO_INT_LEVEL_RISING, irqHandler);
-		}
-	}
 	if (!data->irqParam)
 		((voidFuncPtr)data->irqHandler)();
 	else
 		((voidFuncPtrParam)data->irqHandler)(data->irqParam);
+	if (data->irqChange) {
+		if (data->irqMode == RISING) {
+			data->irqMode = FALLING;
+			gpio_int_enable(pin->gpio, GPIO_INT_LEVEL_FALLING, irqHandler);
+		} else {
+			data->irqMode = RISING;
+			gpio_int_enable(pin->gpio, GPIO_INT_LEVEL_RISING, irqHandler);
+		}
+	}
 }
 
 void attachInterruptParam(pin_size_t interruptNumber, voidFuncPtrParam callback, PinStatus mode, void *param) {
@@ -52,7 +52,13 @@ void attachInterruptParam(pin_size_t interruptNumber, voidFuncPtrParam callback,
 			event = GPIO_INT_LEVEL_RISING;
 			break;
 		case CHANGE:
-			event  = GPIO_INT_LEVEL_FALLING;
+			if (gpio_input(pin->gpio)) {
+				event = GPIO_INT_LEVEL_FALLING;
+				mode  = FALLING;
+			} else {
+				event = GPIO_INT_LEVEL_RISING;
+				mode  = RISING;
+			}
 			change = true;
 			break;
 		default:

cores/beken-72xx/base/api/lt_sleep.c

@@ -19,6 +19,14 @@ void lt_deep_sleep_unset_gpio(uint32_t gpio_index_map) {
 	deep_sleep_param.gpio_index_map &= (~gpio_index_map);
 }
 
+void lt_deep_sleep_keep_floating_gpio(uint32_t gpio_index_map, bool enabled) {
+	if (enabled) {
+		deep_sleep_param.gpio_stay_lo_map |= gpio_index_map;
+	} else {
+		deep_sleep_param.gpio_stay_lo_map &= (~gpio_index_map);
+	}
+}
+
 void lt_deep_sleep_config_timer(uint32_t sleep_duration_ms) {
 	deep_sleep_param.wake_up_way |= PS_DEEP_WAKEUP_RTC;
 	uint64_t sleep_ticks = 32.768 * sleep_duration_ms;
@@ -33,7 +41,7 @@ void lt_deep_sleep_enter() {
 	bk_misc_update_set_type(RESET_SOURCE_DEEPPS_GPIO);
 	GLOBAL_INT_DECLARATION();
 	GLOBAL_INT_DISABLE();
-	sctrl_enter_rtos_deep_sleep((PS_DEEP_CTRL_PARAM *)&deep_sleep_param);
+	sctrl_enter_rtos_deep_sleep_fix((PS_DEEP_CTRL_PARAM *)&deep_sleep_param);
 	ps_delay(500);
 	GLOBAL_INT_RESTORE();
 }

cores/beken-72xx/base/config/lwipopts.h

@@ -10,8 +10,10 @@
 #define LWIP_NETIF_EXT_STATUS_CALLBACK 1
 #define MEMP_NUM_UDP_PCB			   (MAX_SOCKETS_UDP + 2 + 1)
 
+#ifndef CONFIG_IPV6
 #define ip_addr	  ip4_addr
 #define ip_addr_t ip4_addr_t
+#endif
 
 // increase TCP/IP thread stack size (was 512)
 #undef TCPIP_THREAD_STACKSIZE

cores/beken-72xx/base/fixups/sys_ctrl.c

@@ -0,0 +1,431 @@
+#include "include.h"
+#include "sys_ctrl.h"
+
+#include "flash_pub.h"
+#include "power_save_pub.h"
+#include "gpio_pub.h"
+#include "reg_rc.h"
+#include "manual_ps_pub.h"
+
+// usage:
+// extern void sctrl_enter_rtos_deep_sleep_fix(PS_DEEP_CTRL_PARAM *deep_param);
+
+static void sctrl_mac_ahb_slave_clock_disable(void)
+{
+    UINT32 reg;
+#if (CFG_SOC_NAME == SOC_BK7271)
+    reg = REG_READ(SCTRL_CONTROL);
+    reg &= ~MAC_HCLK_EN_BIT;
+    REG_WRITE(SCTRL_CONTROL, reg);
+#else
+    reg = REG_READ(SCTRL_MODEM_CORE_RESET_PHY_HCLK);
+    reg &= ~MAC_HCLK_EN_BIT;
+    REG_WRITE(SCTRL_MODEM_CORE_RESET_PHY_HCLK, reg);
+#endif
+}
+
+// This is a patched version, where `gpio_stay_*_map` arguments are actually
+// taken into account as intended. The offical doc says that they control
+// whether the original voltage should 'stay' (float) instead of configuring
+// pins to pullup/pulldown.
+//
+// https://docs.bekencorp.com/sdk_3.0.x/bk7238/build/en/latest/developer-guide/power_save/sleep_test.html
+void sctrl_enter_rtos_deep_sleep_fix(PS_DEEP_CTRL_PARAM *deep_param)
+{
+    DD_HANDLE flash_hdl;
+    UINT32 status;
+    UINT32 param;
+    UINT32 reg;
+    UINT32 i;
+
+    uart_wait_tx_over();
+
+    /* close all peri clock*/
+    REG_WRITE(ICU_PERI_CLK_PWD, 0xfffff);  //  icu: 0x2;
+
+#if CFG_USE_UART2
+    uart2_exit();
+#endif
+#if CFG_USE_UART1
+    uart1_exit();
+#endif
+
+#if (CFG_SOC_NAME == SOC_BK7231U) || (SOC_BK7231N == CFG_SOC_NAME)
+    reg = REG_READ(SCTRL_LOW_PWR_CLK);
+    reg &=~(LPO_CLK_MUX_MASK);
+    reg |=(LPO_SRC_ROSC << LPO_CLK_MUX_POSI);
+    REG_WRITE(SCTRL_LOW_PWR_CLK, reg);
+
+    REG_WRITE(SCTRL_ROSC_CAL, 0x75);
+    REG_WRITE(SCTRL_ROSC_CAL, 0x77);
+#else
+    /*ana_reg set*/
+    REG_WRITE(SCTRL_ANALOG_CTRL0, 0x7819a59b);
+    REG_WRITE(SCTRL_ANALOG_CTRL1, 0x7819a59b);
+    REG_WRITE(SCTRL_ANALOG_CTRL2, 0x84036080);
+    REG_WRITE(SCTRL_ANALOG_CTRL3, 0x180004a0);
+    REG_WRITE(SCTRL_ANALOG_CTRL4, 0x84200e52);
+    REG_WRITE(SCTRL_ANALOG_CTRL5, 0x3b13b13b);
+#if (CFG_SOC_NAME != SOC_BK7231)
+    REG_WRITE(SCTRL_ANALOG_CTRL6, 0xb09350);
+#endif
+#if (CFG_SOC_NAME == SOC_BK7221U)
+    REG_WRITE(SCTRL_ANALOG_CTRL7, 0x441a7f0);
+    REG_WRITE(SCTRL_ANALOG_CTRL8, 0x3b187c);
+    REG_WRITE(SCTRL_ANALOG_CTRL9, 0x82204007);
+    REG_WRITE(SCTRL_ANALOG_CTRL10, 0x80801432);
+#endif
+#endif
+    ps_delay(10);
+    /*clear int*/
+    REG_WRITE(ICU_INTERRUPT_ENABLE, 0);
+
+    extern void gpio_ops_disable_filter(void);
+    gpio_ops_disable_filter();
+
+    /*  disable gpio0~31*/
+    REG_WRITE(SCTRL_GPIO_WAKEUP_EN,0x0);  //sys_ctrl : 0x48;
+    REG_WRITE(SCTRL_GPIO_WAKEUP_INT_STATUS,0xFFFFFFFF);  //sys_ctrl : 0x4a;
+
+#if (CFG_SOC_NAME != SOC_BK7231N)
+    /*	disable gpio32~39*/
+    REG_WRITE(SCTRL_GPIO_WAKEUP_EN1,0x0);  //sys_ctrl : 0x51;
+    REG_WRITE(SCTRL_GPIO_WAKEUP_INT_STATUS1,0xFF);  //sys_ctrl : 0x53;
+#endif
+
+    REG_WRITE(SCTRL_BLOCK_EN_MUX, 0x0);   //sys_ctrl : 0x4F;
+
+    /* ROSC_TIMER_int_clear*/
+    reg = REG_READ(SCTRL_ROSC_TIMER);
+    reg = reg| ROSC_TIMER_INT_STATUS_BIT ;
+    REG_WRITE(SCTRL_ROSC_TIMER,reg);      //sys_ctrl : 0x47;
+
+    /*ROSC_TIMER close */
+    reg = REG_READ(SCTRL_ROSC_TIMER);
+    reg = reg & (~ROSC_TIMER_ENABLE_BIT);																   //'C'
+    REG_WRITE(SCTRL_ROSC_TIMER,reg);
+
+    reg = REG_READ(SCTRL_LOW_PWR_CLK);
+    reg &=~(LPO_CLK_MUX_MASK);
+    if(deep_param->lpo_32k_src == LPO_SELECT_32K_XTAL)
+    {
+        reg |=(LPO_SRC_32K_XTAL << LPO_CLK_MUX_POSI);
+    }
+    else
+    {
+        reg |=(LPO_SRC_ROSC << LPO_CLK_MUX_POSI);
+    }
+
+    REG_WRITE(SCTRL_LOW_PWR_CLK, reg);    //sys_ctrl : 0x40;
+
+    /* close all peri int*/
+    //    REG_WRITE(ICU_INTERRUPT_ENABLE, 0);
+
+    /* MAC pwd*/
+    REG_WRITE(SCTRL_PWR_MAC_MODEM, MAC_PWD << MAC_PWD_POSI);   //sys_ctrl : 0x43;
+
+    sctrl_mac_ahb_slave_clock_disable();
+
+    /* Mac Subsystem clock 480m disable*/
+    reg = REG_READ(SCTRL_CONTROL);
+    REG_WRITE(SCTRL_CONTROL, reg | MAC_CLK480M_PWD_BIT);
+
+    /* Modem pwd*/
+    REG_WRITE(SCTRL_PWR_MAC_MODEM, MODEM_PWD << MODEM_PWD_POSI);
+
+    /* Modem AHB clock disable*/
+    reg = REG_READ(SCTRL_MODEM_CORE_RESET_PHY_HCLK);
+    reg &= ~PHY_HCLK_EN_BIT;
+    REG_WRITE(SCTRL_MODEM_CORE_RESET_PHY_HCLK, reg);
+
+    /* Modem Subsystem clock 480m disable*/
+    reg = REG_READ(SCTRL_CONTROL);
+    REG_WRITE(SCTRL_CONTROL, reg | MODEM_CLK480M_PWD_BIT);
+
+    /* Flash 26MHz clock select dco clock*/
+    flash_hdl = ddev_open(FLASH_DEV_NAME, &status, 0);
+    ASSERT(DD_HANDLE_UNVALID != flash_hdl);
+    ddev_control(flash_hdl, CMD_FLASH_SET_DCO, 0);
+
+    /* MCLK(main clock) select:dco*/ /* MCLK division*/
+    reg = REG_READ(SCTRL_CONTROL);
+    reg &= ~(MCLK_MUX_MASK << MCLK_MUX_POSI);
+    reg &= ~(MCLK_DIV_MASK << MCLK_DIV_POSI);
+    REG_WRITE(SCTRL_CONTROL, reg);                                     //0x02
+
+    if(deep_param->lpo_32k_src == LPO_SELECT_32K_XTAL)
+    {
+        reg = REG_READ(SCTRL_CONTROL);
+        reg =((reg & (~0xF0)) | (0<<4));
+        reg =((reg & (~0x03)) | (0<<MCLK_MUX_POSI));
+        reg =((reg & (~0x100)) | FLASH_26M_MUX_BIT);
+        REG_WRITE(SCTRL_CONTROL,reg); //sys_ctrl : 0x02;
+    }
+
+    ps_delay(10);
+
+    reg = 0x0;
+    reg = (reg &(~(BLOCK_EN_WORD_MASK << 20))&(~(0x7FFFUL<<5)) &(~(0x01UL<<1)));
+    reg = (reg |(BLOCK_EN_WORD_PWD<< 20 )|BLK_EN_FLASH|BLK_EN_ROSC32K|BLK_EN_DIGITAL_CORE|BLK_EN_ANALOG_SYS_LDO);
+    if(deep_param->lpo_32k_src == LPO_SELECT_32K_XTAL)
+    {
+        reg = (reg |BLK_EN_32K_XTAL|BLK_EN_26M_XTAL);
+    }
+    REG_WRITE(SCTRL_BLOCK_EN_CFG, reg);                  //sys_ctrl : 0x4B;                   //'E'
+
+#if (CFG_SOC_NAME != SOC_BK7231U) && (SOC_BK7231N != CFG_SOC_NAME)
+    reg = REG_READ(SCTRL_ROSC_CAL);                           //ROSC Calibration disable
+    reg =(reg  & (~0x01));
+    REG_WRITE(SCTRL_ROSC_CAL, reg);
+#endif
+
+    for(i=0; i<GPIONUM; i++)
+    {
+#if (CFG_SOC_NAME == SOC_BK7231N)
+        if(((i > GPIO1) && (i < GPIO6))
+            || ((i > GPIO11) && (i < GPIO14))
+            || ((i > GPIO17) && (i < GPIO20))
+            || ((i > GPIO24) && (i < GPIO26))
+            || ((i > GPIO26) && (i < GPIO28)))
+        {
+            continue;
+        }
+#endif
+        if(((i < BITS_INT)&&(deep_param->gpio_stay_lo_map & (0x01UL << i)))
+        ||((deep_param->gpio_index_map & (0x01UL << i)))
+        ||((deep_param->gpio_last_index_map & (0x01UL << i)))
+        ||((i >= BITS_INT)&&(deep_param->gpio_stay_hi_map & (0x01UL << (i - BITS_INT)))) )
+        {
+            continue;
+        }
+        param = GPIO_CFG_PARAM(i, GMODE_DEEP_PS);	/*set gpio 0~39 as high impendance*/
+        sddev_control(GPIO_DEV_NAME, CMD_GPIO_CFG, &param);
+    }
+
+    if (((deep_param->wake_up_way & PS_DEEP_WAKEUP_RTC))
+        && (deep_param->sleep_time!= 0xffffffff))
+    {
+    /*ROSC_TIMER  init*/
+#if (CFG_SOC_NAME != SOC_BK7231)
+        reg = (deep_param->sleep_time >> 16)& 0xffff;                                          //'A'
+        REG_WRITE(SCTRL_ROSC_TIMER_H,reg);
+#endif
+
+        reg = REG_READ(SCTRL_ROSC_TIMER);
+        reg |= ROSC_TIMER_INT_STATUS_BIT;                                                                   //'C'
+        REG_WRITE(SCTRL_ROSC_TIMER,reg);  //sys_ctrl : 0x47;
+
+        reg = REG_READ(SCTRL_ROSC_TIMER);
+        reg &= ~(ROSC_TIMER_PERIOD_MASK << ROSC_TIMER_PERIOD_POSI);
+        reg |= ((deep_param->sleep_time & ROSC_TIMER_PERIOD_MASK) << ROSC_TIMER_PERIOD_POSI);
+        REG_WRITE(SCTRL_ROSC_TIMER,reg);   //sys_ctrl : 0x47;                         //'D'
+
+        reg = REG_READ(SCTRL_ROSC_TIMER);
+        reg |= ROSC_TIMER_ENABLE_BIT;
+        REG_WRITE(SCTRL_ROSC_TIMER,reg);  //sys_ctrl : 0x47;                             //'B'
+
+        if(deep_param->lpo_32k_src == LPO_SELECT_32K_XTAL)
+        {
+            REG_WRITE(SCTRL_CONTROL, 0x330100);
+            REG_WRITE(SCTRL_BLOCK_EN_CFG, (0x15D|(0xA5C<<20)));
+            REG_WRITE(SCTRL_ROSC_CAL, 0x30);
+            REG_WRITE(SCTRL_LOW_PWR_CLK, 0x01);
+            REG_WRITE(SCTRL_MODEM_CORE_RESET_PHY_HCLK, 0x03);
+            REG_WRITE(SCTRL_CLK_GATING, 0x1ff);
+        }
+    }
+
+#if ((CFG_SOC_NAME != SOC_BK7231N) && (CFG_SOC_NAME != SOC_BK7236))
+    if ((deep_param->wake_up_way & PS_DEEP_WAKEUP_GPIO))
+    {
+        for (i = 0; i < BITS_INT; i++)
+        {
+#if(BITS_INT > GPIONUM)
+            if(i >= GPIONUM)
+            {
+                break;
+            }
+#endif
+            if (deep_param->gpio_index_map & (0x01UL << i))			/*set gpio 0~31 mode*/
+            {
+                if( deep_param->gpio_edge_map & (0x01UL << i))      //0:high,1:low.
+                {
+                    if (deep_param->gpio_stay_lo_map & (0x01UL << i)) {
+                        param = GPIO_CFG_PARAM(i, GMODE_INPUT);
+                    } else {
+                        param = GPIO_CFG_PARAM(i, GMODE_INPUT_PULLUP);
+                    }
+                    sddev_control(GPIO_DEV_NAME, CMD_GPIO_CFG, &param);
+                    if(0x1 != (UINT32)gpio_ctrl( CMD_GPIO_INPUT, &i))
+                    {   /*check gpio really input value,to correct wrong edge setting*/
+                        param = GPIO_CFG_PARAM(i, GMODE_INPUT);
+                        sddev_control(GPIO_DEV_NAME, CMD_GPIO_CFG, &param);
+                        deep_param->gpio_edge_map &= ~(0x01UL << i);
+                    }
+                }
+                else
+                {
+                    if (deep_param->gpio_stay_lo_map & (0x01UL << i)) {
+                        param = GPIO_CFG_PARAM(i, GMODE_INPUT);
+                    } else {
+                        param = GPIO_CFG_PARAM(i, GMODE_INPUT_PULLDOWN);
+                    }
+                    sddev_control(GPIO_DEV_NAME, CMD_GPIO_CFG, &param);
+                    if(0x0 != (UINT32)gpio_ctrl( CMD_GPIO_INPUT, &i))
+                    {   /*check gpio really input value,to correct wrong edge setting*/
+                        param = GPIO_CFG_PARAM(i, GMODE_INPUT);
+                        sddev_control(GPIO_DEV_NAME, CMD_GPIO_CFG, &param);
+                        deep_param->gpio_edge_map |= (0x01UL << i);
+                    }
+                }
+            }
+        }
+
+        for (i = 0; i < (GPIONUM - BITS_INT); i++)
+        {
+            if (deep_param->gpio_last_index_map & (0x01UL << i))				/*set gpio 32~39 mode*/
+            {
+                if( deep_param->gpio_last_edge_map  & (0x01UL << i))
+                {
+                    if (deep_param->gpio_stay_hi_map & (0x01UL << (i - BITS_INT))) {
+                        param = GPIO_CFG_PARAM(i + BITS_INT, GMODE_INPUT);
+                    } else {
+                        param = GPIO_CFG_PARAM(i + BITS_INT, GMODE_INPUT_PULLUP);
+                    }
+                    sddev_control(GPIO_DEV_NAME, CMD_GPIO_CFG, &param);
+                    reg = i + BITS_INT;
+                    if(0x1 != (UINT32)gpio_ctrl( CMD_GPIO_INPUT, &reg))
+                    {   /*check gpio really input value,to correct wrong edge setting*/
+                        param = GPIO_CFG_PARAM(i + BITS_INT, GMODE_INPUT);
+                        sddev_control(GPIO_DEV_NAME, CMD_GPIO_CFG, &param);
+                        deep_param->gpio_last_edge_map &= ~(0x01UL << i);
+                    }
+                }
+                else
+                {
+                    if (deep_param->gpio_stay_hi_map & (0x01UL << (i - BITS_INT))) {
+                        param = GPIO_CFG_PARAM(i + BITS_INT, GMODE_INPUT);
+                    } else {
+                        param = GPIO_CFG_PARAM(i + BITS_INT, GMODE_INPUT_PULLDOWN);
+                    }
+                    sddev_control(GPIO_DEV_NAME, CMD_GPIO_CFG, &param);
+                    reg = i + BITS_INT;
+                    if(0x0 != (UINT32)gpio_ctrl( CMD_GPIO_INPUT, &reg))
+                    {   /*check gpio really input value,to correct wrong edge setting*/
+                        param = GPIO_CFG_PARAM(i + BITS_INT, GMODE_INPUT);
+                        sddev_control(GPIO_DEV_NAME, CMD_GPIO_CFG, &param);
+                        deep_param->gpio_last_edge_map |= (0x01UL << i);
+                    }
+                }
+            }
+        }
+
+        /* set gpio 0~31 mode*/
+        reg = 0xFFFFFFFF;
+        REG_WRITE(SCTRL_GPIO_WAKEUP_INT_STATUS,reg);
+        reg = deep_param->gpio_edge_map;
+        REG_WRITE(SCTRL_GPIO_WAKEUP_TYPE,reg);
+        reg = deep_param->gpio_index_map;
+        REG_WRITE(SCTRL_GPIO_WAKEUP_EN,reg);
+
+        /* set gpio 31~32 mode*/
+        reg = 0xFF;
+        REG_WRITE(SCTRL_GPIO_WAKEUP_INT_STATUS1,reg);
+
+        reg = deep_param->gpio_last_edge_map;
+        REG_WRITE(SCTRL_GPIO_WAKEUP_TYPE1,reg);
+
+        reg = deep_param->gpio_last_index_map;
+        REG_WRITE(SCTRL_GPIO_WAKEUP_EN1,reg);
+    }
+#elif ((CFG_SOC_NAME == SOC_BK7231N) || (CFG_SOC_NAME == SOC_BK7236))
+    if(( deep_param->wake_up_way & PS_DEEP_WAKEUP_GPIO ))
+    {
+        for ( i = 0; i < BITS_INT; i++ )
+        {
+#if(BITS_INT > GPIONUM)
+            if( i >= GPIONUM )
+            {
+                break;
+            }
+#endif
+            if((( i > GPIO1 ) && ( i < GPIO6 ))
+            || (( i > GPIO11 ) && ( i < GPIO14 ))
+            || (( i > GPIO17 ) && ( i < GPIO20 ))
+            || (( i > GPIO24 ) && ( i < GPIO26 ))
+            || (( i > GPIO26 ) && ( i < GPIO28 )))
+            {
+                continue;
+            }
+
+            if ( deep_param->gpio_index_map & ( 0x01UL << i ))
+            {
+                int type_h,type_l;
+                type_l = deep_param->gpio_edge_map;
+                type_h = 0x0;
+
+                /* low level or negedge wakeup */
+                if(( type_h & ( 0x01UL << i )) == ( type_l & ( 0x01UL << i )))
+                {
+                    if (deep_param->gpio_stay_lo_map & (0x01UL << i)) {
+                        param = GPIO_CFG_PARAM(i, GMODE_INPUT);
+                    } else {
+                        param = GPIO_CFG_PARAM(i, GMODE_INPUT_PULLUP);
+                    }
+                    sddev_control(GPIO_DEV_NAME, CMD_GPIO_CFG, &param);
+                }
+                else    /* high level or posedge wakeup */
+                {
+                    if (deep_param->gpio_stay_lo_map & (0x01UL << i)) {
+                        param = GPIO_CFG_PARAM(i, GMODE_INPUT);
+                    } else {
+                        param = GPIO_CFG_PARAM(i, GMODE_INPUT_PULLDOWN);
+                    }
+                    sddev_control(GPIO_DEV_NAME, CMD_GPIO_CFG, &param);
+                }
+
+                REG_WRITE(SCTRL_GPIO_WAKEUP_TYPE, type_l);
+                REG_WRITE(SCTRL_GPIO_WAKEUP_TYPE_SELECT, type_h);
+            }
+        }
+
+        reg = deep_param->gpio_index_map;
+        REG_WRITE(SCTRL_GPIO_WAKEUP_EN,reg);
+    }
+#endif
+
+#if (CFG_SOC_NAME != SOC_BK7231N)
+    REG_WRITE(SCTRL_USB_PLUG_WAKEUP,USB_PLUG_IN_INT_BIT|USB_PLUG_OUT_INT_BIT);
+    if(deep_param->wake_up_way & PS_DEEP_WAKEUP_USB)
+    {
+        REG_WRITE(SCTRL_USB_PLUG_WAKEUP,USB_PLUG_IN_EN_BIT|USB_PLUG_OUT_EN_BIT);
+    }
+#endif
+
+#ifdef BK_DEEP_SLEEP_DEBUG
+    BK_DEEP_SLEEP_PRT("SCTRL_CONTROL=0x%08X\r\n", REG_READ(SCTRL_CONTROL));
+    BK_DEEP_SLEEP_PRT("SCTRL_SLEEP=0x%08X\r\n", REG_READ(SCTRL_SLEEP));
+    BK_DEEP_SLEEP_PRT("SCTRL_ROSC_TIMER=0x%08X\r\n", REG_READ(SCTRL_ROSC_TIMER));
+    BK_DEEP_SLEEP_PRT("SCTRL_BLOCK_EN_CFG=0x%08X\r\n", REG_READ(SCTRL_BLOCK_EN_CFG));
+    BK_DEEP_SLEEP_PRT("SCTRL_ROSC_CAL=0x%08X\r\n", REG_READ(SCTRL_ROSC_CAL));
+    BK_DEEP_SLEEP_PRT("SCTRL_BLOCK_EN_MUX=0x%08X\r\n", REG_READ(SCTRL_BLOCK_EN_MUX));
+    BK_DEEP_SLEEP_PRT("SCTRL_LOW_PWR_CLK=0x%08X\r\n", REG_READ(SCTRL_LOW_PWR_CLK));
+    BK_DEEP_SLEEP_PRT("SCTRL_PWR_MAC_MODEM=0x%08X\r\n", REG_READ(SCTRL_PWR_MAC_MODEM));
+    BK_DEEP_SLEEP_PRT("SCTRL_MODEM_CORE_RESET_PHY_HCLK=0x%08X\r\n", REG_READ(SCTRL_MODEM_CORE_RESET_PHY_HCLK));
+    BK_DEEP_SLEEP_PRT("SCTRL_CLK_GATING=0x%08X\r\n", REG_READ(SCTRL_CLK_GATING));
+    BK_DEEP_SLEEP_PRT("SCTRL_GPIO_WAKEUP_INT_STATUS=0x%08X\r\n", REG_READ(SCTRL_GPIO_WAKEUP_INT_STATUS));
+    BK_DEEP_SLEEP_PRT("SCTRL_GPIO_WAKEUP_TYPE=0x%08X\r\n", REG_READ(SCTRL_GPIO_WAKEUP_TYPE));
+    BK_DEEP_SLEEP_PRT("SCTRL_GPIO_WAKEUP_EN=0x%08X\r\n", REG_READ(SCTRL_GPIO_WAKEUP_EN));
+    BK_DEEP_SLEEP_PRT("SCTRL_GPIO_WAKEUP_INT_STATUS1=0x%08X\r\n", REG_READ(SCTRL_GPIO_WAKEUP_INT_STATUS1));
+    BK_DEEP_SLEEP_PRT("SCTRL_GPIO_WAKEUP_TYPE1=0x%08X\r\n", REG_READ(SCTRL_GPIO_WAKEUP_TYPE1));
+    BK_DEEP_SLEEP_PRT("SCTRL_GPIO_WAKEUP_EN1=0x%08X\r\n", REG_READ(SCTRL_GPIO_WAKEUP_EN1));
+#endif
+
+    /* enter deep_sleep mode */
+    reg = REG_READ(SCTRL_SLEEP);
+    reg &= ~(SLEEP_MODE_MASK << SLEEP_MODE_POSI);
+    reg = reg | SLEEP_MODE_CFG_DEEP_WORD;
+    REG_WRITE(SCTRL_SLEEP, reg);
+
+    delay(5);
+}

cores/beken-72xx/base/sdk_extern.h

@@ -18,7 +18,7 @@ uint32_t wdt_ctrl(uint32_t cmd, void *param);
 void bk_send_byte(uint8_t uport, uint8_t data);
 void uart_hw_set_change(uint8_t uport, bk_uart_config_t *uart_config);
 int uart_rx_callback_set(int uport, uart_callback callback, void *param);
-void sctrl_enter_rtos_deep_sleep(PS_DEEP_CTRL_PARAM *deep_param);
+void sctrl_enter_rtos_deep_sleep_fix(PS_DEEP_CTRL_PARAM *deep_param);
 void ps_delay(volatile UINT16 times);
 
 #ifdef __cplusplus

cores/beken-72xx/base/wraps/BkDriverFlash.c

@@ -70,8 +70,12 @@ OSStatus __wrap_bk_flash_erase(bk_partition_t partition, uint32_t off_set, uint3
 	return kNoErr;
 }
 
-OSStatus
-__wrap_bk_flash_write(bk_partition_t partition, volatile uint32_t off_set, uint8_t *inBuffer, uint32_t inBufferLength) {
+OSStatus __wrap_bk_flash_write(
+	bk_partition_t partition,
+	volatile uint32_t off_set,
+	uint8_t *inBuffer,
+	uint32_t inBufferLength
+) {
 	UINT32 status;
 	DD_HANDLE flash_hdl;
 	uint32_t start_addr;
@@ -98,8 +102,12 @@ __wrap_bk_flash_write(bk_partition_t partition, volatile uint32_t off_set, uint8
 	return kNoErr;
 }
 
-OSStatus
-__wrap_bk_flash_read(bk_partition_t partition, volatile uint32_t off_set, uint8_t *outBuffer, uint32_t inBufferLength) {
+OSStatus __wrap_bk_flash_read(
+	bk_partition_t partition,
+	volatile uint32_t off_set,
+	uint8_t *outBuffer,
+	uint32_t inBufferLength
+) {
 	UINT32 status;
 	uint32_t start_addr;
 	DD_HANDLE flash_hdl;

cores/common/arduino/libraries/api/WiFi/WiFi.h

@@ -97,8 +97,13 @@ class WiFiClass {
 		const uint8_t *bssid   = NULL,
 		bool connect		   = true
 	);
-	WiFiStatus
-	begin(char *ssid, char *passphrase = NULL, int32_t channel = 0, const uint8_t *bssid = NULL, bool connect = true);
+	WiFiStatus begin(
+		char *ssid,
+		char *passphrase	 = NULL,
+		int32_t channel		 = 0,
+		const uint8_t *bssid = NULL,
+		bool connect		 = true
+	);
 
 	bool config(
 		IPAddress localIP,
@@ -129,6 +134,8 @@ class WiFiClass {
 	uint8_t subnetCIDR();
 	bool enableIpV6();
 	IPv6Address localIPv6();
+	std::vector<IPv6Address> allLocalIPv6();
+
 	const char *getHostname();
 	bool setHostname(const char *hostname);
 	bool setMacAddress(const uint8_t *mac);
@@ -176,7 +183,11 @@ class WiFiClass {
 
   public: /* WiFiAP.cpp */
 	bool softAP(
-		const char *ssid, const char *passphrase = NULL, int channel = 1, bool ssidHidden = false, int maxClients = 4
+		const char *ssid,
+		const char *passphrase = NULL,
+		int channel			   = 1,
+		bool ssidHidden		   = false,
+		int maxClients		   = 4
 	);
 	bool softAPConfig(IPAddress localIP, IPAddress gateway, IPAddress subnet);
 	bool softAPdisconnect(bool wifiOff = false);

cores/common/arduino/libraries/api/WiFi/WiFiSTA.cpp

@@ -44,5 +44,9 @@ __attribute__((weak)) bool WiFiClass::enableIpV6() {
 }
 
 __attribute__((weak)) IPv6Address WiFiClass::localIPv6() {
-	return IPv6Address();
+	return {};
+}
+
+__attribute__((weak)) std::vector<IPv6Address> WiFiClass::allLocalIPv6() {
+	return {};
 }

cores/common/arduino/libraries/api/WiFi/WiFiScan.cpp

@@ -3,7 +3,12 @@
 #include "WiFi.h"
 
 bool WiFiClass::getNetworkInfo(
-	uint8_t networkItem, String &ssid, WiFiAuthMode &encType, int32_t &rssi, uint8_t *&bssid, int32_t &channel
+	uint8_t networkItem,
+	String &ssid,
+	WiFiAuthMode &encType,
+	int32_t &rssi,
+	uint8_t *&bssid,
+	int32_t &channel
 ) {
 	ssid	= SSID(networkItem);
 	encType = encryptionType(networkItem);

cores/common/arduino/libraries/common/WiFiClient/MbedTLSClient.cpp

@@ -86,13 +86,21 @@ int MbedTLSClient::connect(const char *host, uint16_t port, int32_t timeout) {
 }
 
 int MbedTLSClient::connect(
-	IPAddress ip, uint16_t port, const char *rootCABuf, const char *clientCert, const char *clientKey
+	IPAddress ip,
+	uint16_t port,
+	const char *rootCABuf,
+	const char *clientCert,
+	const char *clientKey
 ) {
 	return connect(ipToString(ip).c_str(), port, 0, rootCABuf, clientCert, clientKey, NULL, NULL) == 0;
 }
 
 int MbedTLSClient::connect(
-	const char *host, uint16_t port, const char *rootCABuf, const char *clientCert, const char *clientKey
+	const char *host,
+	uint16_t port,
+	const char *rootCABuf,
+	const char *clientCert,
+	const char *clientKey
 ) {
 	return connect(host, port, 0, rootCABuf, clientCert, clientKey, NULL, NULL) == 0;
 }

cores/common/arduino/libraries/common/WiFiClient/WiFiClientSecure.h

@@ -26,12 +26,22 @@
 
 class IWiFiClientSecure {
   public:
-	virtual int
-	connect(IPAddress ip, uint16_t port, const char *rootCABuf, const char *clientCert, const char *clientKey) = 0;
-	virtual int
-	connect(const char *host, uint16_t port, const char *rootCABuf, const char *clientCert, const char *clientKey) = 0;
-	virtual int connect(IPAddress ip, uint16_t port, const char *pskIdent, const char *psk)						   = 0;
-	virtual int connect(const char *host, uint16_t port, const char *pskIdent, const char *psk)					   = 0;
+	virtual int connect(
+		IPAddress ip,
+		uint16_t port,
+		const char *rootCABuf,
+		const char *clientCert,
+		const char *clientKey
+	) = 0;
+	virtual int connect(
+		const char *host,
+		uint16_t port,
+		const char *rootCABuf,
+		const char *clientCert,
+		const char *clientKey
+	)																							= 0;
+	virtual int connect(IPAddress ip, uint16_t port, const char *pskIdent, const char *psk)		= 0;
+	virtual int connect(const char *host, uint16_t port, const char *pskIdent, const char *psk) = 0;
 
 	virtual int lastError(char *buf, const size_t size) = 0;
 	virtual void setInsecure() = 0; // Don't validate the chain, just accept whatever is given. VERY INSECURE!

cores/common/arduino/libraries/common/mDNS/LwIPmDNS.cpp

@@ -20,23 +20,51 @@ extern "C" {
 
 #if LWIP_MDNS_RESPONDER
 
-static std::vector<char *> services_name;
-static std::vector<char *> services;
-static std::vector<uint8_t> protos;
-static std::vector<uint16_t> ports;
-static std::vector<std::vector<char *>> records;
+struct CachedService {
+	CachedService(const char *_name, const char *_service, mdns_sd_proto _proto, uint16_t _port)
+		: name(strdup(_name)), service(strdup(_service)), proto(_proto), port(_port) {}
+
+	CachedService(const CachedService &)			= delete;
+	CachedService &operator=(const CachedService &) = delete;
+
+	CachedService(CachedService &&other)
+		: name(other.name), service(other.service), proto(other.proto), port(other.port),
+		  records(std::move(other.records)) {
+		other.name	  = nullptr;
+		other.service = nullptr;
+		other.records.clear();
+	}
+
+	~CachedService() {
+		if (name) {
+			free(name);
+		}
+
+		if (service) {
+			free(service);
+		}
+
+		for (auto &str : records) {
+			if (str) {
+				free(str);
+			}
+		}
+	}
+
+	char *name;
+	char *service;
+	mdns_sd_proto proto;
+	uint16_t port;
+	std::vector<char *> records;
+};
+
+static std::vector<CachedService> sCachedServices;
 
 static const char *hostName;
 #ifdef LWIP_NETIF_EXT_STATUS_CALLBACK
 NETIF_DECLARE_EXT_CALLBACK(netif_callback)
 #endif
 
-static inline void freeAllocatedStrings(const std::vector<char *> &strings) {
-	for (auto &str : strings) {
-		free(str);
-	}
-}
-
 mDNS::mDNS() {}
 
 mDNS::~mDNS() {
@@ -44,14 +72,7 @@ mDNS::~mDNS() {
 }
 
 void mDNS::cleanup() {
-	freeAllocatedStrings(services_name);
-	services_name.clear();
-	freeAllocatedStrings(services);
-	services.clear();
-	for (auto &record : records) {
-		freeAllocatedStrings(record);
-	}
-	records.clear();
+	sCachedServices.clear();
 
 	free((void *)hostName);
 	hostName = NULL;
@@ -62,10 +83,10 @@ void mDNS::cleanup() {
 
 static void mdnsTxtCallback(struct mdns_service *service, void *userdata) {
 	size_t index = (size_t)userdata;
-	if (index >= records.size())
+	if (index >= sCachedServices.size())
 		return;
 
-	for (const auto record : records[index]) {
+	for (const auto &record : sCachedServices[index].records) {
 		err_t err = mdns_resp_add_service_txtitem(service, record, strlen(record));
 		if (err != ERR_OK) {
 			LT_DM(MDNS, "Error %d while adding txt record: %s", err, record);
@@ -73,32 +94,45 @@ static void mdnsTxtCallback(struct mdns_service *service, void *userdata) {
 	}
 }
 
+#if LWIP_VERSION_SIMPLE < 20200 // TTL removed in LwIP commit 62fb2fd749b (2.2.0 release)
 static void mdnsStatusCallback(struct netif *netif, uint8_t result) {
 	LT_DM(MDNS, "Status: netif %u, status %u", netif->num, result);
 }
+#else
+static void mdnsStatusCallback(struct netif *netif, uint8_t result, int8_t slot) {
+	LT_DM(MDNS, "Status: netif %u, status %u slot %d", netif->num, result, slot);
+}
+#endif
 
 #ifdef LWIP_NETIF_EXT_STATUS_CALLBACK
 static void addServices(struct netif *netif) {
-	for (uint8_t i = 0; i < services.size(); i++) {
+	for (uint8_t i = 0; i < sCachedServices.size(); i++) {
+		const auto &cachedService = sCachedServices[i];
 		LT_DM(
 			MDNS,
 			"Add service: netif %u / %s / %s / %u / %u",
 			netif->num,
-			services_name[i],
-			services[i],
-			protos[i],
-			ports[i]
+			cachedService.name,
+			cachedService.service,
+			cachedService.proto,
+			cachedService.port
 		);
-		mdns_resp_add_service(
+		s8_t slot = mdns_resp_add_service(
 			netif,
-			services_name[i],
-			services[i],
-			(mdns_sd_proto)protos[i],
-			ports[i],
+			cachedService.name,
+			cachedService.service,
+			cachedService.proto,
+			cachedService.port,
+#if LWIP_VERSION_SIMPLE < 20200 // TTL removed in LwIP commit 62fb2fd749b (2.2.0 release)
 			255,
+#endif
 			mdnsTxtCallback,
 			reinterpret_cast<void *>(i) // index of newly added service
 		);
+
+		if (slot < 0) {
+			LT_DM(MDNS, "mdns_resp_add_service returned error %d", slot);
+		}
 	}
 }
 #endif
@@ -111,7 +145,11 @@ static bool enableMDNS(struct netif *netif) {
 			igmp_start(netif);
 			LT_DM(MDNS, "Added IGMP to netif %u", netif->num);
 		}
+#if LWIP_VERSION_SIMPLE < 20200 // TTL removed in LwIP commit 62fb2fd749b (2.2.0 release)
 		err_t ret = mdns_resp_add_netif(netif, hostName, 255);
+#else
+		err_t ret = mdns_resp_add_netif(netif, hostName);
+#endif
 		if (ret == ERR_OK) {
 			LT_DM(MDNS, "mDNS started on netif %u, announcing it to network", netif->num);
 #if LWIP_VERSION_SIMPLE >= 20100
@@ -128,14 +166,17 @@ static bool enableMDNS(struct netif *netif) {
 }
 
 #ifdef LWIP_NETIF_EXT_STATUS_CALLBACK
-static void
-mdns_netif_ext_status_callback(struct netif *netif, netif_nsc_reason_t reason, const netif_ext_callback_args_t *args) {
+static void mdns_netif_ext_status_callback(
+	struct netif *netif,
+	netif_nsc_reason_t reason,
+	const netif_ext_callback_args_t *args
+) {
 	if (reason & LWIP_NSC_NETIF_REMOVED) {
 		LT_DM(MDNS, "Netif removed, stopping mDNS on netif %u", netif->num);
 		mdns_resp_remove_netif(netif);
-	} else if (reason & LWIP_NSC_STATUS_CHANGED) {
-		LT_DM(MDNS, "Netif changed, starting mDNS on netif %u", netif->num);
-		if (enableMDNS(netif) && services.size() > 0) {
+	} else if ((reason & LWIP_NSC_STATUS_CHANGED) || (reason & LWIP_NSC_NETIF_ADDED)) {
+		LT_DM(MDNS, "Netif changed/added, starting mDNS on netif %u", netif->num);
+		if (enableMDNS(netif) && sCachedServices.size() > 0) {
 			LT_DM(MDNS, "Adding services to netif %u", netif->num);
 			addServices(netif);
 		}
@@ -179,51 +220,54 @@ void mDNS::end() {
 bool mDNS::addServiceImpl(const char *name, const char *service, uint8_t proto, uint16_t port) {
 	bool added			= false;
 	struct netif *netif = netif_list;
+
+	std::size_t serviceIndex = sCachedServices.size();
+	// add the service to TXT record arrays
+	sCachedServices.emplace_back(name, service, (mdns_sd_proto)proto, port);
+
 	while (netif != NULL) {
 		if (netif_is_up(netif)) {
 			// register TXT callback;
 			// pass service index as userdata parameter
 			LT_DM(MDNS, "Add service: netif %u / %s / %s / %u / %u", netif->num, name, service, proto, port);
-			mdns_resp_add_service(
+			s8_t slot = mdns_resp_add_service(
 				netif,
 				name,
 				service,
 				(mdns_sd_proto)proto,
 				port,
+#if LWIP_VERSION_SIMPLE < 20200 // TTL removed in LwIP commit 62fb2fd749b (2.2.0 release)
 				255,
+#endif
 				mdnsTxtCallback,
-				(void *)services.size() // index of newly added service
+				(void *)serviceIndex // index of newly added service
 			);
+
+			if (slot < 0) {
+				LT_DM(MDNS, "mdns_resp_add_service returned error %d", slot);
+			}
+
 			added = true;
 		}
 		netif = netif->next;
 	}
 
-	if (!added)
-		return false;
-
-	// add the service to TXT record arrays
-	services_name.push_back(strdup(name));
-	services.push_back(strdup(service));
-	protos.push_back(proto);
-	ports.push_back(port);
-	records.emplace_back();
-
-	return true;
+	return added;
 }
 
 bool mDNS::addServiceTxtImpl(const char *service, uint8_t proto, const char *item) {
 	uint8_t i;
-	for (i = 0; i < services.size(); i++) {
+	for (i = 0; i < sCachedServices.size(); i++) {
+		const auto &cachedService = sCachedServices[i];
 		// find a matching service
-		if (strcmp(services[i], service) == 0 && protos[i] == proto) {
+		if (strcmp(cachedService.service, service) == 0 && cachedService.proto == proto) {
 			break;
 		}
 	}
-	if (i == services.size())
+	if (i == sCachedServices.size())
 		return false;
 
-	records[i].push_back(strdup(item));
+	sCachedServices[i].records.push_back(strdup(item));
 	return true;
 }
 

cores/common/arduino/libraries/ext/HTTPClient/HTTPClient.cpp

@@ -321,7 +321,12 @@ bool HTTPClient::begin(String host, uint16_t port, String uri, const char *CAcer
 }
 
 bool HTTPClient::begin(
-	String host, uint16_t port, String uri, const char *CAcert, const char *cli_cert, const char *cli_key
+	String host,
+	uint16_t port,
+	String uri,
+	const char *CAcert,
+	const char *cli_cert,
+	const char *cli_key
 ) {
 	if (_client && !_tcpDeprecated) {
 		log_d("mix up of new and deprecated api");

cores/common/arduino/libraries/ext/WebServer/WebServer.h

@@ -81,7 +81,9 @@ class WebServer {
 
 	bool authenticate(const char *username, const char *password);
 	void requestAuthentication(
-		HTTPAuthMethod mode = BASIC_AUTH, const char *realm = NULL, const String &authFailMsg = String("")
+		HTTPAuthMethod mode		  = BASIC_AUTH,
+		const char *realm		  = NULL,
+		const String &authFailMsg = String("")
 	);
 
 	typedef std::function<void(void)> THandlerFunction;

cores/common/arduino/libraries/ext/WebServer/detail/RequestHandlersImpl.h

@@ -10,7 +10,10 @@ using namespace mime;
 class FunctionRequestHandler : public RequestHandler {
   public:
 	FunctionRequestHandler(
-		WebServer::THandlerFunction fn, WebServer::THandlerFunction ufn, const Uri &uri, HTTPMethod method
+		WebServer::THandlerFunction fn,
+		WebServer::THandlerFunction ufn,
+		const Uri &uri,
+		HTTPMethod method
 	)
 		: _fn(fn), _ufn(ufn), _uri(uri.clone()), _method(method) {
 		_uri->initPathArgs(pathArgs);

cores/common/base/api/lt_sleep.c

@@ -6,6 +6,8 @@ __attribute__((weak)) void lt_deep_sleep_config_gpio(uint32_t gpio_index_map, bo
 
 __attribute__((weak)) void lt_deep_sleep_unset_gpio(uint32_t gpio_index_map);
 
+__attribute__((weak)) void lt_deep_sleep_keep_floating_gpio(uint32_t gpio_index_map, bool on_high);
+
 __attribute__((weak)) void lt_deep_sleep_config_timer(uint32_t sleep_duration);
 
 __attribute__((weak)) void lt_deep_sleep_enter();

cores/common/base/api/lt_sleep.h

@@ -19,6 +19,21 @@ void lt_deep_sleep_config_gpio(uint32_t gpio_index_map, bool on_high);
  */
 void lt_deep_sleep_unset_gpio(uint32_t gpio_index_map);
 
+/**
+ * @brief Configure GPIO pins to be kept floating
+ *
+ * This prevents pins from being configured as pullup/pulldown, based on
+ * the configured wake-up mode (low/high), upon entering deep sleep.
+ * This is important, as some-low power devices may be unable to ever
+ * overcome the internal pull strength and change the level. One example
+ * of such device is a magnetic door sensor that must be able to wake on
+ * level change in both directions.
+ *
+ * @param gpio_index_map bitMap of the pins to set/unset as floating
+ * @param enabled whether to set pins to floating or roll back to default mode
+ */
+void lt_deep_sleep_keep_floating_gpio(uint32_t gpio_index_map, bool enabled);
+
 /**
  * @brief Set a sleep timer to wake up the device
  * @param sleep_duration the time in milliseconds to sleep

cores/realtek-amb/arduino/libraries/WiFi/WiFiSTA.cpp

@@ -2,8 +2,13 @@
 
 #include "WiFiPrivate.h"
 
-WiFiStatus
-WiFiClass::begin(const char *ssid, const char *passphrase, int32_t channel, const uint8_t *bssid, bool connect) {
+WiFiStatus WiFiClass::begin(
+	const char *ssid,
+	const char *passphrase,
+	int32_t channel,
+	const uint8_t *bssid,
+	bool connect
+) {
 	if (!enableSTA(true))
 		return WL_CONNECT_FAILED;
 	if (!validate(ssid, passphrase))

external-libs.json

@@ -90,9 +90,10 @@
 			"+<src/api/*.c>",
 			"+<src/core/*.c>",
 			"+<src/core/ipv4/*.c>",
+			"+<src/core/ipv6/*.c>",
 			"+<src/netif/ethernet.c>",
 			"+<src/netif/etharp.c>",
-			"+<src/apps/mdns/mdns.c>",
+			"+<src/apps/mdns/*.c>",
 			"+<src/apps/sntp/sntp.c>",
 			"+<port/realtek/freertos/ethernetif.c>",
 			"+<port/realtek/freertos/sys_arch.c>"
@@ -110,9 +111,10 @@
 			"+<src/api/*.c>",
 			"+<src/core/*.c>",
 			"+<src/core/ipv4/*.c>",
+			"+<src/core/ipv6/*.c>",
 			"+<src/netif/ethernet.c>",
 			"+<src/netif/etharp.c>",
-			"+<src/apps/mdns/mdns.c>",
+			"+<src/apps/mdns/*.c>",
 			"+<src/apps/sntp/sntp.c>",
 			"+<port/*.c>"
 		],
@@ -128,9 +130,10 @@
 			"+<src/api/*.c>",
 			"+<src/core/*.c>",
 			"+<src/core/ipv4/*.c>",
+			"+<src/core/ipv6/*.c>",
 			"+<src/netif/ethernet.c>",
 			"+<src/netif/etharp.c>",
-			"+<src/apps/mdns/mdns.c>",
+			"+<src/apps/mdns/*.c>",
 			"+<src/apps/sntp/sntp.c>",
 			"+<port/realtek/freertos/ethernetif.c>",
 			"+<port/realtek/freertos/sys_arch.c>"

platform.json

@@ -6,7 +6,7 @@
     "type": "git",
     "url": "https://github.com/libretiny-eu/libretiny.git"
   },
-  "version": "1.6.0",
+  "version": "1.7.0",
   "frameworks": {
     "base": {
       "title": "Base Framework (SDK only)",
@@ -67,7 +67,8 @@
           "2.0.2": "2.0.2-bdk",
           "2.1.0": "2.1.0-bdk",
           "2.1.3": "2.1.3-bdk",
-          "default": "2.1.3-bdk"
+          "2.2.0": "2.2.0-bdk",
+          "default": "2.2.0-bdk"
         }
       }
     },