diff --git a/os/board/bk7239n/src/components/bk_cli/cli_main.c b/os/board/bk7239n/src/components/bk_cli/cli_main.c index 313e839e03..b61c71e200 100644 --- a/os/board/bk7239n/src/components/bk_cli/cli_main.c +++ b/os/board/bk7239n/src/components/bk_cli/cli_main.c @@ -34,6 +34,7 @@ #define TAG "cli" +#define CLI_ATE_EMPTY_LINE_PROBE_TIMEOUT 20 static struct cli_st *pCli = NULL; @@ -460,6 +461,24 @@ static int get_input(char *inbuf, unsigned int *bp) if ((uint8_t)inbuf[0] > 0x7f) { continue; } + if (*bp == 0 && (inbuf[*bp] == RET_CHAR || inbuf[*bp] == END_CHAR)) { + char next_ch = 0; + + /* Keep a standalone CR/LF as an empty line, but wait briefly so + * CRLF-prefixed commands are not split. + */ + while (bk_uart_read_bytes(CLI_UART, &next_ch, 1, CLI_ATE_EMPTY_LINE_PROBE_TIMEOUT) > 0) { + inbuf[0] = next_ch; + if (next_ch != RET_CHAR && next_ch != END_CHAR) { + break; + } + } + + if (inbuf[0] == RET_CHAR || inbuf[0] == END_CHAR) { + inbuf[0] = '\0'; + return 1; + } + } if (inbuf[*bp] == RET_CHAR) continue; if (inbuf[*bp] == END_CHAR) { /* end of input line */ diff --git a/os/board/bk7239n/src/components/bk_cli/nist_test/cli_nist_ecdsa.c b/os/board/bk7239n/src/components/bk_cli/nist_test/cli_nist_ecdsa.c index a333b1f71d..96cc34c897 100755 --- a/os/board/bk7239n/src/components/bk_cli/nist_test/cli_nist_ecdsa.c +++ b/os/board/bk7239n/src/components/bk_cli/nist_test/cli_nist_ecdsa.c @@ -13,6 +13,7 @@ // limitations under the License. #include "cli_nist_common.h" +#include "psa/crypto.h" extern int armino_hal_generate_key(hal_key_type mode, uint32_t key_idx); extern int armino_hal_get_key(hal_key_type mode, uint32_t key_idx, hal_data *key); @@ -24,6 +25,157 @@ extern int armino_hal_der_ecdsa_private_key(hal_data *key, hal_data *prikey); extern int armino_hal_der_ecdsa_public_key(hal_data *key, hal_data *pubkey); extern int armino_hal_be_der_ecdsa_public_key(hal_key_type mode, uint8_t *key, hal_data *pubkey, uint32_t key_len); +#define ECDSA_HASH_OUTPUT_MAX_SIZE 64 + +static psa_algorithm_t hal_hash_type_to_psa_alg(hal_hash_type hash_t) +{ + switch (hash_t) { + case HAL_HASH_MD5: return PSA_ALG_MD5; + case HAL_HASH_SHA1: return PSA_ALG_SHA_1; + case HAL_HASH_SHA224: return PSA_ALG_SHA_224; + case HAL_HASH_SHA256: return PSA_ALG_SHA_256; + case HAL_HASH_SHA384: return PSA_ALG_SHA_384; + case HAL_HASH_SHA512: return PSA_ALG_SHA_512; + default: return PSA_ALG_NONE; + } +} + +static int compute_msg_hash(hal_hash_type hash_t, const uint8_t *msg, size_t msg_len, + uint8_t *hash_buf, size_t hash_buf_size, size_t *hash_len) +{ + psa_algorithm_t alg = hal_hash_type_to_psa_alg(hash_t); + if (alg == PSA_ALG_NONE) { + BK_LOGE(NULL, "unsupported hash type %d\n", hash_t); + return NIST_FAIL; + } + psa_status_t status = psa_hash_compute(alg, msg, msg_len, hash_buf, hash_buf_size, hash_len); + if (status != PSA_SUCCESS) { + BK_LOGE(NULL, "psa_hash_compute failed: %d\n", status); + return NIST_FAIL; + } + return NIST_OK; +} + +static size_t der_read_length(const uint8_t *data, size_t data_len, size_t *value) +{ + if (data_len == 0) return 0; + if ((data[0] & 0x80) == 0) { + *value = data[0]; + return 1; + } + size_t num_bytes = data[0] & 0x7F; + if (num_bytes == 0 || num_bytes > 2 || data_len < 1 + num_bytes) return 0; + size_t v = 0; + for (size_t i = 0; i < num_bytes; i++) { + v = (v << 8) | data[1 + i]; + } + *value = v; + return 1 + num_bytes; +} + +static size_t der_write_length(uint8_t *buf, size_t value) +{ + if (value < 0x80) { + buf[0] = (uint8_t)value; + return 1; + } else if (value <= 0xFF) { + buf[0] = 0x81; + buf[1] = (uint8_t)value; + return 2; + } else { + buf[0] = 0x82; + buf[1] = (uint8_t)(value >> 8); + buf[2] = (uint8_t)(value & 0xFF); + return 3; + } +} + +static int ecdsa_der_to_raw(const uint8_t *der, size_t der_len, + uint8_t *raw, size_t component_size, size_t *raw_len) +{ + if (der_len < 6 || der[0] != 0x30) { + return NIST_FAIL; + } + size_t seq_len = 0; + size_t pos = 1; + size_t len_bytes = der_read_length(der + pos, der_len - pos, &seq_len); + if (len_bytes == 0) return NIST_FAIL; + pos += len_bytes; + + for (int comp = 0; comp < 2; comp++) { + if (pos >= der_len || der[pos] != 0x02) { + return NIST_FAIL; + } + pos++; + size_t clen = 0; + len_bytes = der_read_length(der + pos, der_len - pos, &clen); + if (len_bytes == 0) return NIST_FAIL; + pos += len_bytes; + + const uint8_t *cdata = &der[pos]; + pos += clen; + if (pos > der_len) return NIST_FAIL; + + if (clen > 0 && cdata[0] == 0x00) { + cdata++; + clen--; + } + if (clen > component_size) { + return NIST_FAIL; + } + size_t pad = component_size - clen; + memset(raw + comp * component_size, 0, pad); + memcpy(raw + comp * component_size + pad, cdata, clen); + } + *raw_len = component_size * 2; + return NIST_OK; +} + +static int ecdsa_raw_to_der(const uint8_t *raw, size_t component_size, + uint8_t *der, size_t der_buf_size, size_t *der_len) +{ + const uint8_t *r_in = raw; + const uint8_t *s_in = raw + component_size; + size_t r_size = component_size; + size_t s_size = component_size; + + while (r_size > 1 && r_in[0] == 0) { r_in++; r_size--; } + while (s_size > 1 && s_in[0] == 0) { s_in++; s_size--; } + + size_t r_pad = (r_in[0] & 0x80) ? 1 : 0; + size_t s_pad = (s_in[0] & 0x80) ? 1 : 0; + + size_t r_total = r_size + r_pad; + size_t s_total = s_size + s_pad; + size_t seq_len = 2 + r_total + 2 + s_total; + + uint8_t seq_len_buf[3]; + size_t seq_len_bytes = der_write_length(seq_len_buf, seq_len); + size_t total = 1 + seq_len_bytes + seq_len; + + if (total > der_buf_size) { + return NIST_FAIL; + } + + size_t pos = 0; + der[pos++] = 0x30; + memcpy(&der[pos], seq_len_buf, seq_len_bytes); + pos += seq_len_bytes; + der[pos++] = 0x02; + der[pos++] = (uint8_t)r_total; + if (r_pad) der[pos++] = 0x00; + memcpy(&der[pos], r_in, r_size); + pos += r_size; + der[pos++] = 0x02; + der[pos++] = (uint8_t)s_total; + if (s_pad) der[pos++] = 0x00; + memcpy(&der[pos], s_in, s_size); + pos += s_size; + + *der_len = pos; + return NIST_OK; +} + #define HAL_MAX_ECP_KEY_SIZE 133 #define HAL_MAX_ECP_DER_KEY 288 uint8_t nist_ecdsa_key_pair_verify_callback(nist_handle_t *nist_handle) @@ -161,24 +313,44 @@ uint8_t nist_ecdsa_sign_verify_callback(nist_handle_t *nist_handle) BK_LOGI(NULL, "get key failed\n"); return NIST_FAIL; } - // sign + // hash the message + uint8_t hash_buf[ECDSA_HASH_OUTPUT_MAX_SIZE]; + size_t hash_len = 0; + if (compute_msg_hash(hash, msg, msg_len, hash_buf, sizeof(hash_buf), &hash_len) != NIST_OK) { + armino_hal_remove_key(key_mode, 32); + return NIST_FAIL; + } + hal_data msg_digest = {hash_buf, hash_len, NULL, 0}; + + // sign → DER output hal_data sign = {0}; - uint8_t sign_data[136]; - sign.data = sign_data; - hal_data msg_hash = {0}; - msg_hash.data = msg; - msg_hash.data_len = msg_len; - result = armino_hal_ecdsa_sign_md(mode, &msg_hash, 32, &sign); + uint8_t der_sign_buf[144]; + sign.data = der_sign_buf; + sign.data_len = sizeof(der_sign_buf); + result = armino_hal_ecdsa_sign_md(mode, &msg_digest, 32, &sign); if (result != HAL_SUCCESS) { BK_LOGI(NULL, "sign failed\n"); + armino_hal_remove_key(key_mode, 32); + return NIST_FAIL; + } + + // convert DER → raw R || S + uint8_t raw_sign_buf[132]; + size_t raw_sign_len = 0; + result = ecdsa_der_to_raw(sign.data, sign.data_len, + raw_sign_buf, key_len[curve_id], &raw_sign_len); + if (result != NIST_OK) { + BK_LOGE(NULL, "DER->RAW failed\n"); + armino_hal_remove_key(key_mode, 32); return NIST_FAIL; } + result = armino_hal_remove_key(key_mode, 32); if (result != HAL_SUCCESS) { BK_LOGI(NULL, "remove key failed\n"); return NIST_FAIL; } - uint16_t total_len = msg_len + key.data_len + key.priv_len + sign.data_len; + uint16_t total_len = msg_len + key.data_len + key.priv_len + raw_sign_len; uint8_t ret = nist_set_response_total_len(total_len); RETURN_IF_FAIL(ret); @@ -188,7 +360,7 @@ uint8_t nist_ecdsa_sign_verify_callback(nist_handle_t *nist_handle) RETURN_IF_FAIL(ret); ret = nist_add_response_data(key.priv, key.priv_len); RETURN_IF_FAIL(ret); - ret = nist_add_response_data(sign.data, sign.data_len); + ret = nist_add_response_data(raw_sign_buf, raw_sign_len); RETURN_IF_FAIL(ret); return NIST_OK; } @@ -253,19 +425,36 @@ uint8_t nist_ecdsa_verify_verify_callback(nist_handle_t *nist_handle) return NIST_FAIL; } + // hash the message + uint8_t hash_buf[ECDSA_HASH_OUTPUT_MAX_SIZE]; + size_t hash_len = 0; + if (compute_msg_hash(hash, msg, msg_len, hash_buf, sizeof(hash_buf), &hash_len) != NIST_OK) { + kmm_free(pubkey.data); + return NIST_FAIL; + } + hal_data msg_digest = {hash_buf, hash_len, NULL, 0}; + + // convert raw R || S → DER for verify_md + uint8_t raw_cat[132]; + memcpy(raw_cat, sign_r, sign_r_len); + memcpy(raw_cat + sign_r_len, sign_s, sign_s_len); + uint8_t der_sign_buf[144]; + size_t der_sign_len = 0; + int conv_ret = ecdsa_raw_to_der(raw_cat, sign_r_len, der_sign_buf, sizeof(der_sign_buf), &der_sign_len); + if (conv_ret != NIST_OK) { + BK_LOGE(NULL, "RAW->DER failed\n"); + kmm_free(pubkey.data); + return NIST_FAIL; + } + result = armino_hal_set_key(key_mode, 32, &pubkey, NULL); if (result != HAL_SUCCESS) { BK_LOGI(NULL, "set key failed\n"); kmm_free(pubkey.data); return NIST_FAIL; } - hal_data sign_data = {0}; - sign_data.data = sign_r; - sign_data.data_len = sign_len; - hal_data msg_hash = {0}; - msg_hash.data = msg; - msg_hash.data_len = msg_len; - result = armino_hal_ecdsa_verify_md(mode, &msg_hash, &sign_data, 32); + hal_data sign_data = {der_sign_buf, der_sign_len, NULL, 0}; + result = armino_hal_ecdsa_verify_md(mode, &msg_digest, &sign_data, 32); armino_hal_remove_key(key_mode, 32); if ((!expect_result) != (!result)) { BK_LOGI(NULL, "check failed, expect_result = %u, result = %u\n", expect_result, result); diff --git a/os/board/bk7239n/src/components/bk_cli/nist_test/cli_nist_rsa.c b/os/board/bk7239n/src/components/bk_cli/nist_test/cli_nist_rsa.c index f4b427c56b..aaa74a85e2 100755 --- a/os/board/bk7239n/src/components/bk_cli/nist_test/cli_nist_rsa.c +++ b/os/board/bk7239n/src/components/bk_cli/nist_test/cli_nist_rsa.c @@ -13,12 +13,63 @@ // limitations under the License. #include "cli_nist_common.h" +#include "psa/crypto.h" extern int armino_hal_set_key(hal_key_type mode, uint32_t key_idx, hal_data *key, hal_data *prikey); extern int armino_hal_remove_key(hal_key_type mode, uint32_t key_idx); extern int armino_hal_rsa_verify_md(hal_rsa_mode mode, hal_data *hash, hal_data *sign, uint32_t key_idx); extern int armino_hal_rsa_sign_md(hal_rsa_mode mode, hal_data *hash, uint32_t key_idx, hal_data *sign); +static psa_algorithm_t hal_hash_type_to_psa_alg(hal_hash_type hash_t) +{ + switch (hash_t) { + case HAL_HASH_MD5: return PSA_ALG_MD5; + case HAL_HASH_SHA1: return PSA_ALG_SHA_1; + case HAL_HASH_SHA224: return PSA_ALG_SHA_224; + case HAL_HASH_SHA256: return PSA_ALG_SHA_256; + case HAL_HASH_SHA384: return PSA_ALG_SHA_384; + case HAL_HASH_SHA512: return PSA_ALG_SHA_512; + default: return PSA_ALG_NONE; + } +} + +#define RSA_HASH_OUTPUT_MAX_SIZE 64 + +static size_t hal_hash_output_size(hal_hash_type hash_t) +{ + switch (hash_t) { + case HAL_HASH_MD5: return 16; + case HAL_HASH_SHA1: return 20; + case HAL_HASH_SHA224: return 28; + case HAL_HASH_SHA256: return 32; + case HAL_HASH_SHA384: return 48; + case HAL_HASH_SHA512: return 64; + default: return 0; + } +} + +static int compute_msg_hash(hal_hash_type hash_t, const uint8_t *msg, size_t msg_len, + uint8_t *hash_buf, size_t hash_buf_size, size_t *hash_len) +{ + psa_algorithm_t alg = hal_hash_type_to_psa_alg(hash_t); + if (alg == PSA_ALG_NONE) { + BK_LOGE(NULL, "unsupported hash type %d\n", hash_t); + return NIST_FAIL; + } + size_t expected_len = hal_hash_output_size(hash_t); + if (expected_len == 0 || hash_buf_size < expected_len) { + BK_LOGE(NULL, "hash buffer too small: need %u, have %u\n", + (unsigned)expected_len, (unsigned)hash_buf_size); + return NIST_FAIL; + } + psa_status_t status = psa_hash_compute(alg, msg, msg_len, hash_buf, hash_buf_size, hash_len); + if (status != PSA_SUCCESS) { + BK_LOGE(NULL, "psa_hash_compute failed: %d\n", status); + return NIST_FAIL; + } + return NIST_OK; +} + #define SET_RSA_KEY_MODE(sub_type_var, key_mode_var) do { \ switch (sub_type_var) { \ case 0: \ @@ -140,13 +191,20 @@ uint8_t nist_rsa_sign_verify_callback(nist_handle_t *nist_handle) mode.mgf = hash; mode.salt_byte_len = 20; + uint8_t hash_buf[RSA_HASH_OUTPUT_MAX_SIZE]; + size_t hash_len = 0; + if (compute_msg_hash(hash, Msg.data, Msg.data_len, hash_buf, sizeof(hash_buf), &hash_len) != NIST_OK) { + return NIST_FAIL; + } + hal_data msg_digest = {hash_buf, hash_len, NULL, 0}; + result = armino_hal_set_key(key_mode, key_idx, &e, NULL); if (result != HAL_SUCCESS) { BK_LOGE(NULL, "set key failed\n"); return NIST_FAIL; } - result = armino_hal_rsa_verify_md(mode, &Msg, &S, key_idx); + result = armino_hal_rsa_verify_md(mode, &msg_digest, &S, key_idx); if (result != HAL_SUCCESS) { armino_hal_remove_key(key_mode, key_idx); BK_LOGE(NULL, "verify failed\n"); @@ -209,6 +267,13 @@ uint8_t nist_rsa_verify_verify_callback(nist_handle_t *nist_handle) mode.mgf = hash; mode.salt_byte_len = 20; + uint8_t hash_buf[RSA_HASH_OUTPUT_MAX_SIZE]; + size_t hash_len = 0; + if (compute_msg_hash(hash, Msg.data, Msg.data_len, hash_buf, sizeof(hash_buf), &hash_len) != NIST_OK) { + return NIST_FAIL; + } + hal_data msg_digest = {hash_buf, hash_len, NULL, 0}; + result = armino_hal_set_key(key_mode, key_idx, NULL, &d); if (result != HAL_SUCCESS) { BK_LOGI(NULL, "set key failed\n"); @@ -217,7 +282,7 @@ uint8_t nist_rsa_verify_verify_callback(nist_handle_t *nist_handle) signature.data = os_malloc(RSA_MAX_SIGNATURE_BYTE_LEN); signature.data_len = RSA_MAX_SIGNATURE_BYTE_LEN; - result = armino_hal_rsa_sign_md(mode, &Msg, key_idx, &signature); + result = armino_hal_rsa_sign_md(mode, &msg_digest, key_idx, &signature); if (result != HAL_SUCCESS) { BK_LOGE(NULL, "sign failed\n"); result = NIST_FAIL; diff --git a/os/board/bk7239n/src/components/bk_cli/security_test/cli_ecdsa_test.c b/os/board/bk7239n/src/components/bk_cli/security_test/cli_ecdsa_test.c index b9d69eb172..06866f50fd 100755 --- a/os/board/bk7239n/src/components/bk_cli/security_test/cli_ecdsa_test.c +++ b/os/board/bk7239n/src/components/bk_cli/security_test/cli_ecdsa_test.c @@ -19,7 +19,7 @@ extern int armino_hal_ecdsa_sign_md(hal_ecdsa_mode mode, hal_data *hash, uint32_t key_idx, hal_data *sign); extern int armino_hal_ecdsa_verify_md(hal_ecdsa_mode mode, hal_data *hash, hal_data *sign, uint32_t key_idx); -#define SEC_MAX_BUF_SIZE (64) +#define SEC_MAX_BUF_SIZE (139) static void sec_ecdsa_help(void) { diff --git a/os/board/bk7239n/src/components/bk_pm/src/services/bk_pm_sleep.c b/os/board/bk7239n/src/components/bk_pm/src/services/bk_pm_sleep.c index 8304a9bba1..bf5232024a 100644 --- a/os/board/bk7239n/src/components/bk_pm/src/services/bk_pm_sleep.c +++ b/os/board/bk7239n/src/components/bk_pm/src/services/bk_pm_sleep.c @@ -148,6 +148,9 @@ uint64_t pm_normal_sleep_process() #if CONFIG_CKMN bk_rosc_32k_ckest_prog(32); #endif + + pm_rtc_wakeup_reason_parse(); + pm_enable_int(int_level); bk_pm_module_vote_sleep_ctrl(PM_SLEEP_MODULE_NAME_TICK_COMP,0x0,0x0); return sleep_tick; @@ -203,6 +206,8 @@ uint64_t pm_low_voltage_process() } #endif bk_pm_module_vote_sleep_ctrl(PM_SLEEP_MODULE_NAME_TICK_COMP,0x0,0x0); + pm_rtc_wakeup_reason_parse(); + pm_enable_int(int_level); /* Execute post-sleep (wakeup) callbacks */ diff --git a/os/board/bk7239n/src/components/bk_pm/src/services/bk_pm_wakeup_source.c b/os/board/bk7239n/src/components/bk_pm/src/services/bk_pm_wakeup_source.c index 975e94253d..4fda82cf08 100644 --- a/os/board/bk7239n/src/components/bk_pm/src/services/bk_pm_wakeup_source.c +++ b/os/board/bk7239n/src/components/bk_pm/src/services/bk_pm_wakeup_source.c @@ -36,6 +36,7 @@ static touch_wakeup_param_t s_touch_wakeup_param; static uint64_t s_normal_sleep_wakeup_irq = 0; static icu_int_src_t s_normal_sleep_wakeup_irq_id = INT_SRC_NONE; static bk_pm_wakeup_reason_e s_wakeup_reason = BK_PM_WAKEUP_UNKNOWN; +static bk_pm_wakeup_reason_e s_sleep_rtc_wakeup_source = BK_PM_WAKEUP_UNKNOWN; /*=====================VARIABLE SECTION END=================*/ /*================FUNCTION DECLARATION SECTION START========*/ @@ -209,6 +210,7 @@ __attribute__((section(".iram"))) bk_err_t bk_pm_sleep_wakeup_reason_clear() s_normal_sleep_wakeup_irq = 0; s_normal_sleep_wakeup_irq_id = 0; s_wakeup_reason = BK_PM_WAKEUP_UNKNOWN; + s_sleep_rtc_wakeup_source = BK_PM_WAKEUP_UNKNOWN; return BK_OK; } @@ -295,30 +297,13 @@ bk_pm_wakeup_reason_e bk_pm_sleep_wakeup_reason_get() #else case INT_SRC_RTC: #endif - if(bk_rtc_get_first_alarm_name() != NULL) + if(s_sleep_rtc_wakeup_source != BK_PM_WAKEUP_UNKNOWN) { - if(strcmp(bk_rtc_get_first_alarm_name(), PM_WIFI_RTC_ALARM_NAME) == 0) - { - wakeup_reason = BK_PM_WAKEUP_WIFI; - } - else if(strcmp(bk_rtc_get_first_alarm_name(), PM_BT_RTC_ALARM_NAME) == 0) - { - wakeup_reason = BK_PM_WAKEUP_BLE; - } - else if(strcmp(bk_rtc_get_first_alarm_name(), PM_APP_RTC_ALARM_NAME) == 0) - { - wakeup_reason = BK_PM_WAKEUP_HW_TIMER; - } - else - { - wakeup_reason = BK_PM_WAKEUP_HW_TIMER; - } + wakeup_reason = s_sleep_rtc_wakeup_source; } else { - wakeup_reason = BK_PM_WAKEUP_HW_TIMER; } - break; case INT_SRC_MAC_GENERAL: wakeup_reason = BK_PM_WAKEUP_WIFI; @@ -341,3 +326,48 @@ bk_pm_wakeup_reason_e bk_pm_sleep_wakeup_reason_get() } return wakeup_reason; } +bk_err_t pm_rtc_wakeup_reason_parse() +{ + bk_pm_wakeup_reason_e wakeup_reason = BK_PM_WAKEUP_UNKNOWN; + uint32_t int_src = 0; + #if CONFIG_ANA_RTC + int_src = INT_SRC_ANA_RTC; + #else + int_src = INT_SRC_RTC; + #endif + + if(s_normal_sleep_wakeup_irq_id == int_src) + { + if(bk_rtc_get_first_alarm_name() != NULL) + { + if(strncmp(bk_rtc_get_first_alarm_name(), PM_WIFI_RTC_ALARM_NAME, sizeof(PM_WIFI_RTC_ALARM_NAME)) == 0) + { + wakeup_reason = BK_PM_WAKEUP_WIFI; + } + else if(strncmp(bk_rtc_get_first_alarm_name(), PM_BT_RTC_ALARM_NAME, sizeof(PM_BT_RTC_ALARM_NAME)) == 0) + { + wakeup_reason = BK_PM_WAKEUP_BLE; + } + else if(strncmp(bk_rtc_get_first_alarm_name(), PM_APP_RTC_ALARM_NAME, sizeof(PM_APP_RTC_ALARM_NAME)) == 0) + { + wakeup_reason = BK_PM_WAKEUP_HW_TIMER; + } + else if(strncmp(bk_rtc_get_first_alarm_name(), PM_MM_RTC_ALARM_NAME, sizeof(PM_MM_RTC_ALARM_NAME)) == 0) + { + /*mm rtc alarm is on wifi on, it is not a wakeup source, ignore it*/ + } + else + { + wakeup_reason = BK_PM_WAKEUP_HW_TIMER; + } + //LOGI("bk_pm_sleep_wakeup_reason_get: alarm name=%s\r\n", bk_rtc_get_first_alarm_name()); + } + else + { + //LOGI("bk_pm_sleep_wakeup_reason_get: no alarm name\r\n"); + wakeup_reason = BK_PM_WAKEUP_HW_TIMER; + } + s_sleep_rtc_wakeup_source = wakeup_reason; + } + return BK_OK; +} \ No newline at end of file diff --git a/os/board/bk7239n/src/include/modules/pm.h b/os/board/bk7239n/src/include/modules/pm.h index a493593e46..a4d7e0d4cf 100644 --- a/os/board/bk7239n/src/include/modules/pm.h +++ b/os/board/bk7239n/src/include/modules/pm.h @@ -14,6 +14,7 @@ extern "C" { #define PM_WIFI_RTC_ALARM_NAME "bk_wifi" #define PM_BT_RTC_ALARM_NAME "bk_bt" #define PM_APP_RTC_ALARM_NAME "bk_app" +#define PM_MM_RTC_ALARM_NAME "mm_rtc" #define portSVC_DEEP_LV_ENTER (0x0D) #define portSVC_DEEP_LV_EXIT (0x0E) @@ -623,7 +624,19 @@ typedef enum { #define PM_CP1_AUTO_POWER_DOWN_CTRL (PM_CP1_AUTO_POWER_DOWN_ENABLE) /*=====================CONFIG SECTION END=======================*/ - +/** + * @brief parse rtc wakeup reason + * + * @attention + * - This API is to parse rtc wakeup reason. + * + * @param + * -void + * @return + * - BK_OK: succeed + * - others: other errors. + */ +bk_err_t bk_pm_rtc_wakeup_reason_parse(void); /** * @brief Get stable time after sleep wake-up (in microseconds). * diff --git a/os/board/bk7239n/src/middleware/soc/bk7239n/hal/sys_pm_hal.c b/os/board/bk7239n/src/middleware/soc/bk7239n/hal/sys_pm_hal.c index 28e0f6619c..3206367b12 100644 --- a/os/board/bk7239n/src/middleware/soc/bk7239n/hal/sys_pm_hal.c +++ b/os/board/bk7239n/src/middleware/soc/bk7239n/hal/sys_pm_hal.c @@ -74,6 +74,9 @@ extern void delay_us(uint32_t us); extern void flush_all_dcache(void); #define DELAY_US(us) delay_us(us) +__attribute__((section(".iram"))) void pm_delay_us(volatile uint32_t us); +static __attribute__((section(".iram"))) uint64_t pm_get_current_tick(); +__attribute__((section(".iram"))) void pm_delay_us(volatile uint32_t us); #if defined(CONFIG_OTA_POSITION_INDEPENDENT_AB) #define FLASH_BASE_ADDRESS (0x44030000) @@ -940,6 +943,33 @@ __attribute__((section(".iram"))) void sys_drv_wakeup_source_rtc_clear(void) sys_ana_ll_set_ana_reg8_rst_timerwks1v(0); sys_ana_ll_set_ana_reg8_spi_latch1v(0); } + +#define PM_VANALDO_STEP_SIZE (2) +#define PM_VANALDO_STEP_UP_DELAY_US (10) +__attribute__((section(".iram"))) int32 sys_hal_vanaldo_set(uint32_t value) +{ + uint32_t cur = 0; + cur = sys_ana_ll_get_ana_reg7_vanaldosel(); + if (cur == value) { + return 0; + } + + if (value < cur) { + /* Target is lower or equal: set directly */ + sys_ana_ll_set_ana_reg7_vanaldosel(value); + } else { + /* Target is higher: step up by PM_VANALDO_STEP_SIZE, delay PM_VANALDO_STEP_UP_DELAY_US each step */ + uint32_t v; + for (v = cur + PM_VANALDO_STEP_SIZE; v < value; v += PM_VANALDO_STEP_SIZE) { + sys_ana_ll_set_ana_reg7_vanaldosel(v); + pm_delay_us(PM_VANALDO_STEP_UP_DELAY_US); + } + sys_ana_ll_set_ana_reg7_vanaldosel(value); + + pm_delay_us(PM_VANALDO_STEP_UP_DELAY_US); + } + return 0; +} __attribute__((section(".iram"))) void sys_hal_enter_low_voltage(void) { //TODO: fix it when bring up pm @@ -1087,6 +1117,12 @@ __attribute__((section(".iram"))) void sys_hal_enter_low_voltage(void) sys_hal_disable_spi_latch(); #endif /*step 2: set ana voltage to 0.9V */ + uint32_t vanaldosel = sys_ana_ll_get_ana_reg7_vanaldosel(); + uint32_t pwd_regpow = sys_ana_ll_get_ana_reg7_spi_pwd_regpow(); + uint32_t vbspbuf_lp = sys_ana_ll_get_ana_reg7_vbspbuf_lp(); + uint32_t envrefh1v = sys_ana_ll_get_ana_reg7_envrefh1v(); + uint32_t aldohp = sys_ana_ll_get_ana_reg7_aldohp(); + uint32_t dldohp = sys_ana_ll_get_ana_reg7_dldohp(); sys_hal_set_low_voltage(&v_ana_r0, &v_ana_r3, &v_ana_r7, &v_ana_r8, &v_ana_r9, &v_ana_r10); #if defined(CONFIG_LV_FLASH_ENTER_LP_ENABLE) @@ -1148,11 +1184,19 @@ __attribute__((section(".iram"))) void sys_hal_enter_low_voltage(void) /*-----------restore voltage start----------------*/ sys_ana_ll_set_ana_reg8_spi_latch1v(1); + /*step 1: restore ana voltage*/ + sys_hal_vanaldo_set(vanaldosel); + + sys_ana_ll_set_ana_reg7_spi_pwd_regpow(pwd_regpow); + sys_ana_ll_set_ana_reg7_vbspbuf_lp(vbspbuf_lp); + sys_ana_ll_set_ana_reg7_envrefh1v(envrefh1v); + sys_ana_ll_set_ana_reg7_aldohp(aldohp); + sys_ana_ll_set_ana_reg7_dldohp(dldohp); sys_ana_ll_set_ana_reg0_value(v_ana_r0); sys_ana_ll_set_ana_reg3_value(v_ana_r3); - /*step 1: restore ana voltage to 1.1V*/ - sys_ana_ll_set_ana_reg7_value(v_ana_r7); + + //sys_ana_ll_set_ana_reg7_value(v_ana_r7); /*step 2: restore dig voltage to 0.875V by step */ #if defined(CONFIG_SOFT_CTRL_VOLT) /*vdddig voltage*/ @@ -1387,7 +1431,7 @@ void sys_hal_enter_cpu_wfi() { arch_sleep(); } -__attribute__((section(".iram"))) uint64_t pm_get_current_tick() +static __attribute__((section(".iram"))) uint64_t pm_get_current_tick() { uint32_t low_tick = aon_pmu_hal_rtc_tick_l_get(); uint32_t high_tick = aon_pmu_hal_rtc_tick_h_get()&0xF;