Merge branch 'feature/nmea-parser' into 'master'

NMEA0183 Parser

See merge request idf/esp-idf!3866

.flake8

@@ -0,0 +1,237 @@
+[flake8]
+
+select =
+    # Full lists are given in order to suppress all errors from other plugins
+    # Full list of pyflakes error codes:
+    F401,           # module imported but unused
+    F402,           # import module from line N shadowed by loop variable
+    F403,           # 'from module import *' used; unable to detect undefined names
+    F404,           # future import(s) name after other statements
+    F405,           # name may be undefined, or defined from star imports: module
+    F406,           # 'from module import *' only allowed at module level
+    F407,           # an undefined __future__ feature name was imported
+    F601,           # dictionary key name repeated with different values
+    F602,           # dictionary key variable name repeated with different values
+    F621,           # too many expressions in an assignment with star-unpacking
+    F622,           # two or more starred expressions in an assignment (a, *b, *c = d)
+    F631,           # assertion test is a tuple, which are always True
+    F701,           # a break statement outside of a while or for loop
+    F702,           # a continue statement outside of a while or for loop
+    F703,           # a continue statement in a finally block in a loop
+    F704,           # a yield or yield from statement outside of a function
+    F705,           # a return statement with arguments inside a generator
+    F706,           # a return statement outside of a function/method
+    F707,           # an except: block as not the last exception handler
+    F721, F722,     #    doctest syntax error syntax error in forward type annotation
+    F811,           # redefinition of unused name from line N
+    F812,           # list comprehension redefines name from line N
+    F821,           # undefined name name
+    F822,           # undefined name name in __all__
+    F823,           # local variable name referenced before assignment
+    F831,           # duplicate argument name in function definition
+    F841,           # local variable name is assigned to but never used
+    F901,           # raise NotImplemented should be raise NotImplementedError
+
+    # Full list of pycodestyle violations:
+    E101,           # indentation contains mixed spaces and tabs
+    E111,           # indentation is not a multiple of four
+    E112,           # expected an indented block
+    E113,           # unexpected indentation
+    E114,           # indentation is not a multiple of four (comment)
+    E115,           # expected an indented block (comment)
+    E116,           # unexpected indentation (comment)
+    E121,           # continuation line under-indented for hanging indent
+    E122,           # continuation line missing indentation or outdented
+    E123,           # closing bracket does not match indentation of opening bracket's line
+    E124,           # closing bracket does not match visual indentation
+    E125,           # continuation line with same indent as next logical line
+    E126,           # continuation line over-indented for hanging indent
+    E127,           # continuation line over-indented for visual indent
+    E128,           # continuation line under-indented for visual indent
+    E129,           # visually indented line with same indent as next logical line
+    E131,           # continuation line unaligned for hanging indent
+    E133,           # closing bracket is missing indentation
+    E201,           # whitespace after '('
+    E202,           # whitespace before ')'
+    E203,           # whitespace before ':'
+    E211,           # whitespace before '('
+    E221,           # multiple spaces before operator
+    E222,           # multiple spaces after operator
+    E223,           # tab before operator
+    E224,           # tab after operator
+    E225,           # missing whitespace around operator
+    E226,           # missing whitespace around arithmetic operator
+    E227,           # missing whitespace around bitwise or shift operator
+    E228,           # missing whitespace around modulo operator
+    E231,           # missing whitespace after ',', ';', or ':'
+    E241,           # multiple spaces after ','
+    E242,           # tab after ','
+    E251,           # unexpected spaces around keyword / parameter equals
+    E261,           # at least two spaces before inline comment
+    E262,           # inline comment should start with '# '
+    E265,           # block comment should start with '# '
+    E266,           # too many leading '#' for block comment
+    E271,           # multiple spaces after keyword
+    E272,           # multiple spaces before keyword
+    E273,           # tab after keyword
+    E274,           # tab before keyword
+    E275,           # missing whitespace after keyword
+    E301,           # expected 1 blank line, found 0
+    E302,           # expected 2 blank lines, found 0
+    E303,           # too many blank lines 
+    E304,           # blank lines found after function decorator
+    E305,           # expected 2 blank lines after end of function or class
+    E306,           # expected 1 blank line before a nested definition
+    E401,           # multiple imports on one line
+    E402,           # module level import not at top of file
+    E501,           # line too long (82 > 79 characters)
+    E502,           # the backslash is redundant between brackets
+    E701,           # multiple statements on one line (colon)
+    E702,           # multiple statements on one line (semicolon)
+    E703,           # statement ends with a semicolon
+    E704,           # multiple statements on one line (def)
+    E711,           # comparison to None should be 'if cond is None:'
+    E712,           # comparison to True should be 'if cond is True:' or 'if cond:'
+    E713,           # test for membership should be 'not in'
+    E714,           # test for object identity should be 'is not'
+    E721,           # do not compare types, use 'isinstance()'
+    E722,           # do not use bare except, specify exception instead
+    E731,           # do not assign a lambda expression, use a def
+    E741,           # do not use variables named 'l', 'O', or 'I'
+    E742,           # do not define classes named 'l', 'O', or 'I'
+    E743,           # do not define functions named 'l', 'O', or 'I'
+    E901,           # SyntaxError or IndentationError
+    E902,           # IOError
+    W191,           # indentation contains tabs
+    W291,           # trailing whitespace
+    W292,           # no newline at end of file
+    W293,           # blank line contains whitespace
+    W391,           # blank line at end of file
+    W503,           # line break before binary operator
+    W504,           # line break after binary operator
+    W505,           # doc line too long (82 > 79 characters)
+    W601,           # .has_key() is deprecated, use 'in'
+    W602,           # deprecated form of raising exception
+    W603,           # '<>' is deprecated, use '!='
+    W604,           # backticks are deprecated, use 'repr()'
+    W605,           # invalid escape sequence 'x'
+    W606,           # 'async' and 'await' are reserved keywords starting with Python 3.7
+
+    # Full list of flake8 violations
+    E999,           # failed to compile a file into an Abstract Syntax Tree for the plugins that require it
+
+    # Full list of mccabe violations
+    C901            # complexity value provided by the user
+
+ignore =
+    E221,           # multiple spaces before operator
+    E231,           # missing whitespace after ',', ';', or ':'
+    E241,           # multiple spaces after ','
+    W503,           # line break before binary operator
+    W504            # line break after binary operator
+
+max-line-length = 160
+
+show_source = True
+
+statistics = True
+
+exclude =
+    .git,
+    __pycache__,
+    # submodules
+        components/esptool_py/esptool,
+        components/micro-ecc/micro-ecc,
+        components/nghttp/nghttp2,
+        components/libsodium/libsodium,
+        components/json/cJSON,
+        components/mbedtls/mbedtls,
+        components/expat/expat,
+        components/unity/unity,
+        examples/build_system/cmake/import_lib/main/lib/tinyxml2
+    # autogenerated scripts
+        examples/provisioning/custom_config/components/custom_provisioning/python/custom_config_pb2.py,
+    # temporary list (should be empty)
+        components/app_update/dump_otadata.py,
+        components/app_update/gen_empty_partition.py,
+        components/espcoredump/espcoredump.py,
+        components/espcoredump/test/test_espcoredump.py,
+        components/nvs_flash/nvs_partition_generator/nvs_partition_gen.py,
+        components/partition_table/gen_esp32part.py,
+        components/partition_table/test_gen_esp32part_host/gen_esp32part_tests.py,
+        components/protocomm/python/constants_pb2.py,
+        components/protocomm/python/sec0_pb2.py,
+        components/protocomm/python/sec1_pb2.py,
+        components/protocomm/python/session_pb2.py,
+        components/ulp/esp32ulp_mapgen.py,
+        components/wifi_provisioning/python/wifi_config_pb2.py,
+        components/wifi_provisioning/python/wifi_constants_pb2.py,
+        examples/provisioning/ble_prov/ble_prov_test.py,
+        examples/provisioning/softap_prov/softap_prov_test.py,
+        examples/provisioning/softap_prov/utils/wifi_tools.py,
+        tools/ci/apply_bot_filter.py,
+        tools/cmake/convert_to_cmake.py,
+        tools/esp_app_trace/apptrace_proc.py,
+        tools/esp_app_trace/logtrace_proc.py,
+        tools/esp_app_trace/pylibelf/__init__.py,
+        tools/esp_app_trace/pylibelf/constants/__init__.py,
+        tools/esp_app_trace/pylibelf/iterators/__init__.py,
+        tools/esp_app_trace/pylibelf/macros/__init__.py,
+        tools/esp_app_trace/pylibelf/types/__init__.py,
+        tools/esp_app_trace/pylibelf/util/__init__.py,
+        tools/esp_app_trace/pylibelf/util/syms/__init__.py,
+        tools/esp_prov/esp_prov.py,
+        tools/esp_prov/proto/__init__.py,
+        tools/esp_prov/prov/__init__.py,
+        tools/esp_prov/prov/custom_prov.py,
+        tools/esp_prov/prov/wifi_prov.py,
+        tools/esp_prov/security/__init__.py,
+        tools/esp_prov/security/security.py,
+        tools/esp_prov/security/security0.py,
+        tools/esp_prov/security/security1.py,
+        tools/esp_prov/transport/__init__.py,
+        tools/esp_prov/transport/ble_cli.py,
+        tools/esp_prov/transport/transport.py,
+        tools/esp_prov/transport/transport_ble.py,
+        tools/esp_prov/transport/transport_console.py,
+        tools/esp_prov/transport/transport_softap.py,
+        tools/esp_prov/utils/__init__.py,
+        tools/esp_prov/utils/convenience.py,
+        tools/gen_esp_err_to_name.py,
+        tools/idf.py,
+        tools/idf_size.py,
+        tools/kconfig_new/confgen.py,
+        tools/kconfig_new/confserver.py,
+        tools/kconfig_new/gen_kconfig_doc.py,
+        tools/kconfig_new/kconfiglib.py,
+        tools/kconfig_new/test/test_confserver.py,
+        tools/ldgen/fragments.py,
+        tools/ldgen/generation.py,
+        tools/ldgen/ldgen.py,
+        tools/ldgen/pyparsing.py,
+        tools/ldgen/sdkconfig.py,
+        tools/ldgen/test/test_fragments.py,
+        tools/ldgen/test/test_generation.py,
+        tools/mass_mfg/mfg_gen.py,
+        tools/test_idf_monitor/run_test_idf_monitor.py,
+        tools/test_idf_size/test_idf_size.py,
+        tools/tiny-test-fw/CIAssignExampleTest.py,
+        tools/tiny-test-fw/CIAssignUnitTest.py,
+        tools/tiny-test-fw/DUT.py,
+        tools/tiny-test-fw/EnvConfig.py,
+        tools/tiny-test-fw/IDF/IDFApp.py,
+        tools/tiny-test-fw/IDF/IDFDUT.py,
+        tools/tiny-test-fw/Runner.py,
+        tools/tiny-test-fw/TinyFW.py,
+        tools/tiny-test-fw/Utility/CaseConfig.py,
+        tools/tiny-test-fw/Utility/LineChart.py,
+        tools/tiny-test-fw/Utility/PowerControl.py,
+        tools/tiny-test-fw/Utility/SearchCases.py,
+        tools/tiny-test-fw/Utility/__init__.py,
+        tools/tiny-test-fw/docs/conf.py,
+        tools/tiny-test-fw/example.py,
+        tools/unit-test-app/idf_ext.py,
+        tools/unit-test-app/tools/CreateSectionTable.py,
+        tools/unit-test-app/tools/UnitTestParser.py,
+        tools/unit-test-app/unit_test.py,
+        tools/windows/eclipse_make.py,

.gitignore

@@ -68,3 +68,9 @@ test_multi_heap_host
 
 # VS Code Settings
 .vscode/
+
+# Results for the checking of the Python coding style
+flake8_output.txt
+
+# ESP-IDF library 
+build

.gitlab-ci.yml

@@ -19,7 +19,7 @@ variables:
   GET_SOURCES_ATTEMPTS: "10"
   ARTIFACT_DOWNLOAD_ATTEMPTS: "10"
 
-  # We use get-full-sources.sh script to fetch the submodules and/or re-fetch the repo
+  # We use get_sources.sh script to fetch the submodules and/or re-fetch the repo
   # if it was corrupted (if submodule update fails this can happen)
   GIT_STRATEGY: fetch
   GIT_SUBMODULE_STRATEGY: none
@@ -113,6 +113,7 @@ build_template_app:
     - build
   variables:
     BATCH_BUILD: "1"
+    IDF_CI_BUILD: "1"
   only:
     variables:
       - $BOT_TRIGGER_WITH_LABEL == null
@@ -209,8 +210,8 @@ build_esp_idf_tests_make:
     - if [ "$UNIT_TEST_BUILD_SYSTEM" == "make" ]; then exit 0; fi
     # If Make, delete the CMake built artifacts
     - rm -rf builds output sdkconfig
-    - rm -rf $CI_PROJECT_DIR/components/idf_test/unit_test/TestCaseAll.yml
-    - rm -rf $CI_PROJECT_DIR/components/idf_test/unit_test/CIConfigs/*.yml
+    - rm -rf components/idf_test/unit_test/TestCaseAll.yml
+    - rm -rf components/idf_test/unit_test/CIConfigs/*.yml
 
 build_esp_idf_tests_cmake:
   <<: *build_esp_idf_unit_test_template
@@ -227,8 +228,8 @@ build_esp_idf_tests_cmake:
     - if [ "$UNIT_TEST_BUILD_SYSTEM" == "cmake" ]; then exit 0; fi
     # If Make, delete the CMake built artifacts
     - rm -rf builds output sdkconfig
-    - rm -rf $CI_PROJECT_DIR/components/idf_test/unit_test/TestCaseAll.yml
-    - rm -rf $CI_PROJECT_DIR/components/idf_test/unit_test/CIConfigs/*.yml
+    - rm -rf components/idf_test/unit_test/TestCaseAll.yml
+    - rm -rf components/idf_test/unit_test/CIConfigs/*.yml
 
 .build_examples_make_template: &build_examples_make_template
   <<: *build_template
@@ -239,7 +240,6 @@ build_esp_idf_tests_cmake:
     when: always
     paths:
       - build_examples/*/*/*/build/*.bin
-      - build_examples/*/*/*/sdkconfig
       - build_examples/*/*/*/build/*.elf
       - build_examples/*/*/*/build/*.map
       - build_examples/*/*/*/build/download.config
@@ -247,6 +247,7 @@ build_esp_idf_tests_cmake:
       - $LOG_PATH
     expire_in: 2 days
   variables:
+    IDF_CI_BUILD: "1"
     LOG_PATH: "$CI_PROJECT_DIR/log_examples_make"
   only:
     variables:
@@ -271,7 +272,6 @@ build_esp_idf_tests_cmake:
     when: always
     paths:
       - build_examples_cmake/*/*/*/build/*.bin
-      - build_examples_cmake/*/*/*/sdkconfig
       - build_examples_cmake/*/*/*/build/*.elf
       - build_examples_cmake/*/*/*/build/*.map
       - build_examples_cmake/*/*/*/build/download.config
@@ -279,6 +279,7 @@ build_esp_idf_tests_cmake:
       - $LOG_PATH
     expire_in: 2 days
   variables:
+    IDF_CI_BUILD: "1"
     LOG_PATH: "$CI_PROJECT_DIR/log_examples_cmake"
   only:
     variables:
@@ -460,6 +461,13 @@ test_fatfs_on_host:
     - cd components/fatfs/test_fatfs_host/
     - make test
 
+test_ldgen_on_host:
+  <<: *host_test_template
+  script:
+    - cd tools/ldgen/test
+    - ./test_fragments.py
+    - ./test_generation.py
+
 .host_fuzzer_test_template: &host_fuzzer_test_template
   stage: host_test
   image: $CI_DOCKER_REGISTRY/afl-fuzzer-test
@@ -559,7 +567,7 @@ test_idf_monitor:
     expire_in: 1 week
   script:
     - cd ${IDF_PATH}/tools/test_idf_monitor
-    - ${IDF_PATH}/tools/ci/multirun_with_pyenv.sh ./run_test_idf_monitor.py
+    - ./run_test_idf_monitor.py
 
 test_idf_size:
   <<: *host_test_template
@@ -583,9 +591,9 @@ test_esp_err_to_name_on_host:
   script:
     - cd ${IDF_PATH}/tools/
     - ${IDF_PATH}/tools/ci/multirun_with_pyenv.sh -p 2.7.15 ./gen_esp_err_to_name.py
-    - git diff --exit-code -- ../components/esp32/esp_err_to_name.c || (echo 'Differences found. Please run gen_esp_err_to_name.py and commit the changes.'; exit 1)
+    - git diff --exit-code -- ../components/esp32/esp_err_to_name.c || { echo 'Differences found. Please run gen_esp_err_to_name.py and commit the changes.'; exit 1; }
     - ${IDF_PATH}/tools/ci/multirun_with_pyenv.sh -p 3.4.8 ./gen_esp_err_to_name.py
-    - git diff --exit-code -- ../components/esp32/esp_err_to_name.c || (echo 'Differences found between running under Python 2 and 3.'; exit 1)
+    - git diff --exit-code -- ../components/esp32/esp_err_to_name.c || { echo 'Differences found between running under Python 2 and 3.'; exit 1; }
 
 test_espcoredump:
   <<: *host_test_template
@@ -713,6 +721,18 @@ check_examples_cmake_make:
   script:
     - tools/ci/check_examples_cmake_make.sh
 
+check_python_style:
+  <<: *check_job_template
+  artifacts:
+    when: on_failure
+    paths:
+      - flake8_output.txt
+    expire_in: 1 week
+  before_script: *do_nothing_before
+  script:
+    # run it only under Python 3 (it is very slow under Python 2)
+    - ${IDF_PATH}/tools/ci/multirun_with_pyenv.sh -p 3.4.8 python -m flake8 --config=$IDF_PATH/.flake8 --output-file=flake8_output.txt --tee --benchmark $IDF_PATH
+
 check_ut_cmake_make:
   stage: check
   image: $CI_DOCKER_REGISTRY/esp32-ci-env$BOT_DOCKER_IMAGE_TAG
@@ -729,11 +749,8 @@ check_ut_cmake_make:
 
 check_submodule_sync:
   <<: *check_job_template
-  tags:
-    - github_sync
   variables:
     GIT_STRATEGY: clone
-  retry: 2
   script:
     # check if all submodules are correctly synced to public repostory
     - git submodule update --init --recursive
@@ -963,7 +980,7 @@ example_test_002_01:
     - ESP32
     - Example_ShieldBox_Basic
 
-.example_test_003_01:
+example_test_003_01:
   <<: *example_test_template
   tags:
     - ESP32
@@ -991,6 +1008,12 @@ example_test_006_01:
     - ESP32
     - Example_ShieldBox
 
+example_test_007_01:
+  <<: *example_test_template
+  tags:
+    - ESP32
+    - Example_I2C_CCS811_SENSOR
+
 UT_001_01:
   <<: *unit_test_template
   tags:
@@ -1237,6 +1260,12 @@ UT_001_41:
     - ESP32_IDF
     - UT_T1_1
 
+UT_001_42:
+  <<: *unit_test_template
+  tags:
+    - ESP32_IDF
+    - UT_T1_1
+
 UT_002_01:
   <<: *unit_test_template
   tags:
@@ -1341,7 +1370,7 @@ UT_004_10:
   tags:
     - ESP32_IDF
     - UT_T1_1
-    - psram    
+    - psram
 
 UT_004_11:
   <<: *unit_test_template
@@ -1363,7 +1392,28 @@ UT_004_13:
     - ESP32_IDF
     - UT_T1_1
     - psram
-    
+
+UT_004_14:
+  <<: *unit_test_template
+  tags:
+    - ESP32_IDF
+    - UT_T1_1
+    - psram
+
+UT_004_15:
+  <<: *unit_test_template
+  tags:
+    - ESP32_IDF
+    - UT_T1_1
+    - psram
+
+UT_004_14:
+  <<: *unit_test_template
+  tags:
+    - ESP32_IDF
+    - UT_T1_1
+    - psram
+
 UT_005_01:
   <<: *unit_test_template
   tags:
@@ -1459,7 +1509,7 @@ UT_008_04:
     - ESP32_IDF
     - UT_T1_LEDC
     - psram
-    
+
 UT_009_01:
   <<: *unit_test_template
   tags:
@@ -1471,7 +1521,7 @@ UT_009_02:
   tags:
     - ESP32_IDF
     - UT_T2_RS485
-    
+
 UT_009_03:
   <<: *unit_test_template
   tags:
@@ -1556,37 +1606,87 @@ UT_012_04:
     - UT_T1_1
     - 8Mpsram
 
-UT_017_01:
+UT_012_05:
   <<: *unit_test_template
   tags:
     - ESP32_IDF
-    - UT_T2_1
+    - UT_T1_1
+    - 8Mpsram
 
-UT_017_02:
+UT_014_01:
   <<: *unit_test_template
   tags:
     - ESP32_IDF
-    - UT_T2_1
+    - UT_T2_I2C
 
-UT_017_03:
+UT_014_02:
   <<: *unit_test_template
   tags:
     - ESP32_IDF
-    - UT_T2_1
+    - UT_T2_I2C
 
-UT_017_04:
+UT_014_03:
   <<: *unit_test_template
   tags:
     - ESP32_IDF
-    - UT_T2_1
+    - UT_T2_I2C
+
+UT_014_04:
+  <<: *unit_test_template
+  tags:
+    - ESP32_IDF
+    - UT_T2_I2C
     - psram
 
-UT_017_05:
+UT_015_01:
   <<: *unit_test_template
   tags:
     - ESP32_IDF
-    - UT_T2_1
-    - 8Mpsram
+    - UT_T1_MCPWM
+
+UT_015_02:
+  <<: *unit_test_template
+  tags:
+    - ESP32_IDF
+    - UT_T1_MCPWM
+
+UT_015_03:
+  <<: *unit_test_template
+  tags:
+    - ESP32_IDF
+    - UT_T1_MCPWM
+
+UT_015_04:
+  <<: *unit_test_template
+  tags:
+    - ESP32_IDF
+    - UT_T1_MCPWM
+    - psram
+
+UT_016_01:
+  <<: *unit_test_template
+  tags:
+    - ESP32_IDF
+    - UT_T1_I2S
+
+UT_016_02:
+  <<: *unit_test_template
+  tags:
+    - ESP32_IDF
+    - UT_T1_I2S
+
+UT_016_03:
+  <<: *unit_test_template
+  tags:
+    - ESP32_IDF
+    - UT_T1_I2S
+
+UT_016_04:
+  <<: *unit_test_template
+  tags:
+    - ESP32_IDF
+    - UT_T1_I2S
+    - psram
 
 UT_601_01:
   <<: *unit_test_template
@@ -1744,18 +1844,6 @@ IT_006_05:
     - ESP32_IDF
     - SSC_T1_6
 
-IT_006_06:
-  <<: *test_template
-  tags:
-    - ESP32_IDF
-    - SSC_T1_6
-
-IT_006_07:
-  <<: *test_template
-  tags:
-    - ESP32_IDF
-    - SSC_T1_6
-
 IT_007_01:
   <<: *test_template
   tags:
@@ -1768,12 +1856,6 @@ IT_007_02:
     - ESP32_IDF
     - SSC_T1_7
 
-IT_007_03:
-  <<: *test_template
-  tags:
-    - ESP32_IDF
-    - SSC_T1_7
-
 IT_008_01:
   <<: *test_template
   tags:
@@ -1796,49 +1878,7 @@ IT_011_01:
   <<: *test_template
   tags:
     - ESP32_IDF
-    - SSC_T1_MESH1
-
-IT_011_02:
-  <<: *test_template
-  tags:
-    - ESP32_IDF
-    - SSC_T2_MESH1
-
-IT_011_03:
-  <<: *test_template
-  tags:
-    - ESP32_IDF
-    - SSC_T2_MESH1
-
-IT_011_04:
-  <<: *test_template
-  tags:
-    - ESP32_IDF
-    - SSC_T3_MESH1
-
-IT_011_05:
-  <<: *test_template
-  tags:
-    - ESP32_IDF
-    - SSC_T6_MESH1
-
-IT_011_06:
-  <<: *test_template
-  tags:
-    - ESP32_IDF
-    - SSC_T12_MESH1
-
-IT_011_07:
-  <<: *test_template
-  tags:
-    - ESP32_IDF
-    - SSC_T50_MESH1
-
-IT_011_08:
-  <<: *test_template
-  tags:
-    - ESP32_IDF
-    - SSC_T1_MESH2
+    - SSC_T50_1
 
 IT_012_01:
   <<: *test_template
@@ -1846,12 +1886,6 @@ IT_012_01:
     - ESP32_IDF
     - SSC_T1_9
 
-IT_012_02:
-  <<: *test_template
-  tags:
-    - ESP32_IDF
-    - SSC_T1_9
-
 IT_013_01:
   <<: *test_template
   tags:

.gitmodules

@@ -61,3 +61,11 @@
 [submodule "components/protobuf-c/protobuf-c"]
 	path = components/protobuf-c/protobuf-c
 	url = https://github.com/protobuf-c/protobuf-c
+
+[submodule "components/unity/unity"]
+	path = components/unity/unity
+	url = https://github.com/ThrowTheSwitch/Unity
+
+[submodule "examples/build_system/cmake/import_lib/main/lib/tinyxml2"]
+	path = examples/build_system/cmake/import_lib/main/lib/tinyxml2
+	url = https://github.com/leethomason/tinyxml2

.readthedocs.yml

@@ -1,22 +0,0 @@
-# .readthedocs.yml
-# Read the Docs configuration file
-# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
-
-# Required
-version: 2
-
-# Optionally build your docs in additional formats such as PDF and ePub
-formats:
-  - htmlzip
-  - pdf
-
-# Optionally set the version of Python and requirements required to build your docs
-python:
-  version: 2.7
-  install:
-    - requirements: docs/requirements.txt
-
-# We need to list all the submodules included in documenation build by Doxygen
-submodules: 
-  include:
-    - components/mqtt/esp-mqtt

.travis.yml

@@ -0,0 +1,7 @@
+language: python
+sudo: false
+python:
+  - "3.4"
+script:
+  - pip install flake8
+  - travis_wait 20 python -m flake8 --config=.flake8 .

CMakeLists.txt

@@ -0,0 +1,153 @@
+cmake_minimum_required(VERSION 3.5)
+project(esp-idf C CXX ASM)
+
+if(NOT IDF_PATH)
+    set(IDF_PATH ${CMAKE_CURRENT_LIST_DIR})
+endif()
+
+include(tools/cmake/idf_functions.cmake)
+
+#
+# Set variables that control the build configuration and the build itself
+#
+idf_set_variables()
+
+kconfig_set_variables()
+
+#
+# Generate a component dependencies file, enumerating components to be included in the build
+# as well as their dependencies.
+#
+execute_process(COMMAND "${CMAKE_COMMAND}"
+    -D "COMPONENTS=${IDF_COMPONENTS}"
+    -D "COMPONENT_REQUIRES_COMMON=${IDF_COMPONENT_REQUIRES_COMMON}"
+    -D "EXCLUDE_COMPONENTS=${IDF_EXCLUDE_COMPONENTS}"
+    -D "TEST_COMPONENTS=${IDF_TEST_COMPONENTS}"
+    -D "TEST_EXCLUDE_COMPONENTS=${IDF_TEST_EXCLUDE_COMPONENTS}"
+    -D "BUILD_TESTS=${IDF_BUILD_TESTS}"
+    -D "DEPENDENCIES_FILE=${CMAKE_BINARY_DIR}/component_depends.cmake"
+    -D "COMPONENT_DIRS=${IDF_COMPONENT_DIRS}"
+    -D "BOOTLOADER_BUILD=${BOOTLOADER_BUILD}"
+    -D "IDF_TARGET=${IDF_TARGET}"
+    -D "IDF_PATH=${IDF_PATH}"
+    -D "DEBUG=${DEBUG}"
+    -P "${IDF_PATH}/tools/cmake/scripts/expand_requirements.cmake"
+    WORKING_DIRECTORY "${PROJECT_PATH}")
+include("${CMAKE_BINARY_DIR}/component_depends.cmake")
+
+#
+# We now have the following component-related variables:
+#
+# IDF_COMPONENTS is the list of initial components set by the user
+# (or empty to include all components in the build).
+# BUILD_COMPONENTS is the list of components to include in the build.
+# BUILD_COMPONENT_PATHS is the paths to all of these components, obtained from the component dependencies file.
+#
+# Print the list of found components and test components
+#
+string(REPLACE ";" " " BUILD_COMPONENTS_SPACES "${BUILD_COMPONENTS}")
+message(STATUS "Component names: ${BUILD_COMPONENTS_SPACES}")
+unset(BUILD_COMPONENTS_SPACES)
+message(STATUS "Component paths: ${BUILD_COMPONENT_PATHS}")
+
+# Print list of test components
+if(TESTS_ALL EQUAL 1 OR TEST_COMPONENTS)
+    string(REPLACE ";" " " BUILD_TEST_COMPONENTS_SPACES "${BUILD_TEST_COMPONENTS}")
+    message(STATUS "Test component names: ${BUILD_TEST_COMPONENTS_SPACES}")
+    unset(BUILD_TEST_COMPONENTS_SPACES)
+    message(STATUS "Test component paths: ${BUILD_TEST_COMPONENT_PATHS}")
+endif()
+
+# Generate project configuration
+kconfig_process_config()
+
+# Include sdkconfig.cmake so rest of the build knows the configuration
+include(${SDKCONFIG_CMAKE})
+
+# Verify the environment is configured correctly
+idf_verify_environment()
+
+# Check git revision (may trigger reruns of cmake)
+##  sets IDF_VER to IDF git revision
+idf_get_git_revision()
+
+# Check that the targets set in cache, sdkconfig, and in environment all match
+idf_check_config_target()
+
+## get PROJECT_VER
+app_get_revision("${CMAKE_SOURCE_DIR}")
+
+# Add some idf-wide definitions
+idf_set_global_compile_options()
+
+# generate compile_commands.json (needs to come after project)
+set(CMAKE_EXPORT_COMPILE_COMMANDS 1)
+
+#
+# Setup variables for linker script generation
+#
+ldgen_set_variables()
+
+# Include any top-level project_include.cmake files from components
+foreach(component ${BUILD_COMPONENT_PATHS})
+    set(COMPONENT_PATH "${component}")
+    include_if_exists("${component}/project_include.cmake")
+    unset(COMPONENT_PATH)
+endforeach()
+
+#
+# Add each component to the build as a library
+#
+foreach(COMPONENT_PATH ${BUILD_COMPONENT_PATHS})
+    get_filename_component(COMPONENT_NAME ${COMPONENT_PATH} NAME)
+
+    list(FIND BUILD_TEST_COMPONENT_PATHS ${COMPONENT_PATH} idx)
+
+    if(NOT idx EQUAL -1)
+        list(GET BUILD_TEST_COMPONENTS ${idx} test_component)
+        set(COMPONENT_NAME ${test_component})
+    endif()
+
+    component_get_target(COMPONENT_TARGET ${COMPONENT_NAME})
+
+    add_subdirectory(${COMPONENT_PATH} ${COMPONENT_NAME})
+endforeach()
+unset(COMPONENT_NAME)
+unset(COMPONENT_PATH)
+
+# each component should see the include directories of its requirements
+#
+# (we can't do this until all components are registered and targets exist in cmake, as we have
+# a circular requirements graph...)
+foreach(component ${BUILD_COMPONENTS})
+    component_get_target(component_target ${component})
+    if(TARGET ${component_target})
+        get_component_requirements(${component} deps priv_deps)
+
+        list(APPEND priv_deps ${IDF_COMPONENT_REQUIRES_COMMON})
+
+        foreach(dep ${deps})
+            component_get_target(dep_target ${dep})
+            add_component_dependencies(${component_target} ${dep_target} PUBLIC)
+        endforeach()
+
+        foreach(dep ${priv_deps})
+            component_get_target(dep_target ${dep})
+            add_component_dependencies(${component_target} ${dep_target} PRIVATE)
+        endforeach()
+    endif()
+endforeach()
+
+if(IDF_BUILD_ARTIFACTS)
+    # Write project description JSON file
+    make_json_list("${BUILD_COMPONENTS}" build_components_json)
+    make_json_list("${BUILD_COMPONENT_PATHS}" build_component_paths_json)
+    configure_file("${IDF_PATH}/tools/cmake/project_description.json.in"
+        "${IDF_BUILD_ARTIFACTS_DIR}/project_description.json")
+    unset(build_components_json)
+    unset(build_component_paths_json)
+endif()
+
+set(BUILD_COMPONENTS ${BUILD_COMPONENTS} PARENT_SCOPE)
+
+ldgen_add_dependencies()

Kconfig

@@ -8,6 +8,22 @@ config IDF_CMAKE
     bool
     option env="IDF_CMAKE"
 
+
+# A proxy to get environment variable $IDF_TARGET
+config IDF_TARGET_ENV
+	string
+	option env="IDF_TARGET"
+
+# This option records the IDF target when sdkconfig is generated the first time.
+# It is not updated if environment variable $IDF_TARGET changes later, and
+# the build system is responsible for detecting the mismatch between
+# CONFIG_IDF_TARGET and $IDF_TARGET. 
+config IDF_TARGET
+	string
+	default "IDF_TARGET_NOT_SET" if IDF_TARGET_ENV=""
+	default IDF_TARGET_ENV
+
+
 menu "SDK tool configuration"
 config TOOLPREFIX
     string "Compiler toolchain path/prefix"

add_path.sh

@@ -9,6 +9,7 @@
 if [ -z ${IDF_PATH} ]; then
 	echo "IDF_PATH must be set before including this script."
 else
+	IDF_ADD_PATHS_EXTRAS=
 	IDF_ADD_PATHS_EXTRAS="${IDF_ADD_PATHS_EXTRAS}:${IDF_PATH}/components/esptool_py/esptool"
 	IDF_ADD_PATHS_EXTRAS="${IDF_ADD_PATHS_EXTRAS}:${IDF_PATH}/components/espcoredump"
 	IDF_ADD_PATHS_EXTRAS="${IDF_ADD_PATHS_EXTRAS}:${IDF_PATH}/components/partition_table/"

components/app_trace/CMakeLists.txt

@@ -18,6 +18,7 @@ endif()
 
 set(COMPONENT_REQUIRES)
 set(COMPONENT_PRIV_REQUIRES xtensa-debug-module)
+set(COMPONENT_ADD_LDFRAGMENTS linker.lf)
 
 register_component()
 
@@ -25,4 +26,4 @@ register_component()
 # for gcov
 component_compile_options("-fno-profile-arcs" "-fno-test-coverage")
 
-target_link_libraries(app_trace gcov)
+target_link_libraries(${COMPONENT_TARGET} gcov)

components/app_trace/app_trace.c

@@ -172,7 +172,6 @@
 
 #define ESP_APPTRACE_PRINT_LOCK                 0
 
-#define LOG_LOCAL_LEVEL CONFIG_LOG_DEFAULT_LEVEL
 #include "esp_log.h"
 const static char *TAG = "esp_apptrace";
 

components/app_trace/component.mk

@@ -27,3 +27,5 @@ COMPONENT_SRCDIRS += \
 else
 COMPONENT_SRCDIRS += gcov
 endif
+
+COMPONENT_ADD_LDFRAGMENTS += linker.lf

components/app_trace/linker.lf

@@ -0,0 +1,12 @@
+[mapping]
+archive: libapp_trace.a
+entries: 
+    * (noflash)
+
+[mapping]
+archive: libdriver.a
+entries:
+    : SYSVIEW_TS_SOURCE_TIMER_00 = y || SYSVIEW_TS_SOURCE_TIMER_01 = y 
+      || SYSVIEW_TS_SOURCE_TIMER_10 = y || SYSVIEW_TS_SOURCE_TIMER_11 = y
+    timer (noflash)
+

components/app_trace/sys_view/Config/SEGGER_SYSVIEW_Conf.h

@@ -166,10 +166,11 @@ Revision: $Rev: 5927 $
   #define SEGGER_SYSVIEW_GET_INTERRUPT_ID()   SEGGER_SYSVIEW_X_GetInterruptId() // Get the currently active interrupt Id from the user-provided function.
 #endif
 
-void SEGGER_SYSVIEW_X_SysView_Lock();
-void SEGGER_SYSVIEW_X_SysView_Unlock();
-#define SEGGER_SYSVIEW_LOCK()   SEGGER_SYSVIEW_X_SysView_Lock()
-#define SEGGER_SYSVIEW_UNLOCK() SEGGER_SYSVIEW_X_SysView_Unlock()
+unsigned SEGGER_SYSVIEW_X_SysView_Lock();
+void SEGGER_SYSVIEW_X_SysView_Unlock(unsigned int_state);
+// to be recursive save IRQ status on the stack of the caller
+#define SEGGER_SYSVIEW_LOCK()   unsigned _SYSVIEW_int_state = SEGGER_SYSVIEW_X_SysView_Lock()
+#define SEGGER_SYSVIEW_UNLOCK() SEGGER_SYSVIEW_X_SysView_Unlock(_SYSVIEW_int_state)
 
 #endif  // SEGGER_SYSVIEW_CONF_H
 

components/app_trace/sys_view/SEGGER/SEGGER_SYSVIEW.c

@@ -2368,7 +2368,7 @@ void SEGGER_SYSVIEW_RegisterModule(SEGGER_SYSVIEW_MODULE* pModule) {
     _pFirstModule = pModule;
     _NumModules++;
   }
-  SEGGER_SYSVIEW_SendModule(0);
+  SEGGER_SYSVIEW_SendModule(_NumModules-1);
   if (pModule->pfSendModuleDesc) {
     pModule->pfSendModuleDesc();
   }

components/app_trace/sys_view/Sample/Config/SEGGER_SYSVIEW_Config_FreeRTOS.c

@@ -337,15 +337,18 @@ void SEGGER_SYSVIEW_X_RTT_Unlock()
 {
 }
 
-void SEGGER_SYSVIEW_X_SysView_Lock()
+unsigned SEGGER_SYSVIEW_X_SysView_Lock()
 {
     esp_apptrace_tmo_t tmo;
     esp_apptrace_tmo_init(&tmo, SEGGER_LOCK_WAIT_TMO);
     esp_apptrace_lock_take(&s_sys_view_lock, &tmo);
+    // to be recursive save IRQ status on the stack of the caller to keep it from overwriting
+    return s_sys_view_lock.int_state;
 }
 
-void SEGGER_SYSVIEW_X_SysView_Unlock()
+void SEGGER_SYSVIEW_X_SysView_Unlock(unsigned int_state)
 {
+    s_sys_view_lock.int_state = int_state;
     esp_apptrace_lock_give(&s_sys_view_lock);
 }
 

components/app_update/CMakeLists.txt

@@ -1,17 +1,36 @@
-set(COMPONENT_SRCS "esp_ota_ops.c")
+set(COMPONENT_SRCS "esp_ota_ops.c"
+                   "esp_app_desc.c")
 set(COMPONENT_ADD_INCLUDEDIRS "include")
 
-set(COMPONENT_REQUIRES spi_flash partition_table)
-set(COMPONENT_PRIV_REQUIRES bootloader_support)
+set(COMPONENT_REQUIRES spi_flash partition_table bootloader_support)
 
 register_component()
 
-# Add custom target for generating empty otadata partition for flashing
-if(${OTADATA_PARTITION_OFFSET})
-    add_custom_command(OUTPUT "${PROJECT_BINARY_DIR}/${BLANK_OTADATA_FILE}"
-        COMMAND ${PYTHON} ${CMAKE_CURRENT_SOURCE_DIR}/gen_empty_partition.py
-        --size ${OTADATA_PARTITION_SIZE} "${PROJECT_BINARY_DIR}/${BLANK_OTADATA_FILE}")
+# esp_app_desc structure is added as an undefined symbol because otherwise the 
+# linker will ignore this structure as it has no other files depending on it.
+target_link_libraries(${COMPONENT_TARGET} "-u esp_app_desc")
 
-    add_custom_target(blank_ota_data ALL DEPENDS "${PROJECT_BINARY_DIR}/${BLANK_OTADATA_FILE}")
+set_source_files_properties(
+    SOURCE "esp_app_desc.c"
+    PROPERTIES COMPILE_DEFINITIONS 
+    PROJECT_VER=\"${PROJECT_VER}\")
+
+# Add custom target for generating empty otadata partition for flashing
+if(OTADATA_PARTITION_OFFSET AND OTADATA_PARTITION_SIZE)
+    add_custom_command(OUTPUT "${IDF_BUILD_ARTIFACTS_DIR}/${BLANK_OTADATA_FILE}"
+        COMMAND ${PYTHON} ${IDF_PATH}/components/partition_table/parttool.py
+        --partition-type data --partition-subtype ota -q
+        --partition-table-file ${PARTITION_CSV_PATH} generate_blank_partition_file
+        --output "${IDF_BUILD_ARTIFACTS_DIR}/${BLANK_OTADATA_FILE}")
+
+    add_custom_target(blank_ota_data ALL DEPENDS "${IDF_BUILD_ARTIFACTS_DIR}/${BLANK_OTADATA_FILE}")
     add_dependencies(flash blank_ota_data)
 endif()
+
+set(otatool_py ${PYTHON} ${COMPONENT_PATH}/otatool.py)
+
+add_custom_target(read_otadata DEPENDS "${PARTITION_CSV_PATH}"
+                COMMAND ${otatool_py} --partition-table-file ${PARTITION_CSV_PATH} read_otadata)
+
+add_custom_target(erase_otadata DEPENDS "${PARTITION_CSV_PATH}"
+                COMMAND ${otatool_py} --partition-table-file ${PARTITION_CSV_PATH} erase_otadata)

components/app_update/Kconfig.projbuild

@@ -0,0 +1,12 @@
+menu "Application manager"
+
+config APP_COMPILE_TIME_DATE
+    bool "Use time/date stamp for app"
+    default y
+	help
+        If set, then the app will be built with the current time/date stamp. It is stored in the app description structure.
+        If not set, time/date stamp will be excluded from app image.
+        This can be useful for getting the same binary image files made from the same source, 
+        but at different times.
+
+endmenu # "Application manager"

components/app_update/Makefile.projbuild

@@ -1,60 +1,42 @@
 # Generate partition binary
 #
-.PHONY: dump_otadata erase_ota blank_ota_data
+.PHONY: blank_ota_data erase_otadata read_otadata
 
-GEN_EMPTY_PART := $(PYTHON) $(COMPONENT_PATH)/gen_empty_partition.py
+OTATOOL_PY := $(PYTHON) $(COMPONENT_PATH)/otatool.py
+PARTTOOL_PY := $(PYTHON) $(IDF_PATH)/components/partition_table/parttool.py
+
+# Generate blank partition file
 BLANK_OTA_DATA_FILE = $(BUILD_DIR_BASE)/ota_data_initial.bin
 
-PARTITION_TABLE_LEN := 0xC00
-OTADATA_LEN := 0x2000
+$(BLANK_OTA_DATA_FILE): partition_table_get_info $(PARTITION_TABLE_BIN) | check_python_dependencies
+	$(shell if [ "$(OTA_DATA_OFFSET)" != "" ] && [ "$(OTA_DATA_SIZE)" != "" ]; then \
+				$(PARTTOOL_PY) --partition-type data --partition-subtype ota --partition-table-file $(PARTITION_TABLE_BIN) \
+								-q generate_blank_partition_file --output $(BLANK_OTA_DATA_FILE); \
+			fi; )
+	$(eval BLANK_OTA_DATA_FILE = $(shell if [ "$(OTA_DATA_OFFSET)" != "" ] && [ "$(OTA_DATA_SIZE)" != "" ]; then \
+			echo $(BLANK_OTA_DATA_FILE); else echo " "; fi) )
 
-PARTITION_TABLE_ONCHIP_BIN_PATH := $(call dequote,$(abspath $(BUILD_DIR_BASE)))
-PARTITION_TABLE_ONCHIP_BIN_NAME := "onchip_partition.bin"
-OTADATA_ONCHIP_BIN_NAME := "onchip_otadata.bin"
-
-PARTITION_TABLE_ONCHIP_BIN := $(PARTITION_TABLE_ONCHIP_BIN_PATH)/$(call dequote,$(PARTITION_TABLE_ONCHIP_BIN_NAME)) 
-OTADATA_ONCHIP_BIN := $(PARTITION_TABLE_ONCHIP_BIN_PATH)/$(call dequote,$(OTADATA_ONCHIP_BIN_NAME))
-
-PARTITION_TABLE_GET_BIN_CMD = $(ESPTOOLPY_SERIAL) read_flash $(PARTITION_TABLE_OFFSET) $(PARTITION_TABLE_LEN) $(PARTITION_TABLE_ONCHIP_BIN)
-OTADATA_GET_BIN_CMD = $(ESPTOOLPY_SERIAL) read_flash $(OTADATA_OFFSET) $(OTADATA_LEN) $(OTADATA_ONCHIP_BIN)
-
-GEN_OTADATA = $(IDF_PATH)/components/app_update/dump_otadata.py
-ERASE_OTADATA_CMD = $(ESPTOOLPY_SERIAL) erase_region $(OTADATA_OFFSET) $(OTADATA_LEN)
+blank_ota_data: $(BLANK_OTA_DATA_FILE)
 
 # If there is no otadata partition, both OTA_DATA_OFFSET and BLANK_OTA_DATA_FILE 
 # expand to empty values.
 ESPTOOL_ALL_FLASH_ARGS += $(OTA_DATA_OFFSET) $(BLANK_OTA_DATA_FILE)
 
-$(PARTITION_TABLE_ONCHIP_BIN):
-	$(PARTITION_TABLE_GET_BIN_CMD)
+erase_otadata: $(PARTITION_TABLE_BIN) partition_table_get_info | check_python_dependencies
+	$(OTATOOL_PY) --partition-table-file $(PARTITION_TABLE_BIN) erase_otadata
 
-onchip_otadata_get_info: $(PARTITION_TABLE_ONCHIP_BIN) 
-	$(eval OTADATA_OFFSET:=$(shell $(GET_PART_INFO) --type data --subtype ota --offset $(PARTITION_TABLE_ONCHIP_BIN)))
-	@echo $(if $(OTADATA_OFFSET), $(shell export OTADATA_OFFSET), $(shell rm -f $(PARTITION_TABLE_ONCHIP_BIN));$(error "ERROR: ESP32 does not have otadata partition."))
+read_otadata: $(PARTITION_TABLE_BIN) partition_table_get_info | check_python_dependencies
+	$(OTATOOL_PY) --partition-table-file $(PARTITION_TABLE_BIN) read_otadata
 
-$(OTADATA_ONCHIP_BIN):
-	$(OTADATA_GET_BIN_CMD)
-
-dump_otadata: onchip_otadata_get_info $(OTADATA_ONCHIP_BIN) $(PARTITION_TABLE_ONCHIP_BIN) 
-	@echo "otadata retrieved. Contents:"
-	@echo $(SEPARATOR)
-	$(GEN_OTADATA) $(OTADATA_ONCHIP_BIN)
-	@echo $(SEPARATOR)
-	rm -f $(PARTITION_TABLE_ONCHIP_BIN)
-	rm -f $(OTADATA_ONCHIP_BIN)
-
-$(BLANK_OTA_DATA_FILE): partition_table_get_info
-	$(GEN_EMPTY_PART) --size $(OTA_DATA_SIZE) $(BLANK_OTA_DATA_FILE)
-	$(eval BLANK_OTA_DATA_FILE = $(shell if [ $(OTA_DATA_SIZE) != 0 ]; then echo $(BLANK_OTA_DATA_FILE); else echo " "; fi) )
-
-blank_ota_data: $(BLANK_OTA_DATA_FILE)
-
-erase_ota: partition_table_get_info | check_python_dependencies
-	@echo $(if $(OTA_DATA_OFFSET), "Erase ota_data [addr=$(OTA_DATA_OFFSET) size=$(OTA_DATA_SIZE)] ...", $(error "ERROR: Partition table does not have ota_data partition."))
-	$(ESPTOOLPY_SERIAL) erase_region $(OTA_DATA_OFFSET) $(OTA_DATA_SIZE)
+erase_ota: erase_otadata
+	@echo "WARNING: erase_ota is deprecated. Use erase_otadata instead."
 
 all: blank_ota_data
 flash: blank_ota_data
 
+TMP_DEFINES := $(BUILD_DIR_BASE)/app_update/tmp_cppflags.txt
+export TMP_DEFINES
+
 clean:
 	rm -f $(BLANK_OTA_DATA_FILE)
+	rm -f $(TMP_DEFINES)

components/app_update/component.mk

@@ -3,3 +3,47 @@
 #
 # (Uses default behaviour of compiling all source files in directory, adding 'include' to include path.)
 
+# esp_app_desc structure is added as an undefined symbol because otherwise the 
+# linker will ignore this structure as it has no other files depending on it.
+COMPONENT_ADD_LDFLAGS += -u esp_app_desc
+
+ifndef IS_BOOTLOADER_BUILD
+GET_PROJECT_VER ?=
+ifeq ("${PROJECT_VER}", "")
+ifeq ("$(wildcard ${PROJECT_PATH}/version.txt)","")
+GET_PROJECT_VER := $(shell cd ${PROJECT_PATH} && git describe --always --tags --dirty || echo "Not found git repo")
+ifeq ("${GET_PROJECT_VER}", "Not found git repo")
+$(info Project do not have git repo, it needs to get PROJECT_VER from `git describe` command.)
+GET_PROJECT_VER := ""
+endif
+else
+# read from version.txt
+GET_PROJECT_VER := $(shell cat ${PROJECT_PATH}/version.txt)
+endif
+endif
+# If ``PROJECT_VER`` variable set in project Makefile file, its value will be used.
+# Else, if the ``$PROJECT_PATH/version.txt`` exists, its contents will be used as ``PROJECT_VER``.
+# Else, if the project is located inside a Git repository, the output of git describe will be used.
+# Otherwise, ``PROJECT_VER`` will be empty.
+
+ifeq ("${PROJECT_VER}", "")
+PROJECT_VER:= $(GET_PROJECT_VER)
+else
+PROJECT_VER:= $(PROJECT_VER)
+endif
+$(info App "$(PROJECT_NAME)" version: $(PROJECT_VER))
+
+NEW_DEFINES:= $(PROJECT_VER) $(PROJECT_NAME) $(IDF_VER)
+ifeq ("$(wildcard ${TMP_DEFINES})","")
+OLD_DEFINES:=
+else
+OLD_DEFINES:= $(shell cat $(TMP_DEFINES))
+endif
+
+# If NEW_DEFINES (PROJECT_VER, PROJECT_NAME) were changed then rebuild only esp_app_desc.
+ifneq ("${NEW_DEFINES}", "${OLD_DEFINES}")
+$(shell echo $(NEW_DEFINES) > $(TMP_DEFINES); rm -f esp_app_desc.o;)
+endif
+
+esp_app_desc.o: CPPFLAGS += -D PROJECT_VER=\"$(PROJECT_VER)\" -D PROJECT_NAME=\"$(PROJECT_NAME)\"
+endif

components/app_update/dump_otadata.py

@@ -1,88 +0,0 @@
-#!/usr/bin/env python
-#
-# gen_otadata prints info about the otadata partition.
-#
-# Copyright 2018 Espressif Systems (Shanghai) PTE LTD
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http:#www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-from __future__ import print_function, division
-import argparse
-import os
-import re
-import struct
-import sys
-import hashlib
-import binascii
-
-__version__ = '1.0'
-
-quiet = False
-
-def status(msg):
-    """ Print status message to stderr """
-    if not quiet:
-        critical(msg)
-
-def critical(msg):
-    """ Print critical message to stderr """
-    if not quiet:
-        sys.stderr.write(msg)
-        sys.stderr.write('\n')
-
-def little_endian(buff, offset):
-    data = buff[offset:offset+4]
-    data.reverse()
-    data = ''.join(data)
-    return data
-               
-def main():
-    global quiet
-    parser = argparse.ArgumentParser(description='Prints otadata partition in human readable form.')
-
-    parser.add_argument('--quiet', '-q', help="Don't print status messages to stderr", action='store_true')
-
-    search_type = parser.add_mutually_exclusive_group()
-
-    parser.add_argument('input', help='Path to binary file containing otadata partition to parse.',
-                        type=argparse.FileType('rb'))
-
-    args = parser.parse_args()
-
-    quiet = args.quiet
-
-    input = args.input.read()
-    
-    hex_input_0 = binascii.hexlify(input)
-    hex_input_0 = map(''.join, zip(*[iter(hex_input_0)]*2))
-    hex_input_1 = binascii.hexlify(input[4096:])
-    hex_input_1 = map(''.join, zip(*[iter(hex_input_1)]*2))
-    
-    print("\t%11s\t%8s    |\t%8s\t%8s" %("OTA_SEQ", "CRC", "OTA_SEQ", "CRC"))
-    print("Firmware:  0x%s  \t 0x%s |\t0x%s \t 0x%s" % (little_endian(hex_input_0, 0), little_endian(hex_input_0, 28), \
-                                                        little_endian(hex_input_1, 0), little_endian(hex_input_1, 28)))
-class InputError(RuntimeError):
-    def __init__(self, e):
-        super(InputError, self).__init__(e)
-
-class ValidationError(InputError):
-    def __init__(self, partition, message):
-        super(ValidationError, self).__init__(
-            "Partition %s invalid: %s" % (partition.name, message))
-
-if __name__ == '__main__':
-    try:
-        r = main()
-        sys.exit(r)
-    except InputError as e:
-        print(e, file=sys.stderr)
-        sys.exit(2)

components/app_update/esp_app_desc.c

@@ -0,0 +1,49 @@
+// Copyright 2017-2018 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <assert.h>
+#include "esp_ota_ops.h"
+#include "sdkconfig.h"
+
+// Application version info
+const __attribute__((section(".rodata_desc"))) esp_app_desc_t esp_app_desc = {
+    .magic_word = ESP_APP_DESC_MAGIC_WORD,
+    .version = PROJECT_VER,
+    .project_name = PROJECT_NAME,
+    .idf_ver = IDF_VER,
+
+#ifdef CONFIG_APP_SECURE_VERSION
+    .secure_version = CONFIG_APP_SECURE_VERSION,
+#else
+    .secure_version = 0,
+#endif
+
+#ifdef CONFIG_APP_COMPILE_TIME_DATE
+    .time = __TIME__,
+    .date = __DATE__,
+#else
+    .time = "",
+    .date = "",
+#endif
+};
+
+
+_Static_assert(sizeof(PROJECT_VER) <= sizeof(esp_app_desc.version), "PROJECT_VER is longer than version field in structure");
+_Static_assert(sizeof(IDF_VER) <= sizeof(esp_app_desc.idf_ver), "IDF_VER is longer than idf_ver field in structure");
+_Static_assert(sizeof(PROJECT_NAME) <= sizeof(esp_app_desc.project_name), "PROJECT_NAME is longer than project_name field in structure");
+
+const esp_app_desc_t *esp_ota_get_app_description(void)
+{
+    return &esp_app_desc;
+}

components/app_update/esp_ota_ops.c

@@ -36,10 +36,10 @@
 #include "rom/crc.h"
 #include "soc/dport_reg.h"
 #include "esp_log.h"
+#include "esp_flash_data_types.h"
+#include "bootloader_common.h"
+#include "sys/param.h"
 
-
-#define OTA_MAX(a,b) ((a) >= (b) ? (a) : (b)) 
-#define OTA_MIN(a,b) ((a) <= (b) ? (a) : (b)) 
 #define SUB_TYPE_ID(i) (i & 0x0F) 
 
 typedef struct ota_ops_entry_ {
@@ -52,19 +52,10 @@ typedef struct ota_ops_entry_ {
     LIST_ENTRY(ota_ops_entry_) entries;
 } ota_ops_entry_t;
 
-/* OTA selection structure (two copies in the OTA data partition.)
-   Size of 32 bytes is friendly to flash encryption */
-typedef struct {
-    uint32_t ota_seq;
-    uint8_t  seq_label[24];
-    uint32_t crc;                /* CRC32 of ota_seq field only */
-} ota_select;
-
 static LIST_HEAD(ota_ops_entries_head, ota_ops_entry_) s_ota_ops_entries_head =
     LIST_HEAD_INITIALIZER(s_ota_ops_entries_head);
 
 static uint32_t s_ota_ops_last_handle = 0;
-static ota_select s_ota_select[2];
 
 const static char *TAG = "esp_ota_ops";
 
@@ -77,6 +68,53 @@ static bool is_ota_partition(const esp_partition_t *p)
             && p->subtype < ESP_PARTITION_SUBTYPE_APP_OTA_MAX);
 }
 
+// Read otadata partition and fill array from two otadata structures.
+// Also return pointer to otadata info partition.
+static const esp_partition_t *read_otadata(esp_ota_select_entry_t *two_otadata)
+{
+    const esp_partition_t *otadata_partition = esp_partition_find_first(ESP_PARTITION_TYPE_DATA, ESP_PARTITION_SUBTYPE_DATA_OTA, NULL);
+
+    if (otadata_partition == NULL) {
+        ESP_LOGE(TAG, "not found otadata");
+        return NULL;
+    }
+
+    spi_flash_mmap_handle_t ota_data_map;
+    const void *result = NULL;
+    esp_err_t err = esp_partition_mmap(otadata_partition, 0, otadata_partition->size, SPI_FLASH_MMAP_DATA, &result, &ota_data_map);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "mmap otadata filed. Err=0x%8x", err);
+        return NULL;
+    } else {
+        memcpy(&two_otadata[0], result, sizeof(esp_ota_select_entry_t));
+        memcpy(&two_otadata[1], result + SPI_FLASH_SEC_SIZE, sizeof(esp_ota_select_entry_t));
+        spi_flash_munmap(ota_data_map);
+    }
+    return otadata_partition;
+}
+
+static esp_err_t image_validate(const esp_partition_t *partition, esp_image_load_mode_t load_mode)
+{
+    esp_image_metadata_t data;
+    const esp_partition_pos_t part_pos = {
+        .offset = partition->address,
+        .size = partition->size,
+    };
+
+    if (esp_image_verify(load_mode, &part_pos, &data) != ESP_OK) {
+        return ESP_ERR_OTA_VALIDATE_FAILED;
+    }
+
+#ifdef CONFIG_SECURE_SIGNED_ON_UPDATE
+    esp_err_t ret = esp_secure_boot_verify_signature(partition->address, data.image_len);
+    if (ret != ESP_OK) {
+        return ESP_ERR_OTA_VALIDATE_FAILED;
+    }
+#endif
+
+    return ESP_OK;
+}
+
 esp_err_t esp_ota_begin(const esp_partition_t *partition, size_t image_size, esp_ota_handle_t *out_handle)
 {
     ota_ops_entry_t *new_entry;
@@ -145,7 +183,8 @@ esp_err_t esp_ota_write(esp_ota_handle_t handle, const void *data, size_t size)
         if (it->handle == handle) {
             // must erase the partition before writing to it
             assert(it->erased_size > 0 && "must erase the partition before writing to it");
-            if (it->wrote_size == 0 && it->partial_bytes == 0 && size > 0 && data_bytes[0] != ESP_IMAGE_HEADER_MAGIC) {
+
+            if(it->wrote_size == 0 && size > 0 && data_bytes[0] != 0xE9) {
                 ESP_LOGE(TAG, "OTA image has invalid magic byte (expected 0xE9, saw 0x%02x", data_bytes[0]);
                 return ESP_ERR_OTA_VALIDATE_FAILED;
             }
@@ -156,7 +195,7 @@ esp_err_t esp_ota_write(esp_ota_handle_t handle, const void *data, size_t size)
 
                 /* check if we have partially written data from earlier */
                 if (it->partial_bytes != 0) {
-                    copy_len = OTA_MIN(16 - it->partial_bytes, size);
+                    copy_len = MIN(16 - it->partial_bytes, size);
                     memcpy(it->partial_data + it->partial_bytes, data_bytes, copy_len);
                     it->partial_bytes += copy_len;
                     if (it->partial_bytes != 16) {
@@ -246,32 +285,20 @@ esp_err_t esp_ota_end(esp_ota_handle_t handle)
     return ret;
 }
 
-static uint32_t ota_select_crc(const ota_select *s)
+static esp_err_t rewrite_ota_seq(esp_ota_select_entry_t *two_otadata, uint32_t seq, uint8_t sec_id, const esp_partition_t *ota_data_partition)
 {
-    return crc32_le(UINT32_MAX, (uint8_t *)&s->ota_seq, 4);
-}
-
-static bool ota_select_valid(const ota_select *s)
-{
-    return s->ota_seq != UINT32_MAX && s->crc == ota_select_crc(s);
-}
-
-static esp_err_t rewrite_ota_seq(uint32_t seq, uint8_t sec_id, const esp_partition_t *ota_data_partition)
-{
-    esp_err_t ret;
-
-    if (sec_id == 0 || sec_id == 1) {
-        s_ota_select[sec_id].ota_seq = seq;
-        s_ota_select[sec_id].crc = ota_select_crc(&s_ota_select[sec_id]);
-        ret = esp_partition_erase_range(ota_data_partition, sec_id * SPI_FLASH_SEC_SIZE, SPI_FLASH_SEC_SIZE);
-        if (ret != ESP_OK) {
-            return ret;
-        } else {
-            return esp_partition_write(ota_data_partition, SPI_FLASH_SEC_SIZE * sec_id, &s_ota_select[sec_id].ota_seq, sizeof(ota_select));
-        }
-    } else {
+    if (two_otadata == NULL || sec_id > 1) {
         return ESP_ERR_INVALID_ARG;
     }
+
+    two_otadata[sec_id].ota_seq = seq;
+    two_otadata[sec_id].crc = bootloader_common_ota_select_crc(&two_otadata[sec_id]);
+    esp_err_t ret = esp_partition_erase_range(ota_data_partition, sec_id * SPI_FLASH_SEC_SIZE, SPI_FLASH_SEC_SIZE);
+    if (ret != ESP_OK) {
+        return ret;
+    } else {
+        return esp_partition_write(ota_data_partition, SPI_FLASH_SEC_SIZE * sec_id, &two_otadata[sec_id], sizeof(esp_ota_select_entry_t));
+    }
 }
 
 static uint8_t get_ota_partition_count(void)
@@ -286,119 +313,70 @@ static uint8_t get_ota_partition_count(void)
 
 static esp_err_t esp_rewrite_ota_data(esp_partition_subtype_t subtype)
 {
-    esp_err_t ret;
-    const esp_partition_t *find_partition = NULL;
-    uint16_t ota_app_count = 0;
-    uint32_t i = 0;
-    uint32_t seq;
-    spi_flash_mmap_handle_t ota_data_map;
-    const void *result = NULL;
-
-    find_partition = esp_partition_find_first(ESP_PARTITION_TYPE_DATA, ESP_PARTITION_SUBTYPE_DATA_OTA, NULL);
-    if (find_partition != NULL) {
-        ota_app_count = get_ota_partition_count();
-        //esp32_idf use two sector for store information about which partition is running
-        //it defined the two sector as ota data partition,two structure ota_select is saved in the two sector
-        //named data in first sector as s_ota_select[0], second sector data as s_ota_select[1]
-        //e.g.
-        //if s_ota_select[0].ota_seq == s_ota_select[1].ota_seq == 0xFFFFFFFF,means ota info partition is in init status
-        //so it will boot factory application(if there is),if there's no factory application,it will boot ota[0] application 
-        //if s_ota_select[0].ota_seq != 0 and s_ota_select[1].ota_seq != 0,it will choose a max seq ,and get value of max_seq%max_ota_app_number
-        //and boot a subtype (mask 0x0F) value is (max_seq - 1)%max_ota_app_number,so if want switch to run ota[x],can use next formulas.
-        //for example, if s_ota_select[0].ota_seq = 4, s_ota_select[1].ota_seq = 5, and there are 8 ota application, 
-        //current running is (5-1)%8 = 4,running ota[4],so if we want to switch to run ota[7],
-        //we should add s_ota_select[0].ota_seq (is 4) to 4 ,(8-1)%8=7,then it will boot ota[7]
-        //if      A=(B - C)%D
-        //then    B=(A + C)%D + D*n ,n= (0,1,2...)
-        //so current ota app sub type id is x , dest bin subtype is y,total ota app count is n
-        //seq will add (x + n*1 + 1 - seq)%n
-        if (SUB_TYPE_ID(subtype) >= ota_app_count) {
-            return ESP_ERR_INVALID_ARG;
-        }
-
-        ret = esp_partition_mmap(find_partition, 0, find_partition->size, SPI_FLASH_MMAP_DATA, &result, &ota_data_map);
-        if (ret != ESP_OK) {
-            result = NULL;
-            return ret;
-        } else {
-            memcpy(&s_ota_select[0], result, sizeof(ota_select));
-            memcpy(&s_ota_select[1], result + SPI_FLASH_SEC_SIZE, sizeof(ota_select));
-            spi_flash_munmap(ota_data_map);
-        }
-
-        if (ota_select_valid(&s_ota_select[0]) && ota_select_valid(&s_ota_select[1])) {
-            seq = OTA_MAX(s_ota_select[0].ota_seq, s_ota_select[1].ota_seq);
-            while (seq > (SUB_TYPE_ID(subtype) + 1) % ota_app_count + i * ota_app_count) {
-                i++;
-            }
-
-            if (s_ota_select[0].ota_seq >= s_ota_select[1].ota_seq) {
-                return rewrite_ota_seq((SUB_TYPE_ID(subtype) + 1) % ota_app_count + i * ota_app_count, 1, find_partition);
-            } else {
-                return rewrite_ota_seq((SUB_TYPE_ID(subtype) + 1) % ota_app_count + i * ota_app_count, 0, find_partition);
-            }
-
-        } else if (ota_select_valid(&s_ota_select[0])) {
-            while (s_ota_select[0].ota_seq > (SUB_TYPE_ID(subtype) + 1) % ota_app_count + i * ota_app_count) {
-                i++;
-            }
-            return rewrite_ota_seq((SUB_TYPE_ID(subtype) + 1) % ota_app_count + i * ota_app_count, 1, find_partition);
-
-        } else if (ota_select_valid(&s_ota_select[1])) {
-            while (s_ota_select[1].ota_seq > (SUB_TYPE_ID(subtype) + 1) % ota_app_count + i * ota_app_count) {
-                i++;
-            }
-            return rewrite_ota_seq((SUB_TYPE_ID(subtype) + 1) % ota_app_count + i * ota_app_count, 0, find_partition);
-
-        } else {
-            /* Both OTA slots are invalid, probably because unformatted... */
-            return rewrite_ota_seq(SUB_TYPE_ID(subtype) + 1, 0, find_partition);
-        }
-
-    } else {
+    esp_ota_select_entry_t otadata[2];
+    const esp_partition_t *otadata_partition = read_otadata(otadata);
+    if (otadata_partition == NULL) {
         return ESP_ERR_NOT_FOUND;
     }
+
+    int ota_app_count = get_ota_partition_count();
+    if (SUB_TYPE_ID(subtype) >= ota_app_count) {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    //esp32_idf use two sector for store information about which partition is running
+    //it defined the two sector as ota data partition,two structure esp_ota_select_entry_t is saved in the two sector
+    //named data in first sector as otadata[0], second sector data as otadata[1]
+    //e.g.
+    //if otadata[0].ota_seq == otadata[1].ota_seq == 0xFFFFFFFF,means ota info partition is in init status
+    //so it will boot factory application(if there is),if there's no factory application,it will boot ota[0] application
+    //if otadata[0].ota_seq != 0 and otadata[1].ota_seq != 0,it will choose a max seq ,and get value of max_seq%max_ota_app_number
+    //and boot a subtype (mask 0x0F) value is (max_seq - 1)%max_ota_app_number,so if want switch to run ota[x],can use next formulas.
+    //for example, if otadata[0].ota_seq = 4, otadata[1].ota_seq = 5, and there are 8 ota application,
+    //current running is (5-1)%8 = 4,running ota[4],so if we want to switch to run ota[7],
+    //we should add otadata[0].ota_seq (is 4) to 4 ,(8-1)%8=7,then it will boot ota[7]
+    //if      A=(B - C)%D
+    //then    B=(A + C)%D + D*n ,n= (0,1,2...)
+    //so current ota app sub type id is x , dest bin subtype is y,total ota app count is n
+    //seq will add (x + n*1 + 1 - seq)%n
+
+    int active_otadata = bootloader_common_get_active_otadata(otadata);
+    if (active_otadata != -1) {
+        uint32_t seq = otadata[active_otadata].ota_seq;
+        uint32_t i = 0;
+        while (seq > (SUB_TYPE_ID(subtype) + 1) % ota_app_count + i * ota_app_count) {
+            i++;
+        }
+        int next_otadata = (~active_otadata)&1; // if 0 -> will be next 1. and if 1 -> will be next 0.
+        return rewrite_ota_seq(otadata, (SUB_TYPE_ID(subtype) + 1) % ota_app_count + i * ota_app_count, next_otadata, otadata_partition);
+    } else {
+        /* Both OTA slots are invalid, probably because unformatted... */
+        int next_otadata = 0;
+        return rewrite_ota_seq(otadata, SUB_TYPE_ID(subtype) + 1, next_otadata, otadata_partition);
+    }
 }
 
 esp_err_t esp_ota_set_boot_partition(const esp_partition_t *partition)
 {
-    const esp_partition_t *find_partition = NULL;
     if (partition == NULL) {
         return ESP_ERR_INVALID_ARG;
     }
 
-    esp_image_metadata_t data;
-    const esp_partition_pos_t part_pos = {
-        .offset = partition->address,
-        .size = partition->size,
-    };
-    if (esp_image_verify(ESP_IMAGE_VERIFY, &part_pos, &data) != ESP_OK) {
+    if (image_validate(partition, ESP_IMAGE_VERIFY) != ESP_OK) {
         return ESP_ERR_OTA_VALIDATE_FAILED;
     }
 
-#ifdef CONFIG_SECURE_SIGNED_ON_UPDATE
-    esp_err_t ret = esp_secure_boot_verify_signature(partition->address, data.image_len);
-    if (ret != ESP_OK) {
-        return ESP_ERR_OTA_VALIDATE_FAILED;
-    }
-#endif
     // if set boot partition to factory bin ,just format ota info partition
     if (partition->type == ESP_PARTITION_TYPE_APP) {
         if (partition->subtype == ESP_PARTITION_SUBTYPE_APP_FACTORY) {
-            find_partition = esp_partition_find_first(ESP_PARTITION_TYPE_DATA, ESP_PARTITION_SUBTYPE_DATA_OTA, NULL);
+            const esp_partition_t *find_partition = esp_partition_find_first(ESP_PARTITION_TYPE_DATA, ESP_PARTITION_SUBTYPE_DATA_OTA, NULL);
             if (find_partition != NULL) {
                 return esp_partition_erase_range(find_partition, 0, find_partition->size);
             } else {
                 return ESP_ERR_NOT_FOUND;
             }
         } else {
-            // try to find this partition in flash,if not find it ,return error
-            find_partition = esp_partition_find_first(ESP_PARTITION_TYPE_DATA, ESP_PARTITION_SUBTYPE_DATA_OTA, NULL);
-            if (find_partition != NULL) {
-                return esp_rewrite_ota_data(partition->subtype);
-            } else {
-                return ESP_ERR_NOT_FOUND;
-            }
+            return esp_rewrite_ota_data(partition->subtype);
         }
     } else {
         return ESP_ERR_INVALID_ARG;
@@ -435,58 +413,30 @@ static const esp_partition_t *find_default_boot_partition(void)
 
 const esp_partition_t *esp_ota_get_boot_partition(void)
 {
-    esp_err_t ret;
-    const esp_partition_t *find_partition = NULL;
-    spi_flash_mmap_handle_t ota_data_map;
-    const void *result = NULL;
-    uint16_t ota_app_count = 0;
-    find_partition = esp_partition_find_first(ESP_PARTITION_TYPE_DATA, ESP_PARTITION_SUBTYPE_DATA_OTA, NULL);
-
-    if (find_partition == NULL) {
-        ESP_LOGE(TAG, "not found ota data");
+    esp_ota_select_entry_t otadata[2];
+    const esp_partition_t *otadata_partition = read_otadata(otadata);
+    if (otadata_partition == NULL) {
         return NULL;
     }
 
-    ret = esp_partition_mmap(find_partition, 0, find_partition->size, SPI_FLASH_MMAP_DATA, &result, &ota_data_map);
-    if (ret != ESP_OK) {
-        spi_flash_munmap(ota_data_map);
-        ESP_LOGE(TAG, "mmap ota data filed");
-        return NULL;
-    } else {
-        memcpy(&s_ota_select[0], result, sizeof(ota_select));
-        memcpy(&s_ota_select[1], result + 0x1000, sizeof(ota_select));
-        spi_flash_munmap(ota_data_map);
-    }
-    ota_app_count = get_ota_partition_count();
-
+    int ota_app_count = get_ota_partition_count();
     ESP_LOGD(TAG, "found ota app max = %d", ota_app_count);
 
-    if (s_ota_select[0].ota_seq == 0xFFFFFFFF && s_ota_select[1].ota_seq == 0xFFFFFFFF) {
-        ESP_LOGD(TAG, "finding factory app......");
+    if ((bootloader_common_ota_select_invalid(&otadata[0]) &&
+         bootloader_common_ota_select_invalid(&otadata[1])) ||
+         ota_app_count == 0) {
+        ESP_LOGD(TAG, "finding factory app...");
         return find_default_boot_partition();
-    } else if (ota_select_valid(&s_ota_select[0]) && ota_select_valid(&s_ota_select[1])) {
-        ESP_LOGD(TAG, "finding ota_%d app......", \
-                 ESP_PARTITION_SUBTYPE_APP_OTA_MIN + ((OTA_MAX(s_ota_select[0].ota_seq, s_ota_select[1].ota_seq) - 1) % ota_app_count));
-
-        return esp_partition_find_first(ESP_PARTITION_TYPE_APP, \
-                                        ESP_PARTITION_SUBTYPE_APP_OTA_MIN + ((OTA_MAX(s_ota_select[0].ota_seq, s_ota_select[1].ota_seq) - 1) % ota_app_count), NULL);
-    } else if (ota_select_valid(&s_ota_select[0])) {
-        ESP_LOGD(TAG, "finding ota_%d app......", \
-                 ESP_PARTITION_SUBTYPE_APP_OTA_MIN + (s_ota_select[0].ota_seq - 1) % ota_app_count);
-
-        return esp_partition_find_first(ESP_PARTITION_TYPE_APP, \
-                                        ESP_PARTITION_SUBTYPE_APP_OTA_MIN + (s_ota_select[0].ota_seq - 1) % ota_app_count, NULL);
-
-    } else if (ota_select_valid(&s_ota_select[1])) {
-        ESP_LOGD(TAG, "finding ota_%d app......", \
-                 ESP_PARTITION_SUBTYPE_APP_OTA_MIN + (s_ota_select[1].ota_seq - 1) % ota_app_count);
-
-        return esp_partition_find_first(ESP_PARTITION_TYPE_APP, \
-                                        ESP_PARTITION_SUBTYPE_APP_OTA_MIN + (s_ota_select[1].ota_seq - 1) % ota_app_count, NULL);
-
     } else {
-        ESP_LOGE(TAG, "ota data invalid, no current app. Assuming factory");
-        return find_default_boot_partition();
+        int active_otadata = bootloader_common_get_active_otadata(otadata);
+        if (active_otadata != -1) {
+            int ota_slot = (otadata[active_otadata].ota_seq - 1) % ota_app_count; // Actual OTA partition selection
+            ESP_LOGD(TAG, "finding ota_%d app...", ESP_PARTITION_SUBTYPE_APP_OTA_MIN + ota_slot);
+            return esp_partition_find_first(ESP_PARTITION_TYPE_APP, ESP_PARTITION_SUBTYPE_APP_OTA_MIN + ota_slot, NULL);
+        } else {
+            ESP_LOGE(TAG, "ota data invalid, no current app. Assuming factory");
+            return find_default_boot_partition();
+        }
     }
 }
 
@@ -575,3 +525,25 @@ const esp_partition_t* esp_ota_get_next_update_partition(const esp_partition_t *
     return default_ota;
 
 }
+
+esp_err_t esp_ota_get_partition_description(const esp_partition_t *partition, esp_app_desc_t *app_desc)
+{
+    if (partition == NULL || app_desc == NULL) {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    if(partition->type != ESP_PARTITION_TYPE_APP) {
+        return ESP_ERR_NOT_SUPPORTED;
+    }
+
+    esp_err_t err = esp_partition_read(partition, sizeof(esp_image_header_t) + sizeof(esp_image_segment_header_t), app_desc, sizeof(esp_app_desc_t));
+    if (err != ESP_OK) {
+        return err;
+    }
+
+    if (app_desc->magic_word != ESP_APP_DESC_MAGIC_WORD) {
+        return ESP_ERR_NOT_FOUND;
+    }
+
+    return ESP_OK;
+}

components/app_update/gen_empty_partition.py

@@ -1,82 +0,0 @@
-#!/usr/bin/env python
-#
-# generates an empty binary file
-# 
-# This tool generates an empty binary file of the required size.
-#
-# Copyright 2018 Espressif Systems (Shanghai) PTE LTD
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http:#www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-from __future__ import print_function, division
-from __future__ import unicode_literals
-import argparse
-import os
-import re
-import struct
-import sys
-import hashlib
-import binascii
-
-__version__ = '1.0'
-
-quiet = False
-
-def status(msg):
-    """ Print status message to stderr """
-    if not quiet:
-        critical(msg)
-
-def critical(msg):
-    """ Print critical message to stderr """
-    if not quiet:
-        sys.stderr.write(msg)
-        sys.stderr.write('\n')
-
-def generate_blanked_file(size, output_path):
-    output = b"\xFF" * size
-    try:
-        stdout_binary = sys.stdout.buffer  # Python 3
-    except AttributeError:
-        stdout_binary = sys.stdout
-    with stdout_binary if output_path == '-' else open(output_path, 'wb') as f:
-        f.write(output)
-
-def main():
-    global quiet
-    parser = argparse.ArgumentParser(description='Generates an empty binary file of the required size.')
-
-    parser.add_argument('--quiet', '-q', help="Don't print status messages to stderr", action='store_true')
-
-    parser.add_argument('--size', help='Size of generated the file',  type=str, required=True)
-    
-    parser.add_argument('output', help='Path for binary file.', nargs='?', default='-')
-    args = parser.parse_args()
-
-    quiet = args.quiet
-
-    size = int(args.size, 0)
-    if size > 0 :
-        generate_blanked_file(size, args.output)
-    return 0
-    
-class InputError(RuntimeError):
-    def __init__(self, e):
-        super(InputError, self).__init__(e)
-
-if __name__ == '__main__':
-    try:
-        r = main()
-        sys.exit(r)
-    except InputError as e:
-        print(e, file=sys.stderr)
-        sys.exit(2)

components/app_update/include/esp_ota_ops.h

@@ -20,6 +20,7 @@
 #include <stddef.h>
 #include "esp_err.h"
 #include "esp_partition.h"
+#include "esp_image_format.h"
 
 #ifdef __cplusplus
 extern "C"
@@ -41,6 +42,14 @@ extern "C"
  */
 typedef uint32_t esp_ota_handle_t;
 
+/**
+ * @brief   Return esp_app_desc structure. This structure includes app version.
+ * 
+ * Return description for running app.
+ * @return Pointer to esp_app_desc structure.
+ */
+const esp_app_desc_t *esp_ota_get_app_description(void);
+
 /**
  * @brief   Commence an OTA update writing to the specified partition.
 
@@ -170,6 +179,22 @@ const esp_partition_t* esp_ota_get_running_partition(void);
  */
 const esp_partition_t* esp_ota_get_next_update_partition(const esp_partition_t *start_from);
 
+/**
+ * @brief Returns esp_app_desc structure for app partition. This structure includes app version.
+ * 
+ * Returns a description for the requested app partition.
+ * @param[in] partition     Pointer to app partition. (only app partition)
+ * @param[out] app_desc     Structure of info about app.
+ * @return
+ *  - ESP_OK                Successful.
+ *  - ESP_ERR_NOT_FOUND     app_desc structure is not found. Magic word is incorrect.
+ *  - ESP_ERR_NOT_SUPPORTED Partition is not application.
+ *  - ESP_ERR_INVALID_ARG   Arguments is NULL or if partition's offset exceeds partition size.
+ *  - ESP_ERR_INVALID_SIZE  Read would go out of bounds of the partition.
+ *  - or one of error codes from lower-level flash driver.
+ */
+esp_err_t esp_ota_get_partition_description(const esp_partition_t *partition, esp_app_desc_t *app_desc);
+
 #ifdef __cplusplus
 }
 #endif

components/app_update/otatool.py

@@ -0,0 +1,327 @@
+#!/usr/bin/env python
+#
+# otatool is used to perform ota-level operations - flashing ota partition
+# erasing ota partition and switching ota partition
+#
+# Copyright 2018 Espressif Systems (Shanghai) PTE LTD
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http:#www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from __future__ import print_function, division
+import argparse
+import os
+import sys
+import binascii
+import subprocess
+import tempfile
+import collections
+import struct
+
+__version__ = '1.0'
+
+IDF_COMPONENTS_PATH = os.path.expandvars(os.path.join("$IDF_PATH", "components"))
+
+PARTTOOL_PY = os.path.join(IDF_COMPONENTS_PATH, "partition_table", "parttool.py")
+
+SPI_FLASH_SEC_SIZE = 0x2000
+
+quiet = False
+
+
+def status(msg):
+    if not quiet:
+        print(msg)
+
+
+def _invoke_parttool(parttool_args, args, output=False, partition=None):
+    invoke_args = []
+
+    if partition:
+        invoke_args += [sys.executable, PARTTOOL_PY] + partition
+    else:
+        invoke_args += [sys.executable, PARTTOOL_PY, "--partition-type", "data", "--partition-subtype", "ota"]
+
+    if quiet:
+        invoke_args += ["-q"]
+
+    if args.port != "":
+        invoke_args += ["--port", args.port]
+
+    if args.partition_table_file:
+        invoke_args += ["--partition-table-file", args.partition_table_file]
+
+    if args.partition_table_offset:
+        invoke_args += ["--partition-table-offset", args.partition_table_offset]
+
+    invoke_args += parttool_args
+
+    if output:
+        return subprocess.check_output(invoke_args)
+    else:
+        return subprocess.check_call(invoke_args)
+
+
+def _get_otadata_contents(args, check=True):
+    global quiet
+
+    if check:
+        check_args = ["get_partition_info", "--info", "offset", "size"]
+
+        quiet = True
+        output = _invoke_parttool(check_args, args, True).split(b" ")
+        quiet = args.quiet
+
+        if not output:
+            raise RuntimeError("No ota_data partition found")
+
+    with tempfile.NamedTemporaryFile() as otadata_file:
+        invoke_args = ["read_partition", "--output", otadata_file.name]
+        _invoke_parttool(invoke_args, args)
+        return otadata_file.read()
+
+
+def _get_otadata_status(otadata_contents):
+    status = []
+
+    otadata_status = collections.namedtuple("otadata_status", "seq crc")
+
+    for i in range(2):
+        start = i * (SPI_FLASH_SEC_SIZE >> 1)
+
+        seq = bytearray(otadata_contents[start:start + 4])
+        crc = bytearray(otadata_contents[start + 28:start + 32])
+
+        seq = struct.unpack('>I', seq)
+        crc = struct.unpack('>I', crc)
+
+        status.append(otadata_status(seq[0], crc[0]))
+
+    return status
+
+
+def read_otadata(args):
+    status("Reading ota_data partition contents...")
+    otadata_info = _get_otadata_contents(args)
+    otadata_info = _get_otadata_status(otadata_info)
+
+    print(otadata_info)
+
+    print("\t\t{:11}\t{:8s}|\t{:8s}\t{:8s}".format("OTA_SEQ", "CRC", "OTA_SEQ", "CRC"))
+    print("Firmware:  0x{:8x}  \t 0x{:8x} |\t0x{:8x} \t 0x{:8x}".format(otadata_info[0].seq, otadata_info[0].crc,
+                                                                        otadata_info[1].seq, otadata_info[1].crc))
+
+
+def erase_otadata(args):
+    status("Erasing ota_data partition contents...")
+    _invoke_parttool(["erase_partition"], args)
+    status("Erased ota_data partition contents")
+
+
+def switch_otadata(args):
+    sys.path.append(os.path.join(IDF_COMPONENTS_PATH, "partition_table"))
+    import gen_esp32part as gen
+
+    def is_otadata_status_valid(status):
+        seq = status.seq % (1 << 32)
+        crc = hex(binascii.crc32(struct.pack("I", seq), 0xFFFFFFFF) % (1 << 32))
+        return seq < (int('0xFFFFFFFF', 16) % (1 << 32)) and status.crc == crc
+
+    status("Looking for ota app partitions...")
+
+    # In order to get the number of ota app partitions, we need the partition table
+    partition_table = None
+
+    with tempfile.NamedTemporaryFile() as partition_table_file:
+        invoke_args = ["get_partition_info", "--table", partition_table_file.name]
+
+        _invoke_parttool(invoke_args, args)
+
+        partition_table = partition_table_file.read()
+        partition_table = gen.PartitionTable.from_binary(partition_table)
+
+    ota_partitions = list()
+
+    for i in range(gen.NUM_PARTITION_SUBTYPE_APP_OTA):
+        ota_partition = filter(lambda p: p.subtype == (gen.MIN_PARTITION_SUBTYPE_APP_OTA + i), partition_table)
+
+        try:
+            ota_partitions.append(list(ota_partition)[0])
+        except IndexError:
+            break
+
+    ota_partitions = sorted(ota_partitions, key=lambda p: p.subtype)
+
+    if not ota_partitions:
+        raise RuntimeError("No ota app partitions found")
+
+    status("Verifying partition to switch to exists...")
+
+    # Look for the app partition to switch to
+    ota_partition_next = None
+
+    try:
+        if args.name:
+            ota_partition_next = filter(lambda p: p.name == args.name, ota_partitions)
+        else:
+            ota_partition_next = filter(lambda p: p.subtype - gen.MIN_PARTITION_SUBTYPE_APP_OTA  == args.slot, ota_partitions)
+
+        ota_partition_next = list(ota_partition_next)[0]
+    except IndexError:
+        raise RuntimeError("Partition to switch to not found")
+
+    otadata_contents = _get_otadata_contents(args)
+    otadata_status = _get_otadata_status(otadata_contents)
+
+    # Find the copy to base the computation for ota sequence number on
+    otadata_compute_base = -1
+
+    # Both are valid, take the max as computation base
+    if is_otadata_status_valid(otadata_status[0]) and is_otadata_status_valid(otadata_status[1]):
+        if otadata_status[0].seq >= otadata_status[1].seq:
+            otadata_compute_base = 0
+        else:
+            otadata_compute_base = 1
+    # Only one copy is valid, use that
+    elif is_otadata_status_valid(otadata_status[0]):
+        otadata_compute_base = 0
+    elif is_otadata_status_valid(otadata_status[1]):
+        otadata_compute_base = 1
+    # Both are invalid (could be initial state - all 0xFF's)
+    else:
+        pass
+
+    ota_seq_next = 0
+    ota_partitions_num = len(ota_partitions)
+
+    target_seq = (ota_partition_next.subtype & 0x0F) + 1
+
+    # Find the next ota sequence number
+    if otadata_compute_base == 0 or otadata_compute_base == 1:
+        base_seq = otadata_status[otadata_compute_base].seq % (1 << 32)
+
+        i = 0
+        while base_seq > target_seq % ota_partitions_num + i * ota_partitions_num:
+            i += 1
+
+        ota_seq_next = target_seq % ota_partitions_num + i * ota_partitions_num
+    else:
+        ota_seq_next = target_seq
+
+    # Create binary data from computed values
+    ota_seq_next = struct.pack("I", ota_seq_next)
+    ota_seq_crc_next = binascii.crc32(ota_seq_next, 0xFFFFFFFF) % (1 << 32)
+    ota_seq_crc_next = struct.pack("I", ota_seq_crc_next)
+
+    with tempfile.NamedTemporaryFile() as otadata_next_file:
+        start = (1 if otadata_compute_base == 0 else 0) * (SPI_FLASH_SEC_SIZE >> 1)
+
+        otadata_next_file.write(otadata_contents)
+
+        otadata_next_file.seek(start)
+        otadata_next_file.write(ota_seq_next)
+
+        otadata_next_file.seek(start + 28)
+        otadata_next_file.write(ota_seq_crc_next)
+
+        otadata_next_file.flush()
+
+        _invoke_parttool(["write_partition", "--input", otadata_next_file.name], args)
+        status("Updated ota_data partition")
+
+
+def _get_partition_specifier(args):
+    if args.name:
+        return ["--partition-name", args.name]
+    else:
+        return ["--partition-type", "app", "--partition-subtype", "ota_" + str(args.slot)]
+
+
+def read_ota_partition(args):
+    invoke_args = ["read_partition", "--output", args.output]
+    _invoke_parttool(invoke_args, args, partition=_get_partition_specifier(args))
+    status("Read ota partition contents to file {}".format(args.output))
+
+
+def write_ota_partition(args):
+    invoke_args = ["write_partition", "--input", args.input]
+    _invoke_parttool(invoke_args, args, partition=_get_partition_specifier(args))
+    status("Written contents of file {} to ota partition".format(args.input))
+
+
+def erase_ota_partition(args):
+    invoke_args = ["erase_partition"]
+    _invoke_parttool(invoke_args, args, partition=_get_partition_specifier(args))
+    status("Erased contents of ota partition")
+
+
+def main():
+    global quiet
+
+    parser = argparse.ArgumentParser("ESP-IDF OTA Partitions Tool")
+
+    parser.add_argument("--quiet", "-q", help="suppress stderr messages", action="store_true")
+
+    # There are two possible sources for the partition table: a device attached to the host
+    # or a partition table CSV/binary file. These sources are mutually exclusive.
+    partition_table_info_source_args = parser.add_mutually_exclusive_group()
+
+    partition_table_info_source_args.add_argument("--port", "-p", help="port where the device to read the partition table from is attached", default="")
+    partition_table_info_source_args.add_argument("--partition-table-file", "-f", help="file (CSV/binary) to read the partition table from", default="")
+
+    parser.add_argument("--partition-table-offset", "-o", help="offset to read the partition table from", default="0x8000")
+
+    subparsers = parser.add_subparsers(dest="operation", help="run otatool -h for additional help")
+
+    # Specify the supported operations
+    subparsers.add_parser("read_otadata", help="read otadata partition")
+    subparsers.add_parser("erase_otadata", help="erase otadata partition")
+
+    slot_or_name_parser = argparse.ArgumentParser(add_help=False)
+    slot_or_name_parser_args = slot_or_name_parser.add_mutually_exclusive_group()
+    slot_or_name_parser_args.add_argument("--slot", help="slot number of the ota partition", type=int)
+    slot_or_name_parser_args.add_argument("--name", help="name of the ota partition")
+
+    subparsers.add_parser("switch_otadata", help="switch otadata partition", parents=[slot_or_name_parser])
+
+    read_ota_partition_subparser = subparsers.add_parser("read_ota_partition", help="read contents of an ota partition", parents=[slot_or_name_parser])
+    read_ota_partition_subparser.add_argument("--output", help="file to write the contents of the ota partition to")
+
+    write_ota_partition_subparser = subparsers.add_parser("write_ota_partition", help="write contents to an ota partition", parents=[slot_or_name_parser])
+    write_ota_partition_subparser.add_argument("--input", help="file whose contents to write to the ota partition")
+
+    subparsers.add_parser("erase_ota_partition", help="erase contents of an ota partition", parents=[slot_or_name_parser])
+
+    args = parser.parse_args()
+
+    quiet = args.quiet
+
+    # No operation specified, display help and exit
+    if args.operation is None:
+        if not quiet:
+            parser.print_help()
+        sys.exit(1)
+
+    # Else execute the operation
+    operation_func = globals()[args.operation]
+
+    if quiet:
+        # If exceptions occur, suppress and exit quietly
+        try:
+            operation_func(args)
+        except Exception:
+            sys.exit(2)
+    else:
+        operation_func(args)
+
+
+if __name__ == '__main__':
+    main()

components/app_update/project_include.cmake

@@ -3,6 +3,7 @@
 # partition table
 # (NB: because of component dependency, we know partition_table
 # project_include.cmake has already been included.)
-if(${OTADATA_PARTITION_OFFSET})
+
+if(OTADATA_PARTITION_OFFSET AND OTADATA_PARTITION_SIZE AND IDF_BUILD_ARTIFACTS)
     set(BLANK_OTADATA_FILE "ota_data_initial.bin")
 endif()

components/app_update/test/CMakeLists.txt

@@ -1,6 +1,6 @@
 set(COMPONENT_SRCDIRS ".")
 set(COMPONENT_ADD_INCLUDEDIRS ".")
 
-set(COMPONENT_REQUIRES unity app_update bootloader_support nvs_flash)
+set(COMPONENT_REQUIRES unity test_utils app_update bootloader_support nvs_flash)
 
 register_component()

components/app_update/test/test_ota_ops.c

@@ -8,7 +8,7 @@
 #include <unity.h>
 #include <test_utils.h>
 #include <esp_ota_ops.h>
-
+#include "bootloader_common.h"
 
 /* These OTA tests currently don't assume an OTA partition exists
    on the device, so they're a bit limited
@@ -84,3 +84,26 @@ TEST_CASE("esp_ota_get_next_update_partition logic", "[ota]")
     TEST_ASSERT_EQUAL_PTR(ota_0, p);
 }
 
+TEST_CASE("esp_ota_get_partition_description ", "[ota]")
+{
+    const esp_partition_t *running = esp_ota_get_running_partition();
+    TEST_ASSERT_NOT_NULL(running);
+    esp_app_desc_t app_desc1, app_desc2;
+    TEST_ESP_OK(esp_ota_get_partition_description(running, &app_desc1));
+    const esp_partition_pos_t running_pos = {
+            .offset = running->address,
+            .size = running->size
+    };
+    TEST_ESP_OK(bootloader_common_get_partition_description(&running_pos, &app_desc2));
+
+    TEST_ASSERT_EQUAL_MEMORY_MESSAGE((uint8_t *)&app_desc1, (uint8_t *)&app_desc2, sizeof(app_desc1), "must be the same");
+
+    const esp_partition_t *not_app = esp_partition_find_first(ESP_PARTITION_TYPE_DATA, ESP_PARTITION_SUBTYPE_DATA_OTA, NULL);
+    TEST_ASSERT_NOT_NULL(not_app);
+    TEST_ESP_ERR(ESP_ERR_NOT_SUPPORTED, esp_ota_get_partition_description(not_app, &app_desc1));
+    const esp_partition_pos_t not_app_pos = {
+            .offset = not_app->address,
+            .size = not_app->size
+    };
+    TEST_ESP_ERR(ESP_ERR_NOT_FOUND, bootloader_common_get_partition_description(&not_app_pos, &app_desc1));
+}

components/aws_iot/port/network_mbedtls_wrapper.c

@@ -236,6 +236,7 @@ IoT_Error_t iot_tls_connect(Network *pNetwork, TLSConnectParams *params) {
 
     mbedtls_ssl_conf_read_timeout(&(tlsDataParams->conf), pNetwork->tlsConnectParams.timeout_ms);
 
+#ifdef CONFIG_MBEDTLS_SSL_ALPN
     /* Use the AWS IoT ALPN extension for MQTT, if port 443 is requested */
     if (pNetwork->tlsConnectParams.DestinationPort == 443) {
         const char *alpnProtocols[] = { "x-amzn-mqtt-ca", NULL };
@@ -244,6 +245,7 @@ IoT_Error_t iot_tls_connect(Network *pNetwork, TLSConnectParams *params) {
             return SSL_CONNECTION_ERROR;
         }
     }
+#endif
 
     if((ret = mbedtls_ssl_setup(&(tlsDataParams->ssl), &(tlsDataParams->conf))) != 0) {
         ESP_LOGE(TAG, "failed! mbedtls_ssl_setup returned -0x%x", -ret);

components/bootloader/project_include.cmake

@@ -1,28 +1,66 @@
+# This is for tracking the top level project path
 if(BOOTLOADER_BUILD)
-    return()  # don't keep recursing!
+    set(main_project_path "${CMAKE_BINARY_DIR}/../..")
+else()
+    set(main_project_path "${IDF_PROJECT_PATH}")
+endif()
+
+get_filename_component(secure_boot_signing_key
+    "${CONFIG_SECURE_BOOT_SIGNING_KEY}"
+    ABSOLUTE BASE_DIR "${main_project_path}")
+if(NOT EXISTS ${secure_boot_signing_key})
+    # If the signing key is not found, create a phony gen_secure_boot_signing_key target that
+    # fails the build. fail_at_build_time also touches CMakeCache.txt to cause a cmake run next time
+    # (to pick up a new signing key if one exists, etc.)
+    fail_at_build_time(gen_secure_boot_signing_key
+        "Secure Boot Signing Key ${CONFIG_SECURE_BOOT_SIGNING_KEY} does not exist. Generate using:"
+        "\tespsecure.py generate_signing_key ${CONFIG_SECURE_BOOT_SIGNING_KEY}")
+else()
+    add_custom_target(gen_secure_boot_signing_key)
+endif()
+
+if(BOOTLOADER_BUILD OR NOT IDF_BUILD_ARTIFACTS)
+    return()  # don't keep recursing, generate on project builds
 endif()
 
 # Glue to build the bootloader subproject binary as an external
 # cmake project under this one
 #
 #
-set(bootloader_build_dir "${CMAKE_BINARY_DIR}/bootloader")
+set(bootloader_build_dir "${IDF_BUILD_ARTIFACTS_DIR}/bootloader")
 set(bootloader_binary_files
     "${bootloader_build_dir}/bootloader.elf"
     "${bootloader_build_dir}/bootloader.bin"
     "${bootloader_build_dir}/bootloader.map"
     )
 
-externalproject_add(bootloader
-    # TODO: support overriding the bootloader in COMPONENT_PATHS
-    SOURCE_DIR "${CMAKE_CURRENT_LIST_DIR}/subproject"
-    BINARY_DIR "${bootloader_build_dir}"
-    CMAKE_ARGS  -DSDKCONFIG=${SDKCONFIG} -DIDF_PATH=${IDF_PATH}
-                -DEXTRA_COMPONENT_DIRS=${CMAKE_CURRENT_LIST_DIR}
-    INSTALL_COMMAND ""
-    BUILD_ALWAYS 1  # no easy way around this...
-    BUILD_BYPRODUCTS ${bootloader_binary_files}
-    )
+# These additional files may get generated
+if(CONFIG_SECURE_BOOTLOADER_REFLASHABLE)
+    set(bootloader_binary_files
+        ${bootloader_binary_files}
+        "${bootloader_build_dir}/bootloader-reflash-digest.bin"
+        "${bootloader_build_dir}/secure-bootloader-key-192.bin"
+        "${bootloader_build_dir}/secure-bootloader-key-256.bin"
+        )
+endif()
+
+if((NOT CONFIG_SECURE_BOOT_ENABLED) OR
+    CONFIG_SECURE_BOOTLOADER_REFLASHABLE OR
+    CONFIG_SECURE_BOOTLOADER_ONE_TIME_FLASH)
+    externalproject_add(bootloader
+        # TODO: support overriding the bootloader in COMPONENT_PATHS
+        SOURCE_DIR "${IDF_PATH}/components/bootloader/subproject"
+        BINARY_DIR "${bootloader_build_dir}"
+        CMAKE_ARGS  -DSDKCONFIG=${SDKCONFIG} -DIDF_PATH=${IDF_PATH}
+                    -DSECURE_BOOT_SIGNING_KEY=${secure_boot_signing_key}
+        INSTALL_COMMAND ""
+        BUILD_ALWAYS 1  # no easy way around this...
+        BUILD_BYPRODUCTS ${bootloader_binary_files}
+        DEPENDS gen_secure_boot_signing_key
+        )
+else()
+    fail_at_build_time(bootloader "Invalid bootloader target: bad sdkconfig?")
+endif()
 
 # this is a hack due to an (annoying) shortcoming in cmake, it can't
 # extend the 'clean' target to the external project

components/bootloader/subproject/CMakeLists.txt

@@ -21,8 +21,117 @@ project(bootloader)
 
 target_linker_script(bootloader.elf
     "main/esp32.bootloader.ld"
-    "main/esp32.bootloader.rom.ld")
-# Imported from esp32 component
+    "main/esp32.bootloader.rom.ld"
+)
+
+# as cmake won't attach linker args to a header-only library, attach
+# linker args directly to the bootloader.elf
+set(ESP32_BOOTLOADER_LINKER_SCRIPTS
+    "../../esp32/ld/esp32.rom.ld"
+    "../../esp32/ld/esp32.rom.spiram_incompatible_fns.ld"
+    "../../esp32/ld/esp32.peripherals.ld")
+
 target_linker_script(bootloader.elf ${ESP32_BOOTLOADER_LINKER_SCRIPTS})
 
 target_link_libraries(bootloader.elf gcc)
+
+set(secure_boot_signing_key ${SECURE_BOOT_SIGNING_KEY})
+
+string(REPLACE ";" " " espsecurepy "${ESPSECUREPY}")
+string(REPLACE ";" " " espefusepy "${ESPEFUSEPY}")
+set(esptoolpy_write_flash "${ESPTOOLPY_WRITE_FLASH_STR}")
+
+if(CONFIG_SECURE_BOOTLOADER_REFLASHABLE)
+    if(CONFIG_SECURE_BOOTLOADER_KEY_ENCODING_192BIT)
+        set(key_digest_len 192)
+    else()
+        set(key_digest_len 256)
+    endif()
+
+    get_filename_component(bootloader_digest_bin
+        "bootloader-reflash-digest.bin"
+        ABSOLUTE BASE_DIR "${CMAKE_BINARY_DIR}")
+
+    get_filename_component(secure_bootloader_key
+        "secure-bootloader-key-${key_digest_len}.bin"
+        ABSOLUTE BASE_DIR "${CMAKE_BINARY_DIR}")
+
+    add_custom_command(OUTPUT "${secure_bootloader_key}"
+        COMMAND ${ESPSECUREPY} digest_private_key
+            --keylen "${key_digest_len}"
+            --keyfile "${secure_boot_signing_key}"
+            "${secure_bootloader_key}"
+        VERBATIM)
+
+    if(CONFIG_SECURE_BOOT_BUILD_SIGNED_BINARIES)
+        add_custom_target(gen_secure_bootloader_key ALL DEPENDS "${secure_bootloader_key}")
+    else()
+        if(NOT EXISTS "${secure_bootloader_key}")
+            message(FATAL_ERROR
+                "No pre-generated key for a reflashable secure bootloader is available, "
+                "due to signing configuration."
+                "\nTo generate one, you can use this command:"
+                "\n\t${espsecurepy} generate_flash_encryption_key ${secure_bootloader_key}"
+                "\nIf a signing key is present, then instead use:"
+                "\n\t${ESPSECUREPY} digest_private_key "
+                "--keylen (192/256) --keyfile KEYFILE "
+                "${secure_bootloader_key}")
+        endif()
+        add_custom_target(gen_secure_bootloader_key)
+    endif()
+
+    add_custom_command(OUTPUT "${bootloader_digest_bin}"
+        COMMAND ${CMAKE_COMMAND} -E echo "DIGEST ${bootloader_digest_bin}"
+        COMMAND ${ESPSECUREPY} digest_secure_bootloader --keyfile "${secure_bootloader_key}"
+            -o "${bootloader_digest_bin}" "${CMAKE_BINARY_DIR}/bootloader.bin"
+        DEPENDS gen_secure_bootloader_key "${CMAKE_BINARY_DIR}/bootloader.bin"
+        VERBATIM)
+
+    add_custom_target (gen_bootloader_digest_bin ALL DEPENDS "${bootloader_digest_bin}")
+endif()
+
+if(CONFIG_SECURE_BOOTLOADER_ONE_TIME_FLASH)
+    add_custom_command(TARGET bootloader POST_BUILD
+        COMMAND ${CMAKE_COMMAND} -E echo
+            "=============================================================================="
+        COMMAND ${CMAKE_COMMAND} -E echo
+            "Bootloader built. Secure boot enabled, so bootloader not flashed automatically."
+        COMMAND ${CMAKE_COMMAND} -E echo
+            "One-time flash command is:"
+        COMMAND ${CMAKE_COMMAND} -E echo
+            "\t${esptoolpy_write_flash} ${BOOTLOADER_OFFSET} ${CMAKE_BINARY_DIR}/bootloader.bin"
+        COMMAND ${CMAKE_COMMAND} -E echo
+            "* IMPORTANT: After first boot, BOOTLOADER CANNOT BE RE-FLASHED on same device"
+        VERBATIM)
+
+elseif(CONFIG_SECURE_BOOTLOADER_REFLASHABLE)
+    add_custom_command(TARGET bootloader POST_BUILD
+        COMMAND ${CMAKE_COMMAND} -E echo
+            "=============================================================================="
+        COMMAND ${CMAKE_COMMAND} -E echo
+            "Bootloader built and secure digest generated."
+        COMMAND ${CMAKE_COMMAND} -E echo
+            "Secure boot enabled, so bootloader not flashed automatically."
+        COMMAND ${CMAKE_COMMAND} -E echo
+            "Burn secure boot key to efuse using:"
+        COMMAND ${CMAKE_COMMAND} -E echo
+            "\t${espefusepy} burn_key secure_boot ${secure_bootloader_key}"
+        COMMAND ${CMAKE_COMMAND} -E echo
+            "First time flash command is:"
+        COMMAND ${CMAKE_COMMAND} -E echo
+            "\t${esptoolpy_write_flash} ${BOOTLOADER_OFFSET} ${CMAKE_BINARY_DIR}/bootloader.bin"
+        COMMAND ${CMAKE_COMMAND} -E echo
+            "=============================================================================="
+        COMMAND ${CMAKE_COMMAND} -E echo
+            "To reflash the bootloader after initial flash:"
+        COMMAND ${CMAKE_COMMAND} -E echo
+            "\t${esptoolpy_write_flash} 0x0 ${bootloader_digest_bin}"
+        COMMAND ${CMAKE_COMMAND} -E echo
+            "=============================================================================="
+        COMMAND ${CMAKE_COMMAND} -E echo
+            "* After first boot, only re-flashes of this kind (with same key) will be accepted."
+        COMMAND ${CMAKE_COMMAND} -E echo
+            "* Not recommended to re-use the same secure boot keyfile on multiple production devices."
+        DEPENDS gen_secure_bootloader_key gen_bootloader_digest_bin
+        VERBATIM)
+endif()

components/bootloader_support/CMakeLists.txt

@@ -17,6 +17,40 @@ if(${BOOTLOADER_BUILD})
     set(COMPONENT_REQUIRES)
     set(COMPONENT_PRIV_REQUIRES spi_flash micro-ecc)
     list(APPEND COMPONENT_SRCS "src/bootloader_init.c")
+
+    if(CONFIG_SECURE_SIGNED_APPS)
+        get_filename_component(secure_boot_verification_key
+            "signature_verification_key.bin"
+            ABSOLUTE BASE_DIR "${CMAKE_BINARY_DIR}")
+        if(CONFIG_SECURE_BOOT_BUILD_SIGNED_BINARIES)
+            add_custom_command(OUTPUT "${secure_boot_verification_key}"
+                COMMAND ${ESPSECUREPY}
+                    extract_public_key --keyfile "${secure_boot_signing_key}"
+                    "${secure_boot_verification_key}"
+                DEPENDS gen_secure_boot_signing_key
+                VERBATIM)
+        else()
+            get_filename_component(orig_secure_boot_verification_key
+                "${CONFIG_SECURE_BOOT_VERIFICATION_KEY}"
+                ABSOLUTE BASE_DIR "${main_project_path}")
+            if(NOT EXISTS ${orig_secure_boot_verification_key})
+                message(FATAL_ERROR
+                    "Secure Boot Verification Public Key ${CONFIG_SECURE_BOOT_VERIFICATION_KEY} does not exist."
+                    "\nThis can be extracted from the private signing key."
+                    "\nSee docs/security/secure-boot.rst for details.")
+            endif()
+
+            add_custom_command(OUTPUT "${secure_boot_verification_key}"
+                COMMAND ${CMAKE_COMMAND} -E copy "${orig_secure_boot_verification_key}"
+                    "${secure_boot_verification_key}"
+                DEPENDS "${orig_secure_boot_verification_key}"
+                VERBATIM)
+        endif()
+        set(COMPONENT_EMBED_FILES "${secure_boot_verification_key}")
+        set_property(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+            APPEND PROPERTY ADDITIONAL_MAKE_CLEAN_FILES
+            "${secure_boot_verification_key}")
+    endif()
 else()
     set(COMPONENT_ADD_INCLUDEDIRS "include")
     set(COMPONENT_PRIV_INCLUDEDIRS "include_bootloader")

components/bootloader_support/include/bootloader_common.h

@@ -14,6 +14,7 @@
 
 #pragma once
 #include "esp_flash_data_types.h"
+#include "esp_image_format.h"
 
 /// Type of hold a GPIO in low state
 typedef enum {
@@ -23,21 +24,29 @@ typedef enum {
 } esp_comm_gpio_hold_t;
 
 /**
- * @brief Calculate crc for the OTA data partition.
+ * @brief Calculate crc for the OTA data select.
  *
- * @param[in] ota_data The OTA data partition.
+ * @param[in] s The OTA data select.
  * @return    Returns crc value.
  */
 uint32_t bootloader_common_ota_select_crc(const esp_ota_select_entry_t *s);
 
 /**
- * @brief Verifies the validity of the OTA data partition
+ * @brief Verifies the validity of the OTA data select
  *
- * @param[in] ota_data The OTA data partition.
+ * @param[in] s The OTA data select.
  * @return    Returns true on valid, false otherwise.
  */
 bool bootloader_common_ota_select_valid(const esp_ota_select_entry_t *s);
 
+/**
+ * @brief Returns true if OTADATA is not marked as bootable partition.
+ *
+ * @param[in] s The OTA data select.
+ * @return    Returns true if OTADATA invalid, false otherwise.
+ */
+bool bootloader_common_ota_select_invalid(const esp_ota_select_entry_t *s);
+
 /**
  * @brief Check if the GPIO input is a long hold or a short hold.
  *
@@ -91,3 +100,27 @@ bool bootloader_common_label_search(const char *list, char *label);
  *          - ESP_FAIL: An allocation error occurred.
  */
 esp_err_t bootloader_common_get_sha256_of_partition(uint32_t address, uint32_t size, int type, uint8_t *out_sha_256);
+
+/**
+ * @brief Returns the number of active otadata.
+ *
+ * @param[in] two_otadata Pointer on array from two otadata structures.
+ *
+ * @return The number of active otadata (0 or 1).
+ *        - -1: If it does not have active otadata.
+ */
+int bootloader_common_get_active_otadata(esp_ota_select_entry_t *two_otadata);
+
+/**
+ * @brief Returns esp_app_desc structure for app partition. This structure includes app version.
+ * 
+ * Returns a description for the requested app partition.
+ * @param[in] partition      App partition description.
+ * @param[out] app_desc      Structure of info about app.
+ * @return
+ *  - ESP_OK:                Successful.
+ *  - ESP_ERR_INVALID_ARG:   The arguments passed are not valid.
+ *  - ESP_ERR_NOT_FOUND:     app_desc structure is not found. Magic word is incorrect.
+ *  - ESP_FAIL:              mapping is fail.
+ */
+esp_err_t bootloader_common_get_partition_description(const esp_partition_pos_t *partition, esp_app_desc_t *app_desc);

components/bootloader_support/include/esp_image_format.h

@@ -89,6 +89,25 @@ typedef struct {
     uint32_t data_len;
 } esp_image_segment_header_t;
 
+#define ESP_APP_DESC_MAGIC_WORD 0xABCD5432 /*!< The magic word for the esp_app_desc structure that is in DROM. */
+
+/**
+ * @brief Description about application.
+ */
+typedef struct {
+    uint32_t magic_word;        /*!< Magic word ESP_APP_DESC_MAGIC_WORD */
+    uint32_t secure_version;    /*!< Secure version */
+    uint32_t reserv1[2];        /*!< --- */
+    char version[32];           /*!< Application version */
+    char project_name[32];      /*!< Project name */
+    char time[16];              /*!< Compile time */
+    char date[16];              /*!< Compile date*/
+    char idf_ver[32];           /*!< Version IDF */
+    uint8_t app_elf_sha256[32]; /*!< sha256 of elf file */
+    uint32_t reserv2[20];       /*!< --- */
+} esp_app_desc_t;
+_Static_assert(sizeof(esp_app_desc_t) == 256, "esp_app_desc_t should be 256 bytes");
+
 #define ESP_IMAGE_MAX_SEGMENTS 16
 
 /* Structure to hold on-flash image metadata */

components/bootloader_support/include_bootloader/bootloader_flash.h

@@ -111,21 +111,4 @@ esp_err_t bootloader_flash_erase_sector(size_t sector);
  */
 esp_err_t bootloader_flash_erase_range(uint32_t start_addr, uint32_t size);
 
-/* Cache MMU block size */
-#define MMU_BLOCK_SIZE    0x00010000
-
-/* Cache MMU address mask (MMU tables ignore bits which are zero) */
-#define MMU_FLASH_MASK    (~(MMU_BLOCK_SIZE - 1))
-
-/**
- * @brief Calculate the number of cache pages to map
- * @param size  size of data to map
- * @param vaddr  virtual address where data will be mapped
- * @return number of cache MMU pages required to do the mapping
- */
-static inline uint32_t bootloader_cache_pages_to_map(uint32_t size, uint32_t vaddr)
-{
-    return (size + (vaddr - (vaddr & MMU_FLASH_MASK)) + MMU_BLOCK_SIZE - 1) / MMU_BLOCK_SIZE;
-}
-
 #endif

components/bootloader_support/src/bootloader_clock.c

@@ -31,14 +31,14 @@ void bootloader_clock_configure()
     /* Set CPU to 80MHz. Keep other clocks unmodified. */
     int cpu_freq_mhz = 80;
 
-    /* On ESP32 rev 0, switching to 80/160 MHz if clock was previously set to
+    /* On ESP32 rev 0, switching to 80MHz if clock was previously set to
      * 240 MHz may cause the chip to lock up (see section 3.5 of the errata
-     * document). For rev. 0, switch to 240 instead if it has been enabled
-     * previously.
+     * document). For rev. 0, switch to 240 instead if it was chosen in
+     * menuconfig.
      */
     uint32_t chip_ver_reg = REG_READ(EFUSE_BLK0_RDATA3_REG);
     if ((chip_ver_reg & EFUSE_RD_CHIP_VER_REV1_M) == 0 &&
-            DPORT_REG_GET_FIELD(DPORT_CPU_PER_CONF_REG, DPORT_CPUPERIOD_SEL) == DPORT_CPUPERIOD_SEL_240) {
+            CONFIG_ESP32_DEFAULT_CPU_FREQ_MHZ == 240) {
         cpu_freq_mhz = 240;
     }
 

components/bootloader_support/src/bootloader_common.c

@@ -29,6 +29,7 @@
 #include "soc/gpio_periph.h"
 #include "esp_image_format.h"
 #include "bootloader_sha.h"
+#include "sys/param.h"
 
 #define ESP_PARTITION_HASH_LEN 32 /* SHA-256 digest length */
 
@@ -39,9 +40,14 @@ uint32_t bootloader_common_ota_select_crc(const esp_ota_select_entry_t *s)
     return crc32_le(UINT32_MAX, (uint8_t*)&s->ota_seq, 4);
 }
 
+bool bootloader_common_ota_select_invalid(const esp_ota_select_entry_t *s)
+{
+    return s->ota_seq == UINT32_MAX;
+}
+
 bool bootloader_common_ota_select_valid(const esp_ota_select_entry_t *s)
 {
-    return s->ota_seq != UINT32_MAX && s->crc == bootloader_common_ota_select_crc(s);
+    return bootloader_common_ota_select_invalid(s) == false && s->crc == bootloader_common_ota_select_crc(s);
 }
 
 esp_comm_gpio_hold_t bootloader_common_check_long_hold_gpio(uint32_t num_pin, uint32_t delay_sec)
@@ -192,3 +198,51 @@ esp_err_t bootloader_common_get_sha256_of_partition (uint32_t address, uint32_t
 
     return ESP_OK;
 }
+
+int bootloader_common_get_active_otadata(esp_ota_select_entry_t *two_otadata)
+{
+    int active_otadata = -1;
+
+    bool valid_otadata[2];
+    valid_otadata[0] = bootloader_common_ota_select_valid(&two_otadata[0]);
+    valid_otadata[1] = bootloader_common_ota_select_valid(&two_otadata[1]);
+    if (valid_otadata[0] && valid_otadata[1]) {
+        if (MAX(two_otadata[0].ota_seq, two_otadata[1].ota_seq) == two_otadata[0].ota_seq) {
+            active_otadata = 0;
+        } else {
+            active_otadata = 1;
+        }
+        ESP_LOGD(TAG, "Both OTA copies are valid");
+    } else {
+        for (int i = 0; i < 2; ++i) {
+            if (valid_otadata[i]) {
+                active_otadata = i;
+                ESP_LOGD(TAG, "Only otadata[%d] is valid", i);
+                break;
+            }
+        }
+    }
+    return active_otadata;
+}
+
+esp_err_t bootloader_common_get_partition_description(const esp_partition_pos_t *partition, esp_app_desc_t *app_desc)
+{
+    if (partition == NULL || app_desc == NULL || partition->offset == 0) {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    const uint8_t *image = bootloader_mmap(partition->offset, partition->size);
+    if (image == NULL) {
+        ESP_LOGE(TAG, "bootloader_mmap(0x%x, 0x%x) failed", partition->offset, partition->size);
+        return ESP_FAIL;
+    }
+
+    memcpy(app_desc, image + sizeof(esp_image_header_t) + sizeof(esp_image_segment_header_t), sizeof(esp_app_desc_t));
+    bootloader_munmap(image);
+
+    if (app_desc->magic_word != ESP_APP_DESC_MAGIC_WORD) {
+        return ESP_ERR_NOT_FOUND;
+    }
+
+    return ESP_OK;
+}

components/bootloader_support/src/bootloader_flash.c

@@ -91,6 +91,8 @@ static const char *TAG = "bootloader_flash";
 */
 #define MMU_BLOCK0_VADDR  0x3f400000
 #define MMU_BLOCK50_VADDR 0x3f720000
+#define MMU_FLASH_MASK    0xffff0000
+#define MMU_BLOCK_SIZE    0x00010000
 
 static bool mapped;
 
@@ -110,11 +112,10 @@ const void *bootloader_mmap(uint32_t src_addr, uint32_t size)
     }
 
     uint32_t src_addr_aligned = src_addr & MMU_FLASH_MASK;
-    uint32_t count = bootloader_cache_pages_to_map(size, src_addr);
+    uint32_t count = (size + (src_addr - src_addr_aligned) + 0xffff) / MMU_BLOCK_SIZE;
     Cache_Read_Disable(0);
     Cache_Flush(0);
-    ESP_LOGD(TAG, "mmu set paddr=%08x count=%d size=%x src_addr=%x src_addr_aligned=%x",
-            src_addr & MMU_FLASH_MASK, count, size, src_addr, src_addr_aligned );
+    ESP_LOGD(TAG, "mmu set paddr=%08x count=%d", src_addr_aligned, count );
     int e = cache_flash_mmu_set(0, 0, MMU_BLOCK0_VADDR, src_addr_aligned, 64, count);
     if (e != 0) {
         ESP_LOGE(TAG, "cache_flash_mmu_set failed: %d\n", e);

components/bootloader_support/src/bootloader_init.c

@@ -33,10 +33,12 @@
 #include "soc/cpu.h"
 #include "soc/rtc.h"
 #include "soc/dport_reg.h"
+#include "soc/io_mux_reg.h"
 #include "soc/efuse_reg.h"
 #include "soc/rtc_cntl_reg.h"
 #include "soc/timer_group_reg.h"
-#include "soc/gpio_periph.h"
+#include "soc/gpio_reg.h"
+#include "soc/gpio_sig_map.h"
 #include "soc/rtc_wdt.h"
 
 #include "sdkconfig.h"
@@ -440,18 +442,10 @@ static void uart_console_configure(void)
         // (arrays should be optimized away by the compiler)
         const uint32_t tx_idx_list[3] = { U0TXD_OUT_IDX, U1TXD_OUT_IDX, U2TXD_OUT_IDX };
         const uint32_t rx_idx_list[3] = { U0RXD_IN_IDX, U1RXD_IN_IDX, U2RXD_IN_IDX };
-        const uint32_t uart_reset[3] = { DPORT_UART_RST, DPORT_UART1_RST, DPORT_UART2_RST };
         const uint32_t tx_idx = tx_idx_list[uart_num];
         const uint32_t rx_idx = rx_idx_list[uart_num];
-
-        PIN_INPUT_ENABLE(GPIO_PIN_MUX_REG[uart_rx_gpio]);
-        gpio_pad_pullup(uart_rx_gpio);
-
         gpio_matrix_out(uart_tx_gpio, tx_idx, 0, 0);
         gpio_matrix_in(uart_rx_gpio, rx_idx, 0);
-
-        DPORT_SET_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, uart_reset[uart_num]);
-        DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, uart_reset[uart_num]);
     }
 #endif // CONFIG_CONSOLE_UART_CUSTOM
 

components/bootloader_support/src/bootloader_utility.c

@@ -67,6 +67,34 @@ static void set_cache_and_start_app(uint32_t drom_addr,
     uint32_t irom_size,
     uint32_t entry_addr);
 
+// Read ota_info partition and fill array from two otadata structures.
+static esp_err_t read_otadata(const esp_partition_pos_t *ota_info, esp_ota_select_entry_t *two_otadata)
+{
+    const esp_ota_select_entry_t *ota_select_map;
+    if (ota_info->offset == 0) {
+        return ESP_ERR_NOT_FOUND;
+    }
+
+    // partition table has OTA data partition
+    if (ota_info->size < 2 * SPI_SEC_SIZE) {
+        ESP_LOGE(TAG, "ota_info partition size %d is too small (minimum %d bytes)", ota_info->size, sizeof(esp_ota_select_entry_t));
+        return ESP_FAIL; // can't proceed
+    }
+
+    ESP_LOGD(TAG, "OTA data offset 0x%x", ota_info->offset);
+    ota_select_map = bootloader_mmap(ota_info->offset, ota_info->size);
+    if (!ota_select_map) {
+        ESP_LOGE(TAG, "bootloader_mmap(0x%x, 0x%x) failed", ota_info->offset, ota_info->size);
+        return ESP_FAIL; // can't proceed
+    }
+
+    memcpy(&two_otadata[0], ota_select_map, sizeof(esp_ota_select_entry_t));
+    memcpy(&two_otadata[1], (uint8_t *)ota_select_map + SPI_SEC_SIZE, sizeof(esp_ota_select_entry_t));
+    bootloader_munmap(ota_select_map);
+
+    return ESP_OK;
+}
+
 bool bootloader_utility_load_partition_table(bootloader_state_t* bs)
 {
     const esp_partition_info_t *partitions;
@@ -194,71 +222,48 @@ static void log_invalid_app_partition(int index)
 
 int bootloader_utility_get_selected_boot_partition(const bootloader_state_t *bs)
 {
-    esp_ota_select_entry_t sa,sb;
-    const esp_ota_select_entry_t *ota_select_map;
+    esp_ota_select_entry_t otadata[2];
+    int boot_index = FACTORY_INDEX;
 
-    if (bs->ota_info.offset != 0) {
-        // partition table has OTA data partition
-        if (bs->ota_info.size < 2 * SPI_SEC_SIZE) {
-            ESP_LOGE(TAG, "ota_info partition size %d is too small (minimum %d bytes)", bs->ota_info.size, sizeof(esp_ota_select_entry_t));
-            return INVALID_INDEX; // can't proceed
+    if (bs->ota_info.offset == 0) {
+        return FACTORY_INDEX;
+    }
+
+    if (read_otadata(&bs->ota_info, otadata) != ESP_OK) {
+        return INVALID_INDEX;
+    }
+
+    ESP_LOGD(TAG, "otadata[0]: sequence values 0x%08x", otadata[0].ota_seq);
+    ESP_LOGD(TAG, "otadata[1]: sequence values 0x%08x", otadata[1].ota_seq);
+
+    if ((bootloader_common_ota_select_invalid(&otadata[0]) &&
+         bootloader_common_ota_select_invalid(&otadata[1])) ||
+         bs->app_count == 0) {
+        ESP_LOGD(TAG, "OTA sequence numbers both empty (all-0xFF) or partition table does not have bootable ota_apps (app_count=%d)", bs->app_count);
+        if (bs->factory.offset != 0) {
+            ESP_LOGI(TAG, "Defaulting to factory image");
+            boot_index = FACTORY_INDEX;
+        } else {
+            ESP_LOGI(TAG, "No factory image, trying OTA 0");
+            boot_index = 0;
         }
-
-        ESP_LOGD(TAG, "OTA data offset 0x%x", bs->ota_info.offset);
-        ota_select_map = bootloader_mmap(bs->ota_info.offset, bs->ota_info.size);
-        if (!ota_select_map) {
-            ESP_LOGE(TAG, "bootloader_mmap(0x%x, 0x%x) failed", bs->ota_info.offset, bs->ota_info.size);
-            return INVALID_INDEX; // can't proceed
-        }
-        memcpy(&sa, ota_select_map, sizeof(esp_ota_select_entry_t));
-        memcpy(&sb, (uint8_t *)ota_select_map + SPI_SEC_SIZE, sizeof(esp_ota_select_entry_t));
-        bootloader_munmap(ota_select_map);
-
-        ESP_LOGD(TAG, "OTA sequence values A 0x%08x B 0x%08x", sa.ota_seq, sb.ota_seq);
-        if ((sa.ota_seq == UINT32_MAX && sb.ota_seq == UINT32_MAX) || (bs->app_count == 0)) {
-            ESP_LOGD(TAG, "OTA sequence numbers both empty (all-0xFF) or partition table does not have bootable ota_apps (app_count=%d)", bs->app_count);
-            if (bs->factory.offset != 0) {
-                ESP_LOGI(TAG, "Defaulting to factory image");
-                return FACTORY_INDEX;
-            } else {
-                ESP_LOGI(TAG, "No factory image, trying OTA 0");
-                return 0;
-            }
-        } else  {
-            bool ota_valid = false;
-            const char *ota_msg;
-            int ota_seq; // Raw OTA sequence number. May be more than # of OTA slots
-            if(bootloader_common_ota_select_valid(&sa) && bootloader_common_ota_select_valid(&sb)) {
-                ota_valid = true;
-                ota_msg = "Both OTA values";
-                ota_seq = MAX(sa.ota_seq, sb.ota_seq) - 1;
-            } else if(bootloader_common_ota_select_valid(&sa)) {
-                ota_valid = true;
-                ota_msg = "Only OTA sequence A is";
-                ota_seq = sa.ota_seq - 1;
-            } else if(bootloader_common_ota_select_valid(&sb)) {
-                ota_valid = true;
-                ota_msg = "Only OTA sequence B is";
-                ota_seq = sb.ota_seq - 1;
-            }
-
-            if (ota_valid) {
-                int ota_slot = ota_seq % bs->app_count; // Actual OTA partition selection
-                ESP_LOGD(TAG, "%s valid. Mapping seq %d -> OTA slot %d", ota_msg, ota_seq, ota_slot);
-                return ota_slot;
-            } else if (bs->factory.offset != 0) {
-                ESP_LOGE(TAG, "ota data partition invalid, falling back to factory");
-                return FACTORY_INDEX;
-            } else {
-                ESP_LOGE(TAG, "ota data partition invalid and no factory, will try all partitions");
-                return FACTORY_INDEX;
-            }
+    } else {
+        int active_otadata = bootloader_common_get_active_otadata(otadata);
+        if (active_otadata != -1) {
+            ESP_LOGD(TAG, "Active OTADATA copy is #%d", active_otadata);
+            uint32_t ota_seq = otadata[active_otadata].ota_seq - 1; // Raw OTA sequence number. May be more than # of OTA slots
+            boot_index = ota_seq % bs->app_count; // Actual OTA partition selection
+            ESP_LOGD(TAG, "Mapping seq %d -> OTA slot %d", ota_seq, boot_index);
+        } else if (bs->factory.offset != 0) {
+            ESP_LOGE(TAG, "ota data partition invalid, falling back to factory");
+            boot_index = FACTORY_INDEX;
+        } else {
+            ESP_LOGE(TAG, "ota data partition invalid and no factory, will try all partitions");
+            boot_index = FACTORY_INDEX;
         }
     }
 
-    // otherwise, start from factory app partition and let the search logic
-    // proceed from there
-    return FACTORY_INDEX;
+    return boot_index;
 }
 
 /* Return true if a partition has a valid app image that was successfully loaded */
@@ -389,7 +394,7 @@ static void unpack_load_app(const esp_image_metadata_t* data)
     // Find DROM & IROM addresses, to configure cache mappings
     for (int i = 0; i < data->image.segment_count; i++) {
         const esp_image_segment_header_t *header = &data->segments[i];
-        if (header->load_addr >= SOC_DROM_LOW && header->load_addr < SOC_DROM_HIGH) {
+        if (header->load_addr >= SOC_IROM_LOW && header->load_addr < SOC_IROM_HIGH) {
             if (drom_addr != 0) {
                 ESP_LOGE(TAG, MAP_ERR_MSG, "DROM");
             } else {
@@ -399,7 +404,7 @@ static void unpack_load_app(const esp_image_metadata_t* data)
             drom_load_addr = header->load_addr;
             drom_size = header->data_len;
         }
-        if (header->load_addr >= SOC_IROM_LOW && header->load_addr < SOC_IROM_HIGH) {
+        if (header->load_addr >= SOC_DROM_LOW && header->load_addr < SOC_DROM_HIGH) {
             if (irom_addr != 0) {
                 ESP_LOGE(TAG, MAP_ERR_MSG, "IROM");
             } else {
@@ -430,7 +435,6 @@ static void set_cache_and_start_app(
     uint32_t irom_size,
     uint32_t entry_addr)
 {
-    int rc;
     ESP_LOGD(TAG, "configure drom and irom and start");
     Cache_Read_Disable( 0 );
     Cache_Flush( 0 );
@@ -442,34 +446,20 @@ static void set_cache_and_start_app(
         DPORT_PRO_FLASH_MMU_TABLE[i] = DPORT_FLASH_MMU_TABLE_INVALID_VAL;
     }
 
-    uint32_t drom_load_addr_aligned = drom_load_addr & MMU_FLASH_MASK;
-    uint32_t drom_page_count = bootloader_cache_pages_to_map(drom_size, drom_load_addr);
-    ESP_LOGV(TAG, "d mmu set paddr=%08x vaddr=%08x size=%d n=%d",
-            drom_addr & MMU_FLASH_MASK, drom_load_addr_aligned, drom_size, drom_page_count);
-    rc = cache_flash_mmu_set(0, 0, drom_load_addr_aligned, drom_addr & MMU_FLASH_MASK, 64, drom_page_count);
-    ESP_LOGV(TAG, "rc=%d", rc);
-    rc = cache_flash_mmu_set(1, 0, drom_load_addr_aligned, drom_addr & MMU_FLASH_MASK, 64, drom_page_count);
-    ESP_LOGV(TAG, "rc=%d", rc);
-
-    uint32_t irom_load_addr_aligned = irom_load_addr & MMU_FLASH_MASK;
-    uint32_t irom_page_count = bootloader_cache_pages_to_map(irom_size, irom_load_addr);
-    ESP_LOGV(TAG, "i mmu set paddr=%08x vaddr=%08x size=%d n=%d",
-            irom_addr & MMU_FLASH_MASK, irom_load_addr_aligned, irom_size, irom_page_count);
-    rc = cache_flash_mmu_set(0, 0, irom_load_addr_aligned, irom_addr & MMU_FLASH_MASK, 64, irom_page_count);
-    ESP_LOGV(TAG, "rc=%d", rc);
-    rc = cache_flash_mmu_set(1, 0, irom_load_addr_aligned, irom_addr & MMU_FLASH_MASK, 64, irom_page_count);
-    ESP_LOGV(TAG, "rc=%d", rc);
-
-    DPORT_REG_CLR_BIT( DPORT_PRO_CACHE_CTRL1_REG,
-            (DPORT_PRO_CACHE_MASK_IRAM0) | (DPORT_PRO_CACHE_MASK_IRAM1 & 0) |
-            (DPORT_PRO_CACHE_MASK_IROM0 & 0) | DPORT_PRO_CACHE_MASK_DROM0 |
-            DPORT_PRO_CACHE_MASK_DRAM1 );
-
-    DPORT_REG_CLR_BIT( DPORT_APP_CACHE_CTRL1_REG,
-            (DPORT_APP_CACHE_MASK_IRAM0) | (DPORT_APP_CACHE_MASK_IRAM1 & 0) |
-            (DPORT_APP_CACHE_MASK_IROM0 & 0) | DPORT_APP_CACHE_MASK_DROM0 |
-            DPORT_APP_CACHE_MASK_DRAM1 );
-
+    uint32_t drom_page_count = (drom_size + 64*1024 - 1) / (64*1024); // round up to 64k
+    ESP_LOGV(TAG, "d mmu set paddr=%08x vaddr=%08x size=%d n=%d", drom_addr & 0xffff0000, drom_load_addr & 0xffff0000, drom_size, drom_page_count );
+    int rc = cache_flash_mmu_set( 0, 0, drom_load_addr & 0xffff0000, drom_addr & 0xffff0000, 64, drom_page_count );
+    ESP_LOGV(TAG, "rc=%d", rc );
+    rc = cache_flash_mmu_set( 1, 0, drom_load_addr & 0xffff0000, drom_addr & 0xffff0000, 64, drom_page_count );
+    ESP_LOGV(TAG, "rc=%d", rc );
+    uint32_t irom_page_count = (irom_size + 64*1024 - 1) / (64*1024); // round up to 64k
+    ESP_LOGV(TAG, "i mmu set paddr=%08x vaddr=%08x size=%d n=%d", irom_addr & 0xffff0000, irom_load_addr & 0xffff0000, irom_size, irom_page_count );
+    rc = cache_flash_mmu_set( 0, 0, irom_load_addr & 0xffff0000, irom_addr & 0xffff0000, 64, irom_page_count );
+    ESP_LOGV(TAG, "rc=%d", rc );
+    rc = cache_flash_mmu_set( 1, 0, irom_load_addr & 0xffff0000, irom_addr & 0xffff0000, 64, irom_page_count );
+    ESP_LOGV(TAG, "rc=%d", rc );
+    DPORT_REG_CLR_BIT( DPORT_PRO_CACHE_CTRL1_REG, (DPORT_PRO_CACHE_MASK_IRAM0) | (DPORT_PRO_CACHE_MASK_IRAM1 & 0) | (DPORT_PRO_CACHE_MASK_IROM0 & 0) | DPORT_PRO_CACHE_MASK_DROM0 | DPORT_PRO_CACHE_MASK_DRAM1 );
+    DPORT_REG_CLR_BIT( DPORT_APP_CACHE_CTRL1_REG, (DPORT_APP_CACHE_MASK_IRAM0) | (DPORT_APP_CACHE_MASK_IRAM1 & 0) | (DPORT_APP_CACHE_MASK_IROM0 & 0) | DPORT_APP_CACHE_MASK_DROM0 | DPORT_APP_CACHE_MASK_DRAM1 );
     Cache_Read_Enable( 0 );
 
     // Application will need to do Cache_Flush(1) and Cache_Read_Enable(1)

components/bootloader_support/src/flash_encrypt.c

@@ -163,7 +163,7 @@ static esp_err_t encrypt_flash_contents(uint32_t flash_crypt_cnt, bool flash_cry
 
     /* If the last flash_crypt_cnt bit is burned or write-disabled, the
        device can't re-encrypt itself. */
-    if (flash_crypt_wr_dis) {
+    if (flash_crypt_wr_dis || flash_crypt_cnt == 0xFF) {
         ESP_LOGE(TAG, "Cannot re-encrypt data (FLASH_CRYPT_CNT 0x%02x write disabled %d", flash_crypt_cnt, flash_crypt_wr_dis);
         return ESP_FAIL;
     }
@@ -200,8 +200,8 @@ static esp_err_t encrypt_flash_contents(uint32_t flash_crypt_cnt, bool flash_cry
     ESP_LOGD(TAG, "All flash regions checked for encryption pass");
 
     /* Set least significant 0-bit in flash_crypt_cnt */
-    int ffs_inv = __builtin_ffs((~flash_crypt_cnt) & EFUSE_RD_FLASH_CRYPT_CNT);
-    /* ffs_inv shouldn't be zero, as zero implies flash_crypt_cnt == EFUSE_RD_FLASH_CRYPT_CNT (0x7F) */
+    int ffs_inv = __builtin_ffs((~flash_crypt_cnt) & 0xFF);
+    /* ffs_inv shouldn't be zero, as zero implies flash_crypt_cnt == 0xFF */
     uint32_t new_flash_crypt_cnt = flash_crypt_cnt + (1 << (ffs_inv - 1));
     ESP_LOGD(TAG, "FLASH_CRYPT_CNT 0x%x -> 0x%x", flash_crypt_cnt, new_flash_crypt_cnt);
     REG_SET_FIELD(EFUSE_BLK0_WDATA0_REG, EFUSE_FLASH_CRYPT_CNT, new_flash_crypt_cnt);

components/bootloader_support/src/secure_boot_signatures.c

@@ -25,7 +25,7 @@
 #include "rom/sha.h"
 typedef SHA_CTX sha_context;
 #else
-#include "mbedtls/sha256.h"
+#include "hwcrypto/sha.h"
 #endif
 
 static const char* TAG = "secure_boot";
@@ -57,8 +57,8 @@ esp_err_t esp_secure_boot_verify_signature(uint32_t src_addr, uint32_t length)
     bootloader_sha256_data(handle, data, length);
     bootloader_sha256_finish(handle, digest);
 #else
-    /* Use thread-safe mbedTLS version */
-    mbedtls_sha256_ret(data, length, digest, 0);
+    /* Use thread-safe esp-idf SHA function */
+    esp_sha(SHA2_256, data, length, digest);
 #endif
 
     // Map the signature block and verify the signature

components/bt/CMakeLists.txt

@@ -281,6 +281,6 @@ if(CONFIG_BT_ENABLED)
         component_compile_options(-Wno-implicit-fallthrough -Wno-unused-const-variable)
     endif()
 
-    target_link_libraries(bt "-L${CMAKE_CURRENT_LIST_DIR}/lib")
-    target_link_libraries(bt btdm_app)
+    target_link_libraries(${COMPONENT_TARGET} "-L${CMAKE_CURRENT_LIST_DIR}/lib")
+    target_link_libraries(${COMPONENT_TARGET} btdm_app)
 endif()

components/bt/Kconfig

@@ -124,6 +124,7 @@ config BT_HCI_UART_BAUDRATE
     default 921600
     help
         UART Baudrate for HCI. Please use standard baudrate.
+
 endmenu
 
 menu "MODEM SLEEP Options"
@@ -135,6 +136,7 @@ config BTDM_CONTROLLER_MODEM_SLEEP
     default y
     help
         Enable/disable bluetooth controller low power mode.
+        Note that currently there is problem in the combination use of bluetooth modem sleep and Dynamic Frequency Scaling(DFS). So do not enable DFS if bluetooth modem sleep is in use.
 
 choice BTDM_MODEM_SLEEP_MODE
     prompt "Bluetooth Modem sleep mode"
@@ -145,13 +147,11 @@ choice BTDM_MODEM_SLEEP_MODE
 config BTDM_MODEM_SLEEP_MODE_ORIG
     bool "ORIG Mode(sleep with low power clock)"
     help
-        ORIG mode is a bluetooth sleep mode that can be used for dual mode controller. In this mode, bluetooth controller
-        sleeps between BR/EDR frames and BLE events. A low power clock is used to maintain bluetooth reference clock.
+        ORIG mode is a deep sleep mode that can be used for dual mode controller. In this mode, bluetooth controller sleeps between BR/EDR frames and BLE events. A low power clock is used to maintain bluetooth reference clock.
 config BTDM_MODEM_SLEEP_MODE_EVED
-    bool "EVED Mode(For internal test only)"
+    bool "EVED Mode "
     help
-        EVED mode is for BLE only and is only for internal test. Do not use it for production. this mode is not compatible
-        with DFS nor light sleep
+        This mode is for BLE only.
 endchoice
 
 choice BTDM_LOW_POWER_CLOCK
@@ -162,10 +162,6 @@ choice BTDM_LOW_POWER_CLOCK
 
 config BTDM_LPCLK_SEL_MAIN_XTAL
     bool "Main crystal"
-    help
-        Main crystal can be used as low power clock for bluetooth modem sleep. If this option is selected, bluetooth
-        modem sleep can work under Dynamic Frequency Scaling(DFS) enabled, but cannot work when light sleep is enabled.
-        Main crystal has a relatively better performance than other bluetooth low power clock sources.
 config BTDM_LPCLK_SEL_EXT_32K_XTAL
     bool "External 32kHz crystal"
     depends on ESP32_RTC_CLOCK_SOURCE_EXTERNAL_CRYSTAL
@@ -243,40 +239,13 @@ config MESH_DUPLICATE_SCAN_CACHE_SIZE
         Maximum number of adv packets which can be recorded in duplicate scan cache for BLE Mesh.
         When the maximum amount of device in the filter is reached, the cache will be refreshed.
 
-config BLE_ADV_REPORT_FLOW_CONTROL_SUPPORTED
-    bool "BLE adv report flow control supported"
-    depends on (BTDM_CONTROLLER_MODE_BTDM || BTDM_CONTROLLER_MODE_BLE_ONLY)
-    default y
+config BTDM_CONTROLLER_FULL_SCAN_SUPPORTED
+    bool "BLE full scan feature supported"
+    depends on BTDM_CONTROLLER_MODE_BLE_ONLY
+    default n
     help
-        The function is mainly used to enable flow control for advertising reports. When it is enabled,
-        advertising reports will be discarded by the controller if the number of unprocessed advertising
-        reports exceeds the size of BLE adv report flow control.
-
-config BLE_ADV_REPORT_FLOW_CONTROL_NUM
-    int "BLE adv report flow control number"
-    depends on BLE_ADV_REPORT_FLOW_CONTROL_SUPPORTED
-    range 50 1000
-    default 100
-    help
-        The number of unprocessed advertising report that Bluedroid can save.If you set
-        `BLE_ADV_REPORT_FLOW_CONTROL_NUM` to a small value, this may cause adv packets lost.
-        If you set `BLE_ADV_REPORT_FLOW_CONTROL_NUM` to a large value, Bluedroid may cache a
-        lot of adv packets and this may cause system memory run out. For example, if you set
-        it to 50, the maximum memory consumed by host is 35 * 50 bytes. Please set
-        `BLE_ADV_REPORT_FLOW_CONTROL_NUM` according to your system free memory and handle adv
-        packets as fast as possible, otherwise it will cause adv packets lost.
-
-config BLE_ADV_REPORT_DISCARD_THRSHOLD
-    int "BLE adv lost event threshold value"
-    depends on BLE_ADV_REPORT_FLOW_CONTROL_SUPPORTED
-    range 1 1000
-    default 20
-    help
-        When adv report flow control is enabled, The ADV lost event will be generated when the number
-        of ADV packets lost in the controller reaches this threshold. It is better to set a larger value.
-        If you set `BLE_ADV_REPORT_DISCARD_THRSHOLD` to a small value or printf every adv lost event, it
-        may cause adv packets lost more.
-
+        The full scan function is mainly used to provide BLE scan performance.
+        This is required for scenes with high scan performance requirements, such as BLE Mesh scenes.
 
 endmenu
 
@@ -434,13 +403,6 @@ config BLE_SMP_ENABLE
    help
        This option can be close when the app not used the ble security connect.
 
-config SMP_SLAVE_CON_PARAMS_UPD_ENABLE
-        bool "Slave enable connection parameters update during pairing"
-        depends on BLE_SMP_ENABLE
-        default n
-        help
-            In order to reduce the pairing time, slave actively initiates connection parameters update during pairing.
-
 config BT_STACK_NO_LOG
     bool "Disable BT debug logs (minimize bin size)"
     depends on BLUEDROID_ENABLED
@@ -1225,26 +1187,7 @@ config SMP_ENABLE
    depends on BLUEDROID_ENABLED
    default CLASSIC_BT_ENABLED || BLE_SMP_ENABLE
 
-config BLE_ACTIVE_SCAN_REPORT_ADV_SCAN_RSP_INDIVIDUALLY
-    bool "Report adv data and scan response individually when BLE active scan"
-    depends on BLUEDROID_ENABLED && (BTDM_CONTROLLER_MODE_BTDM || BTDM_CONTROLLER_MODE_BLE_ONLY)
-    default n
-    help
-        Originally, when doing BLE active scan, Bluedroid will not report adv to application layer
-        until receive scan response. This option is used to disable the behavior. When enable this option,
-        Bluedroid will report adv data or scan response to application layer immediately.
-
 # Memory reserved at start of DRAM for Bluetooth stack
-
-config BLE_ESTABLISH_LINK_CONNECTION_TIMEOUT
-        int "Timeout of BLE connection establishment"
-        depends on BLUEDROID_ENABLED
-        range 1 60
-        default 30
-        help
-            Bluetooth Connection establishment maximum time, if connection time exceeds this value, the connection
-            establishment fails, ESP_GATTC_OPEN_EVT or ESP_GATTS_OPEN_EVT is triggered.
-
 config BT_RESERVE_DRAM
     hex
     default 0xdb5c if BT_ENABLED

components/bt/bluedroid/api/esp_gap_ble_api.c

@@ -457,7 +457,7 @@ esp_err_t esp_ble_gap_add_duplicate_scan_exceptional_device(esp_ble_duplicate_ex
     if (esp_bluedroid_get_status() != ESP_BLUEDROID_STATUS_ENABLED) {
         return ESP_ERR_INVALID_STATE;
     }
-    if (!device_info && type <= ESP_BLE_DUPLICATE_SCAN_EXCEPTIONAL_INFO_MESH_LINK_ID) {
+    if (!device_info){
         return ESP_ERR_INVALID_SIZE;
     }
     msg.sig = BTC_SIG_API_CALL;
@@ -465,9 +465,7 @@ esp_err_t esp_ble_gap_add_duplicate_scan_exceptional_device(esp_ble_duplicate_ex
     msg.act = BTC_GAP_BLE_UPDATE_DUPLICATE_SCAN_EXCEPTIONAL_LIST;
     arg.update_duplicate_exceptional_list.subcode = ESP_BLE_DUPLICATE_EXCEPTIONAL_LIST_ADD;
     arg.update_duplicate_exceptional_list.info_type = type;
-    if (device_info) {
-        memcpy(arg.update_duplicate_exceptional_list.device_info, device_info, sizeof(esp_bd_addr_t));
-    }
+    memcpy(arg.update_duplicate_exceptional_list.device_info, device_info, sizeof(esp_bd_addr_t));
 
     return (btc_transfer_context(&msg, &arg, sizeof(btc_ble_gap_args_t), NULL)
                 == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL);
@@ -481,7 +479,7 @@ esp_err_t esp_ble_gap_remove_duplicate_scan_exceptional_device(esp_ble_duplicate
     if (esp_bluedroid_get_status() != ESP_BLUEDROID_STATUS_ENABLED) {
         return ESP_ERR_INVALID_STATE;
     }
-    if (!device_info && type <= ESP_BLE_DUPLICATE_SCAN_EXCEPTIONAL_INFO_MESH_LINK_ID) {
+    if (!device_info){
         return ESP_ERR_INVALID_SIZE;
     }
     msg.sig = BTC_SIG_API_CALL;
@@ -489,9 +487,7 @@ esp_err_t esp_ble_gap_remove_duplicate_scan_exceptional_device(esp_ble_duplicate
     msg.act = BTC_GAP_BLE_UPDATE_DUPLICATE_SCAN_EXCEPTIONAL_LIST;
     arg.update_duplicate_exceptional_list.subcode = ESP_BLE_DUPLICATE_EXCEPTIONAL_LIST_REMOVE;
     arg.update_duplicate_exceptional_list.info_type = type;
-    if (device_info) {
-        memcpy(arg.update_duplicate_exceptional_list.device_info, device_info, sizeof(esp_bd_addr_t));
-    }
+    memcpy(arg.update_duplicate_exceptional_list.device_info, device_info, sizeof(esp_bd_addr_t));
 
     return (btc_transfer_context(&msg, &arg, sizeof(btc_ble_gap_args_t), NULL)
                 == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL);
@@ -665,6 +661,29 @@ esp_err_t esp_ble_get_bond_device_list(int *dev_num, esp_ble_bond_dev_t *dev_lis
 
     return (ret == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL);
 }
+
+esp_err_t esp_ble_oob_req_reply(esp_bd_addr_t bd_addr, uint8_t *TK, uint8_t len)
+{
+    if(len != ESP_BT_OCTET16_LEN) {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    btc_msg_t msg;
+    btc_ble_gap_args_t arg;
+
+    ESP_BLUEDROID_STATUS_CHECK(ESP_BLUEDROID_STATUS_ENABLED);
+
+    msg.sig = BTC_SIG_API_CALL;
+    msg.pid = BTC_PID_GAP_BLE;
+    msg.act = BTC_GAP_BLE_OOB_REQ_REPLY_EVT;
+    memcpy(arg.oob_req_reply.bd_addr, bd_addr, ESP_BD_ADDR_LEN);
+    arg.oob_req_reply.len = len;
+    arg.oob_req_reply.p_value = TK;
+
+    return (btc_transfer_context(&msg, &arg, sizeof(btc_ble_gap_args_t), btc_gap_ble_arg_deep_copy)
+            == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL);
+}
+
 #endif /* #if (SMP_INCLUDED == TRUE) */
 
 esp_err_t esp_ble_gap_disconnect(esp_bd_addr_t remote_device)

components/bt/bluedroid/api/include/api/esp_gap_ble_api.h

@@ -54,6 +54,7 @@ typedef uint8_t esp_ble_key_type_t;
 #define ESP_LE_AUTH_NO_BOND                 0x00                                     /*!< 0*/                     /* relate to BTM_LE_AUTH_NO_BOND in stack/btm_api.h */
 #define ESP_LE_AUTH_BOND                    0x01                                     /*!< 1 << 0 */               /* relate to BTM_LE_AUTH_BOND in stack/btm_api.h */
 #define ESP_LE_AUTH_REQ_MITM                (1 << 2)                                 /*!< 1 << 2 */               /* relate to BTM_LE_AUTH_REQ_MITM in stack/btm_api.h */
+#define ESP_LE_AUTH_REQ_BOND_MITM           (ESP_LE_AUTH_BOND | ESP_LE_AUTH_REQ_MITM)/*!< 0101*/
 #define ESP_LE_AUTH_REQ_SC_ONLY             (1 << 3)                                 /*!< 1 << 3 */               /* relate to BTM_LE_AUTH_REQ_SC_ONLY in stack/btm_api.h */
 #define ESP_LE_AUTH_REQ_SC_BOND             (ESP_LE_AUTH_BOND | ESP_LE_AUTH_REQ_SC_ONLY)            /*!< 1001 */  /* relate to BTM_LE_AUTH_REQ_SC_BOND in stack/btm_api.h */
 #define ESP_LE_AUTH_REQ_SC_MITM             (ESP_LE_AUTH_REQ_MITM | ESP_LE_AUTH_REQ_SC_ONLY)        /*!< 1100 */  /* relate to BTM_LE_AUTH_REQ_SC_MITM in stack/btm_api.h */
@@ -63,6 +64,9 @@ typedef uint8_t   esp_ble_auth_req_t;         /*!< combination of the above bit
 #define ESP_BLE_ONLY_ACCEPT_SPECIFIED_AUTH_DISABLE 0
 #define ESP_BLE_ONLY_ACCEPT_SPECIFIED_AUTH_ENABLE  1
 
+#define ESP_BLE_OOB_DISABLE 0
+#define ESP_BLE_OOB_ENABLE  1
+
 /* relate to BTM_IO_CAP_xxx in stack/btm_api.h */
 #define ESP_IO_CAP_OUT                      0   /*!< DisplayOnly */         /* relate to BTM_IO_CAP_OUT in stack/btm_api.h */
 #define ESP_IO_CAP_IO                       1   /*!< DisplayYesNo */        /* relate to BTM_IO_CAP_IO in stack/btm_api.h */
@@ -271,6 +275,7 @@ typedef enum {
     ESP_BLE_SM_SET_STATIC_PASSKEY,
     ESP_BLE_SM_CLEAR_STATIC_PASSKEY,
     ESP_BLE_SM_ONLY_ACCEPT_SPECIFIED_SEC_AUTH,
+    ESP_BLE_SM_OOB_SUPPORT,
     ESP_BLE_SM_MAX_PARAM,
 } esp_ble_sm_param_t;
 
@@ -553,7 +558,6 @@ typedef enum {
     ESP_GAP_SEARCH_DISC_CMPL_EVT           = 4,      /*!< Discovery complete. */
     ESP_GAP_SEARCH_DI_DISC_CMPL_EVT        = 5,      /*!< Discovery complete. */
     ESP_GAP_SEARCH_SEARCH_CANCEL_CMPL_EVT  = 6,      /*!< Search cancelled */
-    ESP_GAP_SEARCH_INQ_DISCARD_NUM_EVT     = 7,      /*!< The number of pkt discarded by flow control */
 } esp_gap_search_evt_t;
 
 /**
@@ -584,18 +588,12 @@ typedef enum {
 typedef enum {
     ESP_BLE_DUPLICATE_SCAN_EXCEPTIONAL_INFO_ADV_ADDR       = 0,  /*!< BLE advertising address , device info will be added into ESP_BLE_DUPLICATE_SCAN_EXCEPTIONAL_ADDR_LIST */
     ESP_BLE_DUPLICATE_SCAN_EXCEPTIONAL_INFO_MESH_LINK_ID,        /*!< BLE mesh link ID, it is for BLE mesh, device info will be added into ESP_BLE_DUPLICATE_SCAN_EXCEPTIONAL_MESH_LINK_ID_LIST */
-    ESP_BLE_DUPLICATE_SCAN_EXCEPTIONAL_INFO_MESH_BEACON_TYPE,    /*!< BLE mesh beacon AD type, the format is | Len | 0x2B | Beacon Type | Beacon Data | */     
-    ESP_BLE_DUPLICATE_SCAN_EXCEPTIONAL_INFO_MESH_PROV_SRV_ADV,   /*!< BLE mesh provisioning service uuid, the format is | 0x02 | 0x01 | flags | 0x03 | 0x03 | 0x1827 | .... |` */
-    ESP_BLE_DUPLICATE_SCAN_EXCEPTIONAL_INFO_MESH_PROXY_SRV_ADV,  /*!< BLE mesh adv with proxy service uuid, the format is | 0x02 | 0x01 | flags | 0x03 | 0x03 | 0x1828 | .... |` */
 } esp_ble_duplicate_exceptional_info_type_t;
 
 typedef enum {
-    ESP_BLE_DUPLICATE_SCAN_EXCEPTIONAL_ADDR_LIST                  = BLE_BIT(0),             /*!< duplicate scan exceptional addr list */
-    ESP_BLE_DUPLICATE_SCAN_EXCEPTIONAL_MESH_LINK_ID_LIST          = BLE_BIT(1),             /*!< duplicate scan exceptional mesh link ID list */
-    ESP_BLE_DUPLICATE_SCAN_EXCEPTIONAL_MESH_BEACON_TYPE_LIST      = BLE_BIT(2),             /*!< duplicate scan exceptional mesh beacon type list */
-    ESP_BLE_DUPLICATE_SCAN_EXCEPTIONAL_MESH_PROV_SRV_ADV_LIST     = BLE_BIT(3),             /*!< duplicate scan exceptional mesh adv with provisioning service uuid */
-    ESP_BLE_DUPLICATE_SCAN_EXCEPTIONAL_MESH_PROXY_SRV_ADV_LIST    = BLE_BIT(4),             /*!< duplicate scan exceptional mesh adv with provisioning service uuid */
-    ESP_BLE_DUPLICATE_SCAN_EXCEPTIONAL_ALL_LIST                   = 0xFFFF,                 /*!< duplicate scan exceptional all list */
+    ESP_BLE_DUPLICATE_SCAN_EXCEPTIONAL_ADDR_LIST         = BLE_BIT(0), /*!< duplicate scan exceptional addr list */
+    ESP_BLE_DUPLICATE_SCAN_EXCEPTIONAL_MESH_LINK_ID_LIST = BLE_BIT(1), /*!< duplicate scan exceptional mesh link ID list */
+    ESP_BLE_DUPLICATE_SCAN_EXCEPTIONAL_ALL_LIST = (BLE_BIT(0) | BLE_BIT(1)), /*!< duplicate scan exceptional all list */
 } esp_duplicate_scan_exceptional_list_type_t;
 
 typedef uint8_t esp_duplicate_info_t[ESP_BD_ADDR_LEN];
@@ -637,7 +635,6 @@ typedef union {
         int num_resps;                              /*!< Scan result number */
         uint8_t adv_data_len;                       /*!< Adv data length */
         uint8_t scan_rsp_len;                       /*!< Scan response length */
-        uint32_t num_dis;                          /*!< The number of discard packets */
     } scan_rst;                                     /*!< Event parameter of ESP_GAP_BLE_SCAN_RESULT_EVT */
     /**
      * @brief ESP_GAP_BLE_ADV_DATA_RAW_SET_COMPLETE_EVT
@@ -1052,7 +1049,6 @@ esp_err_t esp_ble_gap_read_rssi(esp_bd_addr_t remote_addr);
  *
  *
  * @param[in]       type: device info type, it is defined in esp_ble_duplicate_exceptional_info_type_t
- *                  when type is MESH_BEACON_TYPE, MESH_PROV_SRV_ADV or MESH_PROXY_SRV_ADV , device_info is invalid.
  * @param[in]       device_info: the device information.
  * @return
  *                  - ESP_OK : success
@@ -1065,7 +1061,6 @@ esp_err_t esp_ble_gap_add_duplicate_scan_exceptional_device(esp_ble_duplicate_ex
  *
  *
  * @param[in]       type: device info type, it is defined in esp_ble_duplicate_exceptional_info_type_t
- *                  when type is MESH_BEACON_TYPE, MESH_PROV_SRV_ADV or MESH_PROXY_SRV_ADV , device_info is invalid.
  * @param[in]       device_info: the device information.
  * @return
  *                  - ESP_OK : success
@@ -1194,6 +1189,20 @@ int esp_ble_get_bond_device_num(void);
 */
 esp_err_t esp_ble_get_bond_device_list(int *dev_num, esp_ble_bond_dev_t *dev_list);
 
+/**
+* @brief           This function is called to provide the OOB data for
+*                  SMP in response to ESP_GAP_BLE_OOB_REQ_EVT
+*
+* @param[in]       bd_addr: BD address of the peer device.
+* @param[in]       TK: TK value, the TK value shall be a 128-bit random number
+* @param[in]       len: length of tk, should always be 128-bit
+*
+* @return          - ESP_OK : success
+*                  - other  : failed
+*
+*/
+esp_err_t esp_ble_oob_req_reply(esp_bd_addr_t bd_addr, uint8_t *TK, uint8_t len);
+
 #endif /* #if (SMP_INCLUDED == TRUE) */
 
 /**

components/bt/bluedroid/bta/av/bta_av_aact.c

@@ -1293,10 +1293,9 @@ void bta_av_setconfig_rsp (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
             /* if SBC is used by the SNK as INT, discover req is not sent in bta_av_config_ind.
                        * call disc_res now */
             /* this is called in A2DP SRC path only, In case of SINK we don't need it  */
-            if (local_sep == AVDT_TSEP_SRC) {
+            if (local_sep == AVDT_TSEP_SRC)
                 p_scb->p_cos->disc_res(p_scb->hndl, num, num, 0, p_scb->peer_addr,
                                        UUID_SERVCLASS_AUDIO_SOURCE);
-            }
         } else {
             /* we do not know the peer device and it is using non-SBC codec
              * we need to know all the SEPs on SNK */

components/bt/bluedroid/bta/av/bta_av_act.c

@@ -829,11 +829,10 @@ void bta_av_rc_msg(tBTA_AV_CB *p_cb, tBTA_AV_DATA *p_data)
             if (p_data->rc_msg.msg.pass.op_id == AVRC_ID_VENDOR) {
                 p_data->rc_msg.msg.hdr.ctype = BTA_AV_RSP_NOT_IMPL;
 #if (AVRC_METADATA_INCLUDED == TRUE)
-                if (p_cb->features & BTA_AV_FEAT_METADATA) {
+                if (p_cb->features & BTA_AV_FEAT_METADATA)
                     p_data->rc_msg.msg.hdr.ctype =
                         bta_av_group_navi_supported(p_data->rc_msg.msg.pass.pass_len,
                                                     p_data->rc_msg.msg.pass.p_pass_data, is_inquiry);
-                }
 #endif
             } else {
                 p_data->rc_msg.msg.hdr.ctype = bta_av_op_supported(p_data->rc_msg.msg.pass.op_id, is_inquiry);
@@ -891,9 +890,7 @@ void bta_av_rc_msg(tBTA_AV_CB *p_cb, tBTA_AV_DATA *p_data)
                 evt = bta_av_proc_meta_cmd (&rc_rsp, &p_data->rc_msg, &ctype);
             } else
 #endif
-            {
                 evt = BTA_AV_VENDOR_CMD_EVT;
-            }
         }
         /* else if configured to support vendor specific and it's a response */
         else if ((p_cb->features & BTA_AV_FEAT_VENDOR) &&
@@ -905,9 +902,7 @@ void bta_av_rc_msg(tBTA_AV_CB *p_cb, tBTA_AV_DATA *p_data)
                 evt = BTA_AV_META_MSG_EVT;
             } else
 #endif
-            {
                 evt = BTA_AV_VENDOR_RSP_EVT;
-            }
 
         }
         /* else if not configured to support vendor specific and it's a command */

components/bt/bluedroid/bta/av/bta_av_main.c

@@ -1268,7 +1268,7 @@ BOOLEAN bta_av_hdl_event(BT_HDR *p_msg)
 ** Returns          char *
 **
 *******************************************************************************/
-UNUSED_ATTR static char *bta_av_st_code(UINT8 state)
+static char *bta_av_st_code(UINT8 state)
 {
     switch (state) {
     case BTA_AV_INIT_ST: return "INIT";

components/bt/bluedroid/bta/av/bta_av_ssm.c

@@ -28,7 +28,6 @@
 #include <string.h>
 #include "bta/bta_av_co.h"
 #include "bta_av_int.h"
-#include "osi/osi.h"
 
 /*****************************************************************************
 ** Constants and types
@@ -565,7 +564,7 @@ void bta_av_set_scb_sst_incoming (tBTA_AV_SCB *p_scb)
 ** Returns          char *
 **
 *******************************************************************************/
-UNUSED_ATTR static char *bta_av_sst_code(UINT8 state)
+static char *bta_av_sst_code(UINT8 state)
 {
     switch (state) {
     case BTA_AV_INIT_SST: return "INIT";

components/bt/bluedroid/bta/dm/bta_dm_act.c

@@ -127,7 +127,6 @@ static void bta_dm_remove_sec_dev_entry(BD_ADDR remote_bd_addr);
 #endif  ///SMP_INCLUDED == TRUE
 static void bta_dm_observe_results_cb(tBTM_INQ_RESULTS *p_inq, UINT8 *p_eir);
 static void bta_dm_observe_cmpl_cb(void *p_result);
-static void bta_dm_observe_discard_cb (uint32_t num_dis);
 static void bta_dm_delay_role_switch_cback(TIMER_LIST_ENT *p_tle);
 extern void sdpu_uuid16_to_uuid128(UINT16 uuid16, UINT8 *p_uuid128);
 static void bta_dm_disable_timer_cback(TIMER_LIST_ENT *p_tle);
@@ -636,15 +635,13 @@ void bta_dm_set_visibility(tBTA_DM_MSG *p_data)
 
     /* set modes for Discoverability and connectability if not ignore */
     if (p_data->set_visibility.disc_mode != (BTA_DM_IGNORE | BTA_DM_LE_IGNORE)) {
-        if ((p_data->set_visibility.disc_mode & BTA_DM_LE_IGNORE) == BTA_DM_LE_IGNORE) {
+        if ((p_data->set_visibility.disc_mode & BTA_DM_LE_IGNORE) == BTA_DM_LE_IGNORE)
             p_data->set_visibility.disc_mode =
                 ((p_data->set_visibility.disc_mode & ~BTA_DM_LE_IGNORE) | le_disc_mode);
-        }
 
-        if ((p_data->set_visibility.disc_mode & BTA_DM_IGNORE) == BTA_DM_IGNORE) {
+        if ((p_data->set_visibility.disc_mode & BTA_DM_IGNORE) == BTA_DM_IGNORE)
             p_data->set_visibility.disc_mode =
                 ((p_data->set_visibility.disc_mode & ~BTA_DM_IGNORE) | disc_mode);
-        }
 
         BTM_SetDiscoverability(p_data->set_visibility.disc_mode,
                                bta_dm_cb.inquiry_scan_window,
@@ -652,15 +649,13 @@ void bta_dm_set_visibility(tBTA_DM_MSG *p_data)
     }
 
     if (p_data->set_visibility.conn_mode != (BTA_DM_IGNORE | BTA_DM_LE_IGNORE)) {
-        if ((p_data->set_visibility.conn_mode & BTA_DM_LE_IGNORE) == BTA_DM_LE_IGNORE) {
+        if ((p_data->set_visibility.conn_mode & BTA_DM_LE_IGNORE) == BTA_DM_LE_IGNORE)
             p_data->set_visibility.conn_mode =
                 ((p_data->set_visibility.conn_mode & ~BTA_DM_LE_IGNORE) | le_conn_mode);
-        }
 
-        if ((p_data->set_visibility.conn_mode & BTA_DM_IGNORE) == BTA_DM_IGNORE) {
+        if ((p_data->set_visibility.conn_mode & BTA_DM_IGNORE) == BTA_DM_IGNORE)
             p_data->set_visibility.conn_mode =
                 ((p_data->set_visibility.conn_mode & ~BTA_DM_IGNORE) | conn_mode);
-        }
 
         BTM_SetConnectability(p_data->set_visibility.conn_mode,
                               bta_dm_cb.page_scan_window,
@@ -1155,6 +1150,21 @@ void bta_dm_loc_oob(tBTA_DM_MSG *p_data)
     BTM_ReadLocalOobData();
 }
 
+/*******************************************************************************
+**
+** Function         bta_dm_oob_reply
+**
+** Description      This function is called to provide the OOB data for
+**                  SMP in response to BLE OOB request.
+**
+** Returns          void
+**
+*******************************************************************************/
+void bta_dm_oob_reply(tBTA_DM_MSG *p_data) 
+{
+    BTM_BleOobDataReply(p_data->oob_reply.bd_addr, BTM_SUCCESS, p_data->oob_reply.len, p_data->oob_reply.value);
+}
+
 /*******************************************************************************
 **
 ** Function         bta_dm_ci_io_req_act
@@ -1890,12 +1900,10 @@ void bta_dm_disc_result (tBTA_DM_MSG *p_data)
 
 #if BLE_INCLUDED == TRUE && BTA_GATT_INCLUDED == TRUE
     /* if any BR/EDR service discovery has been done, report the event */
-    if ((bta_dm_search_cb.services & ((BTA_ALL_SERVICE_MASK | BTA_USER_SERVICE_MASK ) & ~BTA_BLE_SERVICE_MASK))) {
-        bta_dm_search_cb.p_search_cback(BTA_DM_DISC_RES_EVT, &p_data->disc_result.result);
-    }
-#else
-    bta_dm_search_cb.p_search_cback(BTA_DM_DISC_RES_EVT, &p_data->disc_result.result);
+    if ((bta_dm_search_cb.services & ((BTA_ALL_SERVICE_MASK | BTA_USER_SERVICE_MASK ) & ~BTA_BLE_SERVICE_MASK)))
 #endif
+        bta_dm_search_cb.p_search_cback(BTA_DM_DISC_RES_EVT, &p_data->disc_result.result);
+
     tBTA_DM_MSG *p_msg = (tBTA_DM_MSG *) osi_malloc(sizeof(tBTA_DM_MSG));
 
     /* send a message to change state */
@@ -2161,10 +2169,9 @@ static void bta_dm_find_services ( BD_ADDR bd_addr)
                         }
 
                         /* last one? clear the BLE service bit if all discovery has been done */
-                        if (bta_dm_search_cb.uuid_to_search == 0) {
+                        if (bta_dm_search_cb.uuid_to_search == 0)
                             bta_dm_search_cb.services_to_search &=
                                 (tBTA_SERVICE_MASK)(~(BTA_SERVICE_ID_TO_SERVICE_MASK(bta_dm_search_cb.service_index)));
-                        }
 
                     } else
 #endif
@@ -2674,7 +2681,9 @@ static UINT8 bta_dm_authorize_cback (BD_ADDR bd_addr, DEV_CLASS dev_class, BD_NA
     }
 }
 
-#if (BT_SSP_INCLUDED == TRUE)
+
+
+
 /*******************************************************************************
 **
 ** Function         bta_dm_pinname_cback
@@ -2731,7 +2740,6 @@ static UINT8 bta_dm_authorize_cback (BD_ADDR bd_addr, DEV_CLASS dev_class, BD_NA
         bta_dm_cb.p_sec_cback(event, &sec_event);
     }
 }
-#endif /// BT_SSP_INCLUDED == TRUE
 
 /*******************************************************************************
 **
@@ -2751,6 +2759,18 @@ static UINT8 bta_dm_pin_cback (BD_ADDR bd_addr, DEV_CLASS dev_class, BD_NAME bd_
         return BTM_NOT_AUTHORIZED;
     }
 
+    /* If the device name is not known, save bdaddr and devclass and initiate a name request */
+    if (bd_name[0] == 0) {
+        bta_dm_cb.pin_evt = BTA_DM_PIN_REQ_EVT;
+        bdcpy(bta_dm_cb.pin_bd_addr, bd_addr);
+        BTA_COPY_DEVICE_CLASS(bta_dm_cb.pin_dev_class, dev_class);
+        if ((BTM_ReadRemoteDeviceName(bd_addr, bta_dm_pinname_cback, BT_TRANSPORT_BR_EDR)) == BTM_CMD_STARTED) {
+            return BTM_CMD_STARTED;
+        }
+
+        APPL_TRACE_WARNING(" bta_dm_pin_cback() -> Failed to start Remote Name Request  ");
+    }
+
     bdcpy(sec_event.pin_req.bd_addr, bd_addr);
     BTA_COPY_DEVICE_CLASS(sec_event.pin_req.dev_class, dev_class);
     BCM_STRNCPY_S((char *)sec_event.pin_req.bd_name, sizeof(BD_NAME), (char *)bd_name, (BD_NAME_LEN - 1));
@@ -3647,11 +3667,11 @@ static char *bta_dm_get_remname(void)
     char *p_temp;
 
     /* If the name isn't already stored, try retrieving from BTM */
-    if (*p_name == '\0') {
+    if (*p_name == '\0')
         if ((p_temp = BTM_SecReadDevName(bta_dm_search_cb.peer_bdaddr)) != NULL) {
             p_name = p_temp;
         }
-    }
+
     return p_name;
 }
 #endif  ///SDP_INCLUDED == TRUE || SMP_INCLUDED == TRUE
@@ -4266,28 +4286,6 @@ static void bta_dm_observe_cmpl_cb (void *p_result)
     }
 }
 
-/*******************************************************************************
-**
-** Function         bta_dm_observe_discard_cb
-**
-** Description      Callback for BLE Observe lost
-**
-**
-** Returns          void
-**
-*******************************************************************************/
-static void bta_dm_observe_discard_cb (uint32_t num_dis)
-{
-    tBTA_DM_SEARCH  data;
-
-    APPL_TRACE_DEBUG("bta_dm_observe_discard_cb");
-
-    data.inq_dis.num_dis = num_dis;
-    if (bta_dm_search_cb.p_scan_cback) {
-        bta_dm_search_cb.p_scan_cback(BTA_DM_INQ_DISCARD_NUM_EVT, &data);
-    }
-}
-
 #if (SMP_INCLUDED == TRUE)
 /*******************************************************************************
 **
@@ -4492,8 +4490,7 @@ void bta_dm_add_ble_device (tBTA_DM_MSG *p_data)
 {
     if (!BTM_SecAddBleDevice (p_data->add_ble_device.bd_addr, NULL,
                               p_data->add_ble_device.dev_type  ,
-                              p_data->add_ble_device.addr_type,
-                              p_data->add_ble_device.auth_mode)) {
+                              p_data->add_ble_device.addr_type)) {
         APPL_TRACE_ERROR ("BTA_DM: Error adding BLE Device for device %08x%04x",
                           (p_data->add_ble_device.bd_addr[0] << 24) + (p_data->add_ble_device.bd_addr[1] << 16) + \
                           (p_data->add_ble_device.bd_addr[2] << 8) + p_data->add_ble_device.bd_addr[3],
@@ -4622,14 +4619,25 @@ void bta_dm_ble_set_scan_params(tBTA_DM_MSG *p_data)
 *******************************************************************************/
 void bta_dm_ble_set_scan_fil_params(tBTA_DM_MSG *p_data)
 {
-    BTM_BleSetScanFilterParams (p_data->ble_set_scan_fil_params.client_if,
+    tBTA_STATUS status = BTA_FAILURE;
+
+    if (BTM_BleSetScanFilterParams (p_data->ble_set_scan_fil_params.client_if,
                                 p_data->ble_set_scan_fil_params.scan_int,
                                 p_data->ble_set_scan_fil_params.scan_window,
                                 p_data->ble_set_scan_fil_params.scan_mode,
                                 p_data->ble_set_scan_fil_params.addr_type_own,
                                 p_data->ble_set_scan_fil_params.scan_duplicate_filter,
                                 p_data->ble_set_scan_fil_params.scan_filter_policy,
-                                p_data->ble_set_scan_fil_params.scan_param_setup_cback);
+                                p_data->ble_set_scan_fil_params.scan_param_setup_cback) == BTM_SUCCESS) {
+        status = BTA_SUCCESS;
+
+    } else {
+        APPL_TRACE_ERROR("%s(), fail to set scan params.", __func__); 
+    }
+    if (p_data->ble_set_scan_fil_params.scan_param_setup_cback != NULL) {
+        p_data->ble_set_scan_fil_params.scan_param_setup_cback(p_data->ble_set_scan_fil_params.client_if, status);
+    }
+    
 }
 
 
@@ -4819,7 +4827,7 @@ void bta_dm_ble_scan (tBTA_DM_MSG *p_data)
         bta_dm_search_cb.p_scan_cback = p_data->ble_scan.p_cback;
 
         if ((status = BTM_BleScan(TRUE, p_data->ble_scan.duration,
-                                     bta_dm_observe_results_cb, bta_dm_observe_cmpl_cb, bta_dm_observe_discard_cb)) != BTM_CMD_STARTED) {
+                                     bta_dm_observe_results_cb, bta_dm_observe_cmpl_cb)) != BTM_CMD_STARTED) {
             APPL_TRACE_WARNING(" %s start scan failed. status=0x%x\n", __FUNCTION__, status);
         }
 
@@ -4829,7 +4837,7 @@ void bta_dm_ble_scan (tBTA_DM_MSG *p_data)
         }
     } else {
         bta_dm_search_cb.p_scan_cback = NULL;
-        status = BTM_BleScan(FALSE, 0, NULL, NULL, NULL);
+        status = BTM_BleScan(FALSE, 0, NULL, NULL);
 
         if (status != BTM_CMD_STARTED){
             APPL_TRACE_WARNING(" %s stop scan failed, status=0x%x\n", __FUNCTION__, status);
@@ -4872,7 +4880,8 @@ void bta_dm_ble_set_adv_params (tBTA_DM_MSG *p_data)
 *******************************************************************************/
 void bta_dm_ble_set_adv_params_all  (tBTA_DM_MSG *p_data)
 {
-    if (BTM_BleSetAdvParamsStartAdv(p_data->ble_set_adv_params_all.adv_int_min,
+    tBTA_STATUS status = BTA_FAILURE;
+    if (BTM_BleSetAdvParamsAll(p_data->ble_set_adv_params_all.adv_int_min,
                                 p_data->ble_set_adv_params_all.adv_int_max,
                                 p_data->ble_set_adv_params_all.adv_type,
                                 p_data->ble_set_adv_params_all.addr_type_own,
@@ -4880,10 +4889,20 @@ void bta_dm_ble_set_adv_params_all  (tBTA_DM_MSG *p_data)
                                 p_data->ble_set_adv_params_all.channel_map,
                                 p_data->ble_set_adv_params_all.adv_filter_policy,
                                 p_data->ble_set_adv_params_all.p_start_adv_cback) == BTM_SUCCESS) {
-        APPL_TRACE_DEBUG("%s(), success to start ble adv.", __func__);
+        APPL_TRACE_DEBUG("%s(), success to set ble adv params.", __func__);
     } else {
-        APPL_TRACE_ERROR("%s(), fail to start ble adv.", __func__);
+        APPL_TRACE_ERROR("%s(), fail to set ble adv params.", __func__);
+        if(p_data->ble_set_adv_params_all.p_start_adv_cback) {
+            (*p_data->ble_set_adv_params_all.p_start_adv_cback)(status);
+        }
+        return;
     }
+    if(BTM_BleStartAdv() == BTM_SUCCESS) {
+        status = BTA_SUCCESS;
+    }
+    if(p_data->ble_set_adv_params_all.p_start_adv_cback) {
+        (*p_data->ble_set_adv_params_all.p_start_adv_cback)(status);
+    }     
 }
 
 /*******************************************************************************
@@ -4925,6 +4944,29 @@ void bta_dm_ble_set_adv_config (tBTA_DM_MSG *p_data)
     }
 }
 
+/*******************************************************************************
+**
+** Function         bta_dm_ble_set_long_adv
+**
+** Description      This function set the long ADV data
+**
+** Parameters:
+**
+*******************************************************************************/
+void bta_dm_ble_set_long_adv (tBTA_DM_MSG *p_data)
+{
+    tBTA_STATUS status = BTA_FAILURE;
+
+    if (BTM_BleWriteLongAdvData(p_data->ble_set_long_adv_data.adv_data,
+                                p_data->ble_set_long_adv_data.adv_data_len) == BTM_SUCCESS) {
+        status = BTA_SUCCESS;
+    }
+
+    if (p_data->ble_set_adv_data.p_adv_data_cback) {
+        (*p_data->ble_set_adv_data.p_adv_data_cback)(status);
+    }
+}
+
 /*******************************************************************************
 **
 ** Function         bta_dm_ble_set_adv_config_raw
@@ -5040,16 +5082,17 @@ void bta_dm_ble_set_data_length(tBTA_DM_MSG *p_data)
 *******************************************************************************/
 void bta_dm_ble_broadcast (tBTA_DM_MSG *p_data)
 {
-    tBTM_STATUS status = 0;
+    tBTA_STATUS status = BTA_FAILURE;
     BOOLEAN start = p_data->ble_observe.start;
 
-    status = BTM_BleBroadcast(start, p_data->ble_observe.p_stop_adv_cback);
+    if (BTM_BleBroadcast(start, p_data->ble_observe.p_stop_adv_cback) == BTM_SUCCESS) {
+        status = BTA_SUCCESS;
+    } else {
+        APPL_TRACE_ERROR("%s failed\n", __FUNCTION__);
+    }
 
     if (p_data->ble_observe.p_stop_adv_cback){
-        if (status != BTM_SUCCESS){
-            APPL_TRACE_WARNING("%s, %s, status=0x%x\n", __func__,\
-                    (start == TRUE) ? "start adv failed" : "stop adv failed", status);
-        }
+        (*p_data->ble_observe.p_stop_adv_cback)(status);
     }
 
 }
@@ -5188,10 +5231,9 @@ void bta_dm_ble_setup_storage (tBTA_DM_MSG *p_data)
                                              p_data->ble_set_storage.ref_value);
     }
 
-    if (BTM_CMD_STARTED != btm_status) {
+    if (BTM_CMD_STARTED != btm_status)
         bta_ble_scan_setup_cb(BTM_BLE_BATCH_SCAN_CFG_STRG_EVT, p_data->ble_set_storage.ref_value,
                               btm_status);
-    }
 }
 
 /*******************************************************************************
@@ -5219,10 +5261,9 @@ void bta_dm_ble_enable_batch_scan (tBTA_DM_MSG *p_data)
                                             p_data->ble_enable_scan.ref_value);
     }
 
-    if (BTM_CMD_STARTED != btm_status) {
+    if (BTM_CMD_STARTED != btm_status)
         bta_ble_scan_setup_cb(BTM_BLE_BATCH_SCAN_ENABLE_EVT, p_data->ble_enable_scan.ref_value,
                               btm_status);
-    }
 }
 
 /*******************************************************************************
@@ -5246,10 +5287,9 @@ void bta_dm_ble_disable_batch_scan (tBTA_DM_MSG *p_data)
         btm_status = BTM_BleDisableBatchScan(p_data->ble_disable_scan.ref_value);
     }
 
-    if (BTM_CMD_STARTED != btm_status) {
+    if (BTM_CMD_STARTED != btm_status)
         bta_ble_scan_setup_cb(BTM_BLE_BATCH_SCAN_DISABLE_EVT, p_data->ble_enable_scan.ref_value,
                               btm_status);
-    }
 }
 
 /*******************************************************************************
@@ -5273,10 +5313,9 @@ void bta_dm_ble_read_scan_reports(tBTA_DM_MSG *p_data)
                                             p_data->ble_read_reports.ref_value);
     }
 
-    if (BTM_CMD_STARTED != btm_status) {
+    if (BTM_CMD_STARTED != btm_status)
         bta_ble_scan_setup_cb(BTM_BLE_BATCH_SCAN_READ_REPTS_EVT, p_data->ble_enable_scan.ref_value,
                               btm_status);
-    }
 }
 
 /*******************************************************************************
@@ -5406,11 +5445,10 @@ void bta_dm_cfg_filter_cond (tBTA_DM_MSG *p_data)
         }
     }
 
-    if (p_data->ble_cfg_filter_cond.p_filt_cfg_cback) {
+    if (p_data->ble_cfg_filter_cond.p_filt_cfg_cback)
         p_data->ble_cfg_filter_cond.p_filt_cfg_cback(BTA_DM_BLE_PF_CONFIG_EVT,
                 p_data->ble_cfg_filter_cond.cond_type, 0, status,
                 p_data->ble_cfg_filter_cond.ref_value);
-    }
     return;
 }
 
@@ -5441,10 +5479,9 @@ void bta_dm_enable_scan_filter(tBTA_DM_MSG *p_data)
         return;
     }
 
-    if (p_data->ble_enable_scan_filt.p_filt_status_cback) {
+    if (p_data->ble_enable_scan_filt.p_filt_status_cback)
         p_data->ble_enable_scan_filt.p_filt_status_cback (BTA_DM_BLE_PF_ENABLE_EVT,
                 p_data->ble_enable_scan_filt.ref_value, status);
-    }
 
 }
 
@@ -5478,10 +5515,9 @@ void bta_dm_scan_filter_param_setup (tBTA_DM_MSG *p_data)
         }
     }
 
-    if (p_data->ble_scan_filt_param_setup.p_filt_param_cback) {
+    if (p_data->ble_scan_filt_param_setup.p_filt_param_cback)
         p_data->ble_scan_filt_param_setup.p_filt_param_cback (BTA_DM_BLE_PF_ENABLE_EVT, 0,
                 p_data->ble_scan_filt_param_setup.ref_value, status);
-    }
 
     return;
 }
@@ -5791,8 +5827,6 @@ void bta_dm_proc_open_evt(tBTA_GATTC_OPEN *p_data)
                      ((p2[0]) << 24) + ((p2[1]) << 16) + ((p2[2]) << 8) + (p2[3]),
                      ((p2[4]) << 8) + p2[5]);
 
-    UNUSED(p1);
-    UNUSED(p2);
     APPL_TRACE_DEBUG("BTA_GATTC_OPEN_EVT conn_id = %d client_if=%d status = %d" ,
                      p_data->conn_id,
                      p_data->client_if,

components/bt/bluedroid/bta/dm/bta_dm_api.c

@@ -510,6 +510,36 @@ void BTA_DmLocalOob(void)
         bta_sys_sendmsg(p_msg);
     }
 }
+
+/*******************************************************************************
+**
+** Function         BTA_DmOobReply
+**
+**                  This function is called to provide the OOB data for
+**                  SMP in response to BTM_LE_OOB_REQ_EVT
+**
+** Parameters:      bd_addr     - Address of the peer device
+**                  len         - length of simple pairing Randomizer  C
+**                  p_value     - simple pairing Randomizer  C.
+**
+** Returns          void
+**
+*******************************************************************************/
+void BTA_DmOobReply(BD_ADDR bd_addr, UINT8 len, UINT8 *p_value)
+{
+    tBTA_DM_API_OOB_REPLY    *p_msg;
+
+    if ((p_msg = (tBTA_DM_API_OOB_REPLY *) osi_malloc(sizeof(tBTA_DM_API_OOB_REPLY))) != NULL) {
+        p_msg->hdr.event = BTA_DM_API_OOB_REPLY_EVT;
+        if(p_value == NULL || len > BT_OCTET16_LEN) {
+            return;
+        }
+        memcpy(p_msg->bd_addr, bd_addr, BD_ADDR_LEN);
+        p_msg->len = len;
+        memcpy(p_msg->value, p_value, len);
+        bta_sys_sendmsg(p_msg);
+    }
+}
 #endif /* BTM_OOB_INCLUDED */
 /*******************************************************************************
 **
@@ -797,13 +827,12 @@ void BTA_DmAddBleKey (BD_ADDR bd_addr, tBTA_LE_KEY_VALUE *p_le_key, tBTA_LE_KEY_
 **
 ** Parameters:      bd_addr          - BD address of the peer
 **                  dev_type         - Remote device's device type.
-**                  auth_mode        - auth mode
 **                  addr_type        - LE device address type.
 **
 ** Returns          void
 **
 *******************************************************************************/
-void BTA_DmAddBleDevice(BD_ADDR bd_addr, tBLE_ADDR_TYPE addr_type, int auth_mode, tBT_DEVICE_TYPE dev_type)
+void BTA_DmAddBleDevice(BD_ADDR bd_addr, tBLE_ADDR_TYPE addr_type, tBT_DEVICE_TYPE dev_type)
 {
     tBTA_DM_API_ADD_BLE_DEVICE *p_msg;
 
@@ -813,7 +842,6 @@ void BTA_DmAddBleDevice(BD_ADDR bd_addr, tBLE_ADDR_TYPE addr_type, int auth_mode
         p_msg->hdr.event = BTA_DM_API_ADD_BLEDEVICE_EVT;
         bdcpy(p_msg->bd_addr, bd_addr);
         p_msg->addr_type = addr_type;
-        p_msg->auth_mode = auth_mode;
         p_msg->dev_type = dev_type;
 
         bta_sys_sendmsg(p_msg);
@@ -1202,6 +1230,35 @@ void BTA_DmBleSetAdvConfigRaw (UINT8 *p_raw_adv, UINT32 raw_adv_len,
     }
 }
 
+/*******************************************************************************
+**
+** Function         BTA_DmBleSetLongAdv
+**
+** Description      This function is called to set long Advertising data
+**
+** Parameters       adv_data : long advertising data.
+**                  adv_data_len : long advertising data length.
+**                  p_adv_data_cback : set long adv data complete callback.
+**
+** Returns          None
+**
+*******************************************************************************/
+void BTA_DmBleSetLongAdv (UINT8 *adv_data, UINT32 adv_data_len,
+                            tBTA_SET_ADV_DATA_CMPL_CBACK *p_adv_data_cback)
+{
+    tBTA_DM_API_SET_LONG_ADV  *p_msg;
+
+    if ((p_msg = (tBTA_DM_API_SET_LONG_ADV *)
+                 osi_malloc(sizeof(tBTA_DM_API_SET_LONG_ADV))) != NULL) {
+        p_msg->hdr.event = BTA_DM_API_BLE_SET_LONG_ADV_EVT;
+        p_msg->p_adv_data_cback = p_adv_data_cback;
+        p_msg->adv_data = adv_data;
+        p_msg->adv_data_len = adv_data_len;
+
+        bta_sys_sendmsg(p_msg);
+    }
+}
+
 /*******************************************************************************
 **
 ** Function         BTA_DmBleSetScanRsp

components/bt/bluedroid/bta/dm/bta_dm_co.c

@@ -35,6 +35,9 @@
 #define BTM_BLE_ONLY_ACCEPT_SPECIFIED_SEC_AUTH_DISABLE 0
 #define BTM_BLE_ONLY_ACCEPT_SPECIFIED_SEC_AUTH_ENABLE  1
 
+#define BTM_BLE_OOB_DISABLE  0
+#define BTM_BLE_OOB_ENABLE   1
+
 tBTE_APPL_CFG bte_appl_cfg = {
 #if SMP_INCLUDED == TRUE
     BTA_LE_AUTH_REQ_SC_MITM_BOND, // Authentication requirements
@@ -45,7 +48,8 @@ tBTE_APPL_CFG bte_appl_cfg = {
     BTM_BLE_INITIATOR_KEY_SIZE,
     BTM_BLE_RESPONDER_KEY_SIZE,
     BTM_BLE_MAX_KEY_SIZE,
-    BTM_BLE_ONLY_ACCEPT_SPECIFIED_SEC_AUTH_DISABLE
+    BTM_BLE_ONLY_ACCEPT_SPECIFIED_SEC_AUTH_DISABLE,
+    BTM_BLE_OOB_DISABLE,
 };
 #endif
 
@@ -338,12 +342,16 @@ void bta_dm_co_ble_io_req(BD_ADDR bd_addr,  tBTA_IO_CAP *p_io_cap,
      * If the answer can not be obtained right away,
      * set *p_oob_data to BTA_OOB_UNKNOWN and call bta_dm_ci_io_req() when the answer is available */
 
-    *p_oob_data = FALSE;
+    *p_oob_data = bte_appl_cfg.oob_support;
 
     /* *p_auth_req by default is FALSE for devices with NoInputNoOutput; TRUE for other devices. */
 
     *p_auth_req = bte_appl_cfg.ble_auth_req | (bte_appl_cfg.ble_auth_req & BTA_LE_AUTH_REQ_MITM) | ((*p_auth_req) & BTA_LE_AUTH_REQ_MITM);
 
+    if (*p_oob_data == BTM_BLE_OOB_ENABLE) {
+        *p_auth_req = (*p_auth_req)&(~BTA_LE_AUTH_REQ_SC_ONLY);
+    }
+
     if (bte_appl_cfg.ble_io_cap <= 4) {
         *p_io_cap = bte_appl_cfg.ble_io_cap;
     }
@@ -433,5 +441,16 @@ UINT8 bta_dm_co_ble_get_auth_req(void)
     return 0;
 }
 
+void bta_dm_co_ble_oob_support(UINT8 enable)
+{
+#if (SMP_INCLUDED == TRUE)
+    if (enable) {
+        bte_appl_cfg.oob_support = BTM_BLE_OOB_ENABLE;
+    } else {
+        bte_appl_cfg.oob_support = BTM_BLE_OOB_DISABLE;
+    }
+#endif  ///SMP_INCLUDED == TRUE
+}
+
 #endif
 

components/bt/bluedroid/bta/dm/bta_dm_main.c

@@ -82,6 +82,7 @@ const tBTA_DM_ACTION bta_dm_action[BTA_DM_MAX_EVT] = {
 #endif  ///SMP_INCLUDED == TRUE
 #if (BTM_OOB_INCLUDED == TRUE && SMP_INCLUDED == TRUE)
     bta_dm_loc_oob,                         /* BTA_DM_API_LOC_OOB_EVT */
+    bta_dm_oob_reply,                       /* BTA_DM_API_OOB_REPLY_EVT */
     bta_dm_ci_io_req_act,                   /* BTA_DM_CI_IO_REQ_EVT */
     bta_dm_ci_rmt_oob_act,                  /* BTA_DM_CI_RMT_OOB_EVT */
 #endif /* BTM_OOB_INCLUDED */
@@ -130,6 +131,7 @@ const tBTA_DM_ACTION bta_dm_action[BTA_DM_MAX_EVT] = {
     bta_dm_ble_set_scan_rsp_raw,            /* BTA_DM_API_BLE_SET_SCAN_RSP_RAW_EVT */
     bta_dm_ble_broadcast,                   /* BTA_DM_API_BLE_BROADCAST_EVT */
     bta_dm_ble_set_data_length,             /* BTA_DM_API_SET_DATA_LENGTH_EVT */
+    bta_dm_ble_set_long_adv,                /* BTA_DM_API_BLE_SET_LONG_ADV_EVT */
 #if BLE_ANDROID_CONTROLLER_SCAN_FILTER == TRUE
     bta_dm_cfg_filter_cond,                 /* BTA_DM_API_CFG_FILTER_COND_EVT */
     bta_dm_scan_filter_param_setup,         /* BTA_DM_API_SCAN_FILTER_SETUP_EVT */

components/bt/bluedroid/bta/dm/bta_dm_pm.c

@@ -1038,10 +1038,9 @@ static void bta_dm_pm_hid_check(BOOLEAN bScoActive)
             bta_dm_pm_set_sniff_policy( bta_dm_find_peer_device(bta_dm_conn_srvcs.conn_srvc[j].peer_bdaddr), bScoActive);
 
             /* if we had disabled link policy, seems like the hid device stop retrying SNIFF after a few tries. force sniff if needed */
-            if (!bScoActive) {
+            if (!bScoActive)
                 bta_dm_pm_set_mode(bta_dm_conn_srvcs.conn_srvc[j].peer_bdaddr, BTA_DM_PM_NO_ACTION,
                                    BTA_DM_PM_RESTART);
-            }
         }
     }
 

components/bt/bluedroid/bta/dm/include/bta_dm_int.h

@@ -79,6 +79,7 @@ enum {
 #endif  ///SMP_INCLUDED == TRUE
 #if (BTM_OOB_INCLUDED == TRUE && SMP_INCLUDED == TRUE)
     BTA_DM_API_LOC_OOB_EVT,
+    BTA_DM_API_OOB_REPLY_EVT,
     BTA_DM_CI_IO_REQ_EVT,
     BTA_DM_CI_RMT_OOB_EVT,
 #endif /* BTM_OOB_INCLUDED */
@@ -127,7 +128,7 @@ enum {
     BTA_DM_API_BLE_SET_SCAN_RSP_RAW_EVT,
     BTA_DM_API_BLE_BROADCAST_EVT,
     BTA_DM_API_SET_DATA_LENGTH_EVT,
-
+    BTA_DM_API_BLE_SET_LONG_ADV_EVT,
 #if BLE_ANDROID_CONTROLLER_SCAN_FILTER == TRUE
     BTA_DM_API_CFG_FILTER_COND_EVT,
     BTA_DM_API_SCAN_FILTER_SETUP_EVT,
@@ -307,6 +308,14 @@ typedef struct {
     BT_HDR      hdr;
 } tBTA_DM_API_LOC_OOB;
 
+/* data type for BTA_DM_API_OOB_REPLY_EVT */
+typedef struct {
+    BT_HDR      hdr;
+    BD_ADDR bd_addr;
+    UINT8       len;
+    UINT8       value[BT_OCTET16_LEN];
+} tBTA_DM_API_OOB_REPLY;
+
 /* data type for BTA_DM_API_CONFIRM_EVT */
 typedef struct {
     BT_HDR      hdr;
@@ -454,7 +463,6 @@ typedef struct {
     BT_HDR                  hdr;
     BD_ADDR                 bd_addr;
     tBT_DEVICE_TYPE         dev_type ;
-    UINT32                  auth_mode;
     tBLE_ADDR_TYPE          addr_type;
 
 } tBTA_DM_API_ADD_BLE_DEVICE;
@@ -657,6 +665,13 @@ typedef struct {
     tBTA_SET_ADV_DATA_CMPL_CBACK    *p_adv_data_cback;
 } tBTA_DM_API_SET_ADV_CONFIG_RAW;
 
+typedef struct {
+    BT_HDR                  hdr;
+    UINT8                   *adv_data;
+    UINT8                   adv_data_len;
+    tBTA_SET_ADV_DATA_CMPL_CBACK    *p_adv_data_cback;
+} tBTA_DM_API_SET_LONG_ADV;
+
 typedef struct {
     BT_HDR                  hdr;
     UINT8                   batch_scan_full_max;
@@ -789,6 +804,7 @@ typedef union {
     tBTA_DM_API_PIN_REPLY pin_reply;
 
     tBTA_DM_API_LOC_OOB     loc_oob;
+    tBTA_DM_API_OOB_REPLY   oob_reply;
     tBTA_DM_API_CONFIRM     confirm;
     tBTA_DM_API_KEY_REQ     key_req;
     tBTA_DM_CI_IO_REQ       ci_io_req;
@@ -836,6 +852,7 @@ typedef union {
     tBTA_DM_API_BLE_ADV_PARAMS_ALL      ble_set_adv_params_all;
     tBTA_DM_API_SET_ADV_CONFIG          ble_set_adv_data;
     tBTA_DM_API_SET_ADV_CONFIG_RAW      ble_set_adv_data_raw;
+    tBTA_DM_API_SET_LONG_ADV            ble_set_long_adv_data;
 #if BLE_ANDROID_CONTROLLER_SCAN_FILTER == TRUE
     tBTA_DM_API_SCAN_FILTER_PARAM_SETUP ble_scan_filt_param_setup;
     tBTA_DM_API_CFG_FILTER_COND         ble_cfg_filter_cond;
@@ -1248,6 +1265,7 @@ extern void bta_dm_ble_config_local_icon (tBTA_DM_MSG *p_data);
 extern void bta_dm_ble_set_adv_params (tBTA_DM_MSG *p_data);
 extern void bta_dm_ble_set_adv_params_all(tBTA_DM_MSG *p_data);
 extern void bta_dm_ble_set_adv_config (tBTA_DM_MSG *p_data);
+extern void bta_dm_ble_set_long_adv (tBTA_DM_MSG *p_data);
 extern void bta_dm_ble_set_adv_config_raw (tBTA_DM_MSG *p_data);
 extern void bta_dm_ble_set_scan_rsp (tBTA_DM_MSG *p_data);
 extern void bta_dm_ble_set_scan_rsp_raw (tBTA_DM_MSG *p_data);
@@ -1277,6 +1295,7 @@ extern void bta_dm_confirm(tBTA_DM_MSG *p_data);
 extern void bta_dm_key_req(tBTA_DM_MSG *p_data);
 #if (BTM_OOB_INCLUDED == TRUE)
 extern void bta_dm_loc_oob(tBTA_DM_MSG *p_data);
+extern void bta_dm_oob_reply(tBTA_DM_MSG *p_data);
 extern void bta_dm_ci_io_req_act(tBTA_DM_MSG *p_data);
 extern void bta_dm_ci_rmt_oob_act(tBTA_DM_MSG *p_data);
 #endif /* BTM_OOB_INCLUDED */

components/bt/bluedroid/bta/gatt/bta_gattc_act.c

@@ -531,9 +531,7 @@ void bta_gattc_init_bk_conn(tBTA_GATTC_API_OPEN *p_data, tBTA_GATTC_RCB *p_clreg
     if (bta_gattc_mark_bg_conn(p_data->client_if, p_data->remote_bda, TRUE, FALSE)) {
         /* always call open to hold a connection */
         if (!GATT_Connect(p_data->client_if, p_data->remote_bda, p_data->remote_addr_type, FALSE, p_data->transport)) {
-#if (!CONFIG_BT_STACK_NO_LOG)
             uint8_t *bda = (uint8_t *)p_data->remote_bda;
-#endif
             status = BTA_GATT_ERROR;
             APPL_TRACE_ERROR("%s unable to connect to remote bd_addr:%02x:%02x:%02x:%02x:%02x:%02x",
                              __func__, bda[0], bda[1], bda[2], bda[3], bda[4], bda[5]);
@@ -676,7 +674,7 @@ void bta_gattc_conn(tBTA_GATTC_CLCB *p_clcb, tBTA_GATTC_DATA *p_data)
                 bta_gattc_reset_discover_st(p_clcb->p_srcb, BTA_GATT_OK);
                 //register service change
                 bta_gattc_register_service_change_notify(p_clcb->bta_conn_id, p_clcb->bda);
-            } else
+            } else 
 #endif
             { /* cache is building */
                 p_clcb->p_srcb->state = BTA_GATTC_SERV_DISC;
@@ -1073,9 +1071,8 @@ void bta_gattc_disc_cmpl(tBTA_GATTC_CLCB *p_clcb, tBTA_GATTC_DATA *p_data)
 *******************************************************************************/
 void bta_gattc_read(tBTA_GATTC_CLCB *p_clcb, tBTA_GATTC_DATA *p_data)
 {
-    if (!bta_gattc_enqueue(p_clcb, p_data)) {
+    if (!bta_gattc_enqueue(p_clcb, p_data))
         return;
-    }
 
     tGATT_READ_PARAM    read_param;
     memset (&read_param, 0 ,sizeof(tGATT_READ_PARAM));
@@ -1143,9 +1140,8 @@ void bta_gattc_read_multi(tBTA_GATTC_CLCB *p_clcb, tBTA_GATTC_DATA *p_data)
 *******************************************************************************/
 void bta_gattc_write(tBTA_GATTC_CLCB *p_clcb, tBTA_GATTC_DATA *p_data)
 {
-    if (!bta_gattc_enqueue(p_clcb, p_data)) {
+    if (!bta_gattc_enqueue(p_clcb, p_data))
         return;
-    }
 
     tBTA_GATT_STATUS    status = BTA_GATT_OK;
     tGATT_VALUE attr;
@@ -1746,7 +1742,7 @@ void bta_gattc_process_api_cache_assoc(tBTA_GATTC_CB *p_cb, tBTA_GATTC_DATA *p_m
     tBTA_GATTC gattc_cb = {0};
     gattc_cb.set_assoc.client_if = p_msg->api_assoc.client_if;
     BOOLEAN state = FALSE;
-    tBTA_GATTC_CLCB *p_assoc_clcb = bta_gattc_find_clcb_by_cif(p_msg->api_assoc.client_if,
+    tBTA_GATTC_CLCB *p_assoc_clcb = bta_gattc_find_clcb_by_cif(p_msg->api_assoc.client_if, 
                                                              p_msg->api_assoc.assoc_addr, BTA_TRANSPORT_LE);
     tBTA_GATTC_RCB *p_clrcb = bta_gattc_cl_get_regcb(p_msg->api_assoc.client_if);
     if (p_assoc_clcb != NULL) {
@@ -1787,7 +1783,7 @@ void bta_gattc_process_api_cache_assoc(tBTA_GATTC_CB *p_cb, tBTA_GATTC_DATA *p_m
     }
 
     return;
-
+ 
 }
 void bta_gattc_process_api_cache_get_addr_list(tBTA_GATTC_CB *p_cb, tBTA_GATTC_DATA *p_msg)
 {

components/bt/bluedroid/bta/gatt/bta_gattc_cache.c

@@ -93,7 +93,7 @@ static char *bta_gattc_attr_type[] = {
 };
 /* utility functions */
 
-bool display_cache_attribute(void *data, void *context)
+bool display_cache_attribute(void *data, void *context) 
 {
     //tBTA_GATTC_CACHE_ATTR *p_attr = data;
     //APPL_TRACE_ERROR("\t Attr handle[%d] uuid[0x%04x] type[%s] prop[0x%1x]",
@@ -102,7 +102,7 @@ bool display_cache_attribute(void *data, void *context)
     return true;
 }
 
-bool display_cache_service(void *data, void *context)
+bool display_cache_service(void *data, void *context) 
 {
     tBTA_GATTC_SERVICE    *p_cur_srvc = data;
     APPL_TRACE_API("Service: handle[%d ~ %d] %s[0x%04x] inst[%d]",
@@ -213,9 +213,9 @@ static void bta_gattc_free(void *ptr)
     osi_free(ptr);
 }
 
-void bta_gattc_insert_sec_service_to_cache(list_t *services, tBTA_GATTC_SERVICE *p_new_srvc)
+void bta_gattc_insert_sec_service_to_cache(list_t *services, tBTA_GATTC_SERVICE *p_new_srvc) 
 {
-    // services/p_new_srvc is NULL
+    // services/p_new_srvc is NULL 
     if (!services || !p_new_srvc) {
         APPL_TRACE_ERROR("%s services/p_new_srvc is NULL", __func__);
         return;
@@ -243,7 +243,7 @@ void bta_gattc_insert_sec_service_to_cache(list_t *services, tBTA_GATTC_SERVICE
                     return;
                 }
             }
-        }
+        }  
     }
 }
 
@@ -314,9 +314,8 @@ static tBTA_GATT_STATUS bta_gattc_add_char_to_cache(tBTA_GATTC_SERV *p_srvc_cb,
     /* TODO(jpawlowski): We should use attribute handle, not value handle to refer to characteristic.
        This is just a temporary workaround.
     */
-    if (service->e_handle < value_handle) {
+    if (service->e_handle < value_handle)
         service->e_handle = value_handle;
-    }
 
     tBTA_GATTC_CHARACTERISTIC *characteristic = osi_malloc(sizeof(tBTA_GATTC_CHARACTERISTIC));
     if (!characteristic) {
@@ -555,10 +554,10 @@ void bta_gattc_update_include_service(const list_t *services) {
             if(include_service && !include_service->included_service) {
                 //update
                 include_service->included_service = bta_gattc_find_matching_service(services, include_service->incl_srvc_s_handle);
-                if(!include_service->included_service) {
+                if(!include_service->included_service) { 
                     //not match, free it
                     list_remove(service->included_svc, include_service);
-                    osi_free(include_service);
+                    osi_free(include_service);    
                 }
             }
         }
@@ -981,13 +980,12 @@ void bta_gattc_disc_res_cback (UINT16 conn_id, tGATT_DISC_TYPE disc_type, tGATT_
                                               p_data->value.incl_service.e_handle,
                                               p_data->value.incl_service.service_type);
 
-            if (!pri_srvc) {
+            if (!pri_srvc)
                 bta_gattc_add_srvc_to_list(p_srvc_cb,
                                            p_data->value.incl_service.s_handle,
                                            p_data->value.incl_service.e_handle,
                                            p_data->value.incl_service.service_type,
                                            FALSE);
-            }
             /* add into database */
             bta_gattc_add_attr_to_cache(p_srvc_cb,
                                         p_data->handle,
@@ -1009,8 +1007,8 @@ void bta_gattc_disc_res_cback (UINT16 conn_id, tGATT_DISC_TYPE disc_type, tGATT_
 
         case GATT_DISC_CHAR_DSCPT:
             bta_gattc_add_attr_to_cache(p_srvc_cb,
-                                        p_data->handle,
-                                        &p_data->type,
+                                        p_data->handle, 
+                                        &p_data->type, 
                                         0,
                                         0 /* incl_srvc_s_handle */,
                                         0 /* incl_srvc_e_handle */,
@@ -1025,9 +1023,8 @@ void bta_gattc_disc_cmpl_cback (UINT16 conn_id, tGATT_DISC_TYPE disc_type, tGATT
     tBTA_GATTC_CLCB *p_clcb = bta_gattc_find_clcb_by_conn_id(conn_id);
 
     if ( p_clcb && (status != GATT_SUCCESS || p_clcb->status != GATT_SUCCESS) ) {
-        if (status == GATT_SUCCESS) {
+        if (status == GATT_SUCCESS)
             p_clcb->status = status;
-        }
         bta_gattc_sm_execute(p_clcb, BTA_GATTC_DISCOVER_CMPL_EVT, NULL);
         return;
     }
@@ -1074,17 +1071,15 @@ void bta_gattc_search_service(tBTA_GATTC_CLCB *p_clcb, tBT_UUID *p_uuid)
 {
     tBTA_GATTC          cb_data;
 
-    if (!p_clcb->p_srcb->p_srvc_cache || list_is_empty(p_clcb->p_srcb->p_srvc_cache)) {
+    if (!p_clcb->p_srcb->p_srvc_cache || list_is_empty(p_clcb->p_srcb->p_srvc_cache))
         return;
-    }
 
     for (list_node_t *sn = list_begin(p_clcb->p_srcb->p_srvc_cache);
          sn != list_end(p_clcb->p_srcb->p_srvc_cache); sn = list_next(sn)) {
         tBTA_GATTC_SERVICE *p_cache = list_node(sn);
 
-        if (!bta_gattc_uuid_compare(p_uuid, &p_cache->uuid, FALSE)) {
+        if (!bta_gattc_uuid_compare(p_uuid, &p_cache->uuid, FALSE))
             continue;
-        }
 
 #if (defined BTA_GATT_DEBUG && BTA_GATT_DEBUG == TRUE)
         APPL_TRACE_DEBUG("found service [0x%04x], inst[%d] handle [%d]",
@@ -1092,9 +1087,8 @@ void bta_gattc_search_service(tBTA_GATTC_CLCB *p_clcb, tBT_UUID *p_uuid)
                           p_cache->handle,
                           p_cache->s_handle);
 #endif
-        if (!p_clcb->p_rcb->p_cback) {
+        if (!p_clcb->p_rcb->p_cback)
             continue;
-        }
 
         memset(&cb_data, 0, sizeof(tBTA_GATTC));
 
@@ -1109,9 +1103,8 @@ void bta_gattc_search_service(tBTA_GATTC_CLCB *p_clcb, tBT_UUID *p_uuid)
 }
 
 list_t* bta_gattc_get_services_srcb(tBTA_GATTC_SERV *p_srcb) {
-    if (!p_srcb || !p_srcb->p_srvc_cache || list_is_empty(p_srcb->p_srvc_cache)) {
+    if (!p_srcb || !p_srcb->p_srvc_cache || list_is_empty(p_srcb->p_srvc_cache))
         return NULL;
-    }
 
     return p_srcb->p_srvc_cache;
 }
@@ -1119,9 +1112,8 @@ list_t* bta_gattc_get_services_srcb(tBTA_GATTC_SERV *p_srcb) {
 const list_t* bta_gattc_get_services(UINT16 conn_id) {
     tBTA_GATTC_CLCB *p_clcb = bta_gattc_find_clcb_by_conn_id(conn_id);
 
-    if (p_clcb == NULL ) {
+    if (p_clcb == NULL )
         return NULL;
-    }
 
     tBTA_GATTC_SERV *p_srcb = p_clcb->p_srcb;
 
@@ -1129,68 +1121,63 @@ const list_t* bta_gattc_get_services(UINT16 conn_id) {
 }
 
 tBTA_GATTC_SERVICE*  bta_gattc_find_matching_service(const list_t *services, UINT16 handle) {
-    if (!services || list_is_empty(services)) {
+    if (!services || list_is_empty(services))
         return NULL;
-    }
 
     for (list_node_t *sn = list_begin(services);
          sn != list_end(services); sn = list_next(sn)) {
         tBTA_GATTC_SERVICE *service = list_node(sn);
 
-        if (handle >= service->s_handle && handle <= service->e_handle) {
+        if (handle >= service->s_handle && handle <= service->e_handle)
             return service;
-        }
     }
 
     return NULL;
 }
 
-const tBTA_GATTC_SERVICE*  bta_gattc_get_service_for_handle_srcb(tBTA_GATTC_SERV *p_srcb, UINT16 handle)
+const tBTA_GATTC_SERVICE*  bta_gattc_get_service_for_handle_srcb(tBTA_GATTC_SERV *p_srcb, UINT16 handle) 
 {
     const list_t *services = bta_gattc_get_services_srcb(p_srcb);
 
     return bta_gattc_find_matching_service(services, handle);
 }
 
-const tBTA_GATTC_SERVICE*  bta_gattc_get_service_for_handle(UINT16 conn_id, UINT16 handle)
+const tBTA_GATTC_SERVICE*  bta_gattc_get_service_for_handle(UINT16 conn_id, UINT16 handle) 
 {
     const list_t *services = bta_gattc_get_services(conn_id);
 
     return bta_gattc_find_matching_service(services, handle);
 }
 
-tBTA_GATTC_CHARACTERISTIC*  bta_gattc_get_characteristic_srcb(tBTA_GATTC_SERV *p_srcb, UINT16 handle)
+tBTA_GATTC_CHARACTERISTIC*  bta_gattc_get_characteristic_srcb(tBTA_GATTC_SERV *p_srcb, UINT16 handle) 
 {
     const tBTA_GATTC_SERVICE* service = bta_gattc_get_service_for_handle_srcb(p_srcb, handle);
 
-    if (!service) {
+    if (!service)
         return NULL;
-    }
 
     for (list_node_t *cn = list_begin(service->characteristics);
          cn != list_end(service->characteristics); cn = list_next(cn)) {
         tBTA_GATTC_CHARACTERISTIC *p_char = list_node(cn);
-        if (handle == p_char->handle) {
+        if (handle == p_char->handle)
             return p_char;
-        }
     }
 
     return NULL;
 }
 
-tBTA_GATTC_CHARACTERISTIC*  bta_gattc_get_characteristic(UINT16 conn_id, UINT16 handle)
+tBTA_GATTC_CHARACTERISTIC*  bta_gattc_get_characteristic(UINT16 conn_id, UINT16 handle) 
 {
    tBTA_GATTC_CLCB *p_clcb = bta_gattc_find_clcb_by_conn_id(conn_id);
 
-    if (p_clcb == NULL ) {
+    if (p_clcb == NULL )
         return NULL;
-    }
 
     tBTA_GATTC_SERV *p_srcb = p_clcb->p_srcb;
     return bta_gattc_get_characteristic_srcb(p_srcb, handle);
 }
 
-tBTA_GATTC_DESCRIPTOR*  bta_gattc_get_descriptor_srcb(tBTA_GATTC_SERV *p_srcb, UINT16 handle)
+tBTA_GATTC_DESCRIPTOR*  bta_gattc_get_descriptor_srcb(tBTA_GATTC_SERV *p_srcb, UINT16 handle) 
 {
     const tBTA_GATTC_SERVICE* service = bta_gattc_get_service_for_handle_srcb(p_srcb, handle);
 
@@ -1204,22 +1191,20 @@ tBTA_GATTC_DESCRIPTOR*  bta_gattc_get_descriptor_srcb(tBTA_GATTC_SERV *p_srcb, U
         for (list_node_t *dn = list_begin(p_char->descriptors);
              dn != list_end(p_char->descriptors); dn = list_next(dn)) {
             tBTA_GATTC_DESCRIPTOR *p_desc = list_node(dn);
-            if (handle == p_desc->handle) {
+            if (handle == p_desc->handle)
                 return p_desc;
-            }
         }
     }
 
     return NULL;
 }
 
-tBTA_GATTC_DESCRIPTOR*  bta_gattc_get_descriptor(UINT16 conn_id, UINT16 handle)
+tBTA_GATTC_DESCRIPTOR*  bta_gattc_get_descriptor(UINT16 conn_id, UINT16 handle) 
 {
     tBTA_GATTC_CLCB *p_clcb = bta_gattc_find_clcb_by_conn_id(conn_id);
 
-    if (p_clcb == NULL ) {
+    if (p_clcb == NULL )
         return NULL;
-    }
 
     tBTA_GATTC_SERV *p_srcb = p_clcb->p_srcb;
     return bta_gattc_get_descriptor_srcb(p_srcb, handle);
@@ -1458,7 +1443,7 @@ void bta_gattc_get_db_with_opration(UINT16 conn_id,
                     }
                 }
             }
-
+            
         }
     }
 
@@ -1491,7 +1476,7 @@ static size_t bta_gattc_get_db_size_with_type(list_t *services,
         }
 
         if (type == BTGATT_DB_PRIMARY_SERVICE || type == BTGATT_DB_SECONDARY_SERVICE) {
-            if ((type == BTGATT_DB_PRIMARY_SERVICE && p_cur_srvc->is_primary) ||
+            if ((type == BTGATT_DB_PRIMARY_SERVICE && p_cur_srvc->is_primary) || 
                 (type == BTGATT_DB_SECONDARY_SERVICE && !p_cur_srvc->is_primary)) {
                 // if the current service is the last service in the db, need to ensure the current service start handle is not less than the start_handle.
                 if (!svc_length) {
@@ -1587,11 +1572,10 @@ static size_t bta_gattc_get_db_size_with_type(list_t *services,
 ** Returns          number of elements inside db from start_handle to end_handle
 *******************************************************************************/
 static size_t bta_gattc_get_db_size(list_t *services,
-                                    UINT16 start_handle, UINT16 end_handle)
+                                    UINT16 start_handle, UINT16 end_handle) 
 {
-    if (!services || list_is_empty(services)) {
+    if (!services || list_is_empty(services))
         return 0;
-    }
 
     size_t db_size = 0;
     UINT16 svc_length = list_length(services) - 1;
@@ -1614,10 +1598,9 @@ static size_t bta_gattc_get_db_size(list_t *services,
         } else {
             db_size++;
         }
-
-        if (!p_cur_srvc->characteristics || list_is_empty(p_cur_srvc->characteristics)) {
+        
+        if (!p_cur_srvc->characteristics || list_is_empty(p_cur_srvc->characteristics))
             continue;
-        }
 
         for (list_node_t *cn = list_begin(p_cur_srvc->characteristics);
              cn != list_end(p_cur_srvc->characteristics); cn = list_next(cn)) {
@@ -1674,7 +1657,7 @@ void bta_gattc_get_db_size_handle(UINT16 conn_id, UINT16 start_handle, UINT16 en
         *count = 0;
         return;
     }
-
+    
     tBTA_GATTC_SERV *p_srcb = p_clcb->p_srcb;
     if (!p_srcb->p_srvc_cache || list_is_empty(p_srcb->p_srvc_cache)) {
         *count = 0;
@@ -1693,7 +1676,7 @@ void bta_gattc_get_db_size_with_type_handle(UINT16 conn_id, bt_gatt_db_attribute
         *count = 0;
         return;
     }
-
+    
     tBTA_GATTC_SERV *p_srcb = p_clcb->p_srcb;
     if (!p_srcb->p_srvc_cache || list_is_empty(p_srcb->p_srvc_cache)) {
         *count = 0;
@@ -1711,7 +1694,7 @@ void bta_gattc_get_db_size_with_type_handle(UINT16 conn_id, bt_gatt_db_attribute
         }
     }
     *count = bta_gattc_get_db_size_with_type(p_srcb->p_srvc_cache, type, NULL, start_handle, end_handle);
-
+    
 }
 
 /*******************************************************************************
@@ -1803,9 +1786,8 @@ static void bta_gattc_get_gatt_db_impl(tBTA_GATTC_SERV *p_srvc_cb,
                                           p_char->properties);
                 curr_db_attr++;
 
-                if (!p_char->descriptors || list_is_empty(p_char->descriptors)) {
+                if (!p_char->descriptors || list_is_empty(p_char->descriptors))
                     continue;
-                }
 
                 for (list_node_t *dn = list_begin(p_char->descriptors);
                      dn != list_end(p_char->descriptors); dn = list_next(dn)) {
@@ -1833,9 +1815,8 @@ static void bta_gattc_get_gatt_db_impl(tBTA_GATTC_SERV *p_srvc_cb,
             }
         }
 
-        if (!p_cur_srvc->included_svc || list_is_empty(p_cur_srvc->included_svc)) {
+        if (!p_cur_srvc->included_svc || list_is_empty(p_cur_srvc->included_svc))
             continue;
-        }
 
         for (list_node_t *isn = list_begin(p_cur_srvc->included_svc);
              isn != list_end(p_cur_srvc->included_svc); isn = list_next(isn)) {
@@ -2002,9 +1983,8 @@ void bta_gattc_fill_nv_attr(tBTA_GATTC_NV_ATTR *p_attr, UINT8 type, UINT16 s_han
 *******************************************************************************/
 void bta_gattc_cache_save(tBTA_GATTC_SERV *p_srvc_cb, UINT16 conn_id)
 {
-    if (!p_srvc_cb->p_srvc_cache || list_is_empty(p_srvc_cb->p_srvc_cache)) {
+    if (!p_srvc_cb->p_srvc_cache || list_is_empty(p_srvc_cb->p_srvc_cache))
         return;
-    }
 
     int i = 0;
     size_t db_size = bta_gattc_get_db_size(p_srvc_cb->p_srvc_cache, 0x0000, 0xFFFF);
@@ -2037,9 +2017,8 @@ void bta_gattc_cache_save(tBTA_GATTC_SERV *p_srvc_cb, UINT16 conn_id)
          sn != list_end(p_srvc_cb->p_srvc_cache); sn = list_next(sn)) {
         tBTA_GATTC_SERVICE *p_cur_srvc = list_node(sn);
 
-        if (!p_cur_srvc->characteristics || list_is_empty(p_cur_srvc->characteristics)) {
+        if (!p_cur_srvc->characteristics || list_is_empty(p_cur_srvc->characteristics))
             continue;
-        }
 
         for (list_node_t *cn = list_begin(p_cur_srvc->characteristics);
              cn != list_end(p_cur_srvc->characteristics); cn = list_next(cn)) {
@@ -2055,9 +2034,8 @@ void bta_gattc_cache_save(tBTA_GATTC_SERV *p_srvc_cb, UINT16 conn_id)
                                    0 /* incl_srvc_e_handle */,
                                    FALSE);
 
-            if (!p_char->descriptors || list_is_empty(p_char->descriptors)) {
+            if (!p_char->descriptors || list_is_empty(p_char->descriptors))
                 continue;
-            }
 
             for (list_node_t *dn = list_begin(p_char->descriptors);
                  dn != list_end(p_char->descriptors); dn = list_next(dn)) {
@@ -2075,9 +2053,8 @@ void bta_gattc_cache_save(tBTA_GATTC_SERV *p_srvc_cb, UINT16 conn_id)
             }
         }
 
-        if (!p_cur_srvc->included_svc || list_is_empty(p_cur_srvc->included_svc)) {
+        if (!p_cur_srvc->included_svc || list_is_empty(p_cur_srvc->included_svc))
             continue;
-        }
 
         for (list_node_t *an = list_begin(p_cur_srvc->included_svc);
              an != list_end(p_cur_srvc->included_svc); an = list_next(an)) {

components/bt/bluedroid/bta/gatt/bta_gattc_co.c

@@ -261,18 +261,14 @@ tBTA_GATT_STATUS bta_gattc_co_cache_open(BD_ADDR server_bda, BOOLEAN to_save, UI
 *******************************************************************************/
 tBTA_GATT_STATUS bta_gattc_co_cache_load(tBTA_GATTC_NV_ATTR *attr, UINT8 index)
 {
-#if (!CONFIG_BT_STACK_NO_LOG)
     UINT16              num_attr = 0;
-#endif
     tBTA_GATT_STATUS    status = BTA_GATT_ERROR;
     size_t length = 0;
     // Read the size of memory space required for blob
     nvs_get_blob(cache_env.cache_addr[index].cache_fp, cache_key, NULL, &length);
     // Read previously saved blob if available
     esp_err_t err_code = nvs_get_blob(cache_env.cache_addr[index].cache_fp, cache_key, attr, &length);
-#if (!CONFIG_BT_STACK_NO_LOG)
     num_attr = length / sizeof(tBTA_GATTC_NV_ATTR);
-#endif
     status = (err_code == ESP_OK && length != 0) ? BTA_GATT_OK : BTA_GATT_ERROR;
     APPL_TRACE_DEBUG("%s() - read=%d, status=%d, err_code = %d",
                      __func__, num_attr, status, err_code);
@@ -327,9 +323,6 @@ void bta_gattc_co_cache_save (BD_ADDR server_bda, UINT16 num_attr,
         status = BTA_GATT_ERROR;
     }
 
-#if CONFIG_BT_STACK_NO_LOG
-    (void) status;
-#endif
     APPL_TRACE_DEBUG("%s() wrote hash_key = %x%x%x%x, num_attr = %d, status = %d.", __func__, hash_key[0], hash_key[1], hash_key[2], hash_key[3], num_attr, status);
 }
 

components/bt/bluedroid/bta/gatt/bta_gattc_utils.c

@@ -416,9 +416,8 @@ tBTA_GATTC_SERV *bta_gattc_srcb_alloc(BD_ADDR bda)
 
     if (p_tcb != NULL)
     {
-        if (p_tcb->p_srvc_cache != NULL) {
+        if (p_tcb->p_srvc_cache != NULL)
             list_free(p_tcb->p_srvc_cache);
-        }
         osi_free(p_tcb->p_srvc_list);
         p_tcb->p_srvc_list = NULL;
         //osi_free_and_reset((void **)&p_tcb->p_srvc_list);
@@ -584,9 +583,8 @@ void bta_gattc_clear_notif_registration(tBTA_GATTC_SERV *p_srcb, UINT16 conn_id,
                      * clear boundaries are always around service.
                      */
                     handle = p_clrcb->notif_reg[i].handle;
-                    if (handle >= start_handle && handle <= end_handle) {
+                    if (handle >= start_handle && handle <= end_handle)
                         memset(&p_clrcb->notif_reg[i], 0, sizeof(tBTA_GATTC_NOTIF_REG));
-                    }
                 }
             }
         }
@@ -639,9 +637,8 @@ BOOLEAN bta_gattc_mark_bg_conn (tBTA_GATTC_IF client_if,  BD_ADDR_PTR remote_bda
     }
     if (!add) {
         if (remote_bda_ptr) {
-#if (!CONFIG_BT_STACK_NO_LOG)
+            // bdstr_t bdstr = {0};
             char bdstr[18] = {0};
-#endif
             APPL_TRACE_ERROR("%s unable to find the bg connection mask for: %s", __func__,
                              bdaddr_to_string((bt_bdaddr_t *)remote_bda_ptr, bdstr, sizeof(bdstr)));
         }
@@ -939,9 +936,8 @@ void bta_to_btif_uuid(bt_uuid_t *p_dest, tBT_UUID *p_src)
 
     if (p_src->len == LEN_UUID_16 || p_src->len == LEN_UUID_32)
     {
-        for(i=0; i != 16; ++i) {
+        for(i=0; i != 16; ++i)
             p_dest->uu[i] = base_uuid[i];
-        }
     }
 
     switch (p_src->len)

components/bt/bluedroid/bta/gatt/bta_gatts_act.c

@@ -403,7 +403,7 @@ void bta_gatts_add_char(tBTA_GATTS_SRVC_CB *p_srvc_cb, tBTA_GATTS_DATA *p_msg)
     UINT16          attr_id = 0;
     tBTA_GATTS      cb_data;
 
-    tGATT_ATTR_VAL *p_attr_val = NULL;
+    tGATT_ATTR_VAL *p_attr_val = NULL; 
     tGATTS_ATTR_CONTROL *p_control = NULL;
 
     if(p_msg->api_add_char.attr_val.attr_max_len != 0){
@@ -665,18 +665,17 @@ void bta_gatts_indicate_handle (tBTA_GATTS_CB *p_cb, tBTA_GATTS_DATA *p_msg)
                                     &gatt_if, remote_bda, &transport)) {
             p_rcb = bta_gatts_find_app_rcb_by_app_if(gatt_if);
 
-            if (p_msg->api_indicate.need_confirm) {
+            if (p_msg->api_indicate.need_confirm)
 
                 status = GATTS_HandleValueIndication (p_msg->api_indicate.hdr.layer_specific,
                                                       p_msg->api_indicate.attr_id,
                                                       p_msg->api_indicate.len,
                                                       p_msg->api_indicate.value);
-            } else {
+            else
                 status = GATTS_HandleValueNotification (p_msg->api_indicate.hdr.layer_specific,
                                                         p_msg->api_indicate.attr_id,
                                                         p_msg->api_indicate.len,
                                                         p_msg->api_indicate.value);
-            }
 
             /* if over BR_EDR, inform PM for mode change */
             if (transport == BTA_TRANSPORT_BR_EDR) {
@@ -692,16 +691,25 @@ void bta_gatts_indicate_handle (tBTA_GATTS_CB *p_cb, tBTA_GATTS_DATA *p_msg)
                 p_rcb && p_cb->rcb[p_srvc_cb->rcb_idx].p_cback) {
             cb_data.req_data.status = status;
             cb_data.req_data.conn_id = p_msg->api_indicate.hdr.layer_specific;
+            cb_data.req_data.value = NULL;
+            cb_data.req_data.data_len = 0;
             cb_data.req_data.handle = p_msg->api_indicate.attr_id;
 
-            cb_data.req_data.value = (uint8_t *)osi_malloc(p_msg->api_indicate.len);
-            if (cb_data.req_data.value != NULL){
-                memset(cb_data.req_data.value, 0, p_msg->api_indicate.len);
-                cb_data.req_data.data_len = p_msg->api_indicate.len;
-                memcpy(cb_data.req_data.value, p_msg->api_indicate.value, p_msg->api_indicate.len);
-            }else{
-                cb_data.req_data.data_len = 0;
-                APPL_TRACE_ERROR("%s, malloc failed", __func__);
+            if (p_msg->api_indicate.value && (p_msg->api_indicate.len > 0)) {
+                cb_data.req_data.value = (uint8_t *) osi_malloc(p_msg->api_indicate.len);
+                if (cb_data.req_data.value != NULL) {
+                    memset(cb_data.req_data.value, 0, p_msg->api_indicate.len);
+                    cb_data.req_data.data_len = p_msg->api_indicate.len;
+                    memcpy(cb_data.req_data.value, p_msg->api_indicate.value, p_msg->api_indicate.len);
+                } else {
+                    APPL_TRACE_ERROR("%s, malloc failed", __func__);
+                }
+            } else {
+                if (p_msg->api_indicate.value) {
+                    APPL_TRACE_ERROR("%s, incorrect length", __func__);
+                } else {
+                    APPL_TRACE_WARNING("%s, NULL value", __func__);
+                }
             }
             (*p_rcb->p_cback)(BTA_GATTS_CONF_EVT, &cb_data);
             if (cb_data.req_data.value != NULL) {
@@ -852,13 +860,13 @@ void bta_gatts_send_service_change_indication (tBTA_GATTS_DATA *p_msg)
         memcpy(bd_addr, p_msg->api_send_service_change.remote_bda, BD_ADDR_LEN);
         status = GATT_SendServiceChangeIndication(bd_addr);
     } else {
-        status = GATT_SendServiceChangeIndication(NULL);
+        status = GATT_SendServiceChangeIndication(NULL);    
     }
     if (p_rcb && p_rcb->p_cback) {
         service_change.status = status;
         service_change.server_if = p_msg->api_send_service_change.server_if;
         (*p_rcb->p_cback)(BTA_GATTS_SEND_SERVICE_CHANGE_EVT,  (tBTA_GATTS *)&service_change);
-    }
+    }   
 }
 
 /*******************************************************************************
@@ -933,9 +941,6 @@ static void bta_gatts_send_request_cback (UINT16 conn_id,
             cb_data.req_data.trans_id   = trans_id;
             cb_data.req_data.p_data     = (tBTA_GATTS_REQ_DATA *)p_data;
 
-            if(req_type == BTA_GATTS_CONF_EVT) {
-               cb_data.req_data.handle =  p_data->handle;
-            }
             (*p_rcb->p_cback)(req_type,  &cb_data);
         } else {
             APPL_TRACE_ERROR("connection request on gatt_if[%d] is not interested", gatt_if);

components/bt/bluedroid/bta/hf_client/bta_hf_client_at.c

@@ -1159,7 +1159,6 @@ static char *bta_hf_client_skip_unknown(char *buffer)
     buffer = tmp + 2;
 
     APPL_TRACE_DEBUG("%s %.*s", __FUNCTION__, buffer - start - 2, start);
-    UNUSED(start);
 
     return buffer;
 }

components/bt/bluedroid/bta/hf_client/bta_hf_client_sco.c

@@ -308,7 +308,6 @@ static void bta_hf_client_sco_disc_cback(UINT16 sco_idx)
 #if (BTM_SCO_HCI_INCLUDED == TRUE )
         tBTM_STATUS status = BTM_ConfigScoPath(BTM_SCO_ROUTE_PCM, NULL, NULL, TRUE);
         APPL_TRACE_DEBUG("%s close config status = %d", __FUNCTION__, status);
-        UNUSED(status);
         /* SCO clean up here */
         bta_hf_client_sco_co_close();
 #endif

components/bt/bluedroid/bta/hh/bta_hh_act.c

@@ -101,10 +101,8 @@ void bta_hh_api_enable(tBTA_HH_DATA *p_data)
         bta_hh_le_enable();
     } else
 #endif
-    {
         /* signal BTA call back event */
         (* bta_hh_cb.p_cback)(BTA_HH_ENABLE_EVT, (tBTA_HH *)&status);
-    }
 }
 /*******************************************************************************
 **
@@ -903,9 +901,7 @@ void bta_hh_get_dscp_act(tBTA_HH_DEV_CB *p_cb, tBTA_HH_DATA *p_data)
         bta_hh_le_get_dscp_act(p_cb);
     } else
 #endif
-    {
         (*bta_hh_cb.p_cback)(BTA_HH_GET_DSCP_EVT, (tBTA_HH *)&p_cb->dscp_info);
-    }
 }
 
 /*******************************************************************************
@@ -938,10 +934,11 @@ void bta_hh_maint_dev_act(tBTA_HH_DEV_CB *p_cb, tBTA_HH_DATA *p_data)
                 dev_info.status   = BTA_HH_OK;
             } else
 #endif
-            {
+
                 if (HID_HostAddDev(p_dev_info->bda, p_dev_info->attr_mask, &dev_handle)\
                         == HID_SUCCESS) {
                     dev_info.handle   = dev_handle;
+                    dev_info.status   = BTA_HH_OK;
 
 #if (defined BTA_HH_LE_INCLUDED && BTA_HH_LE_INCLUDED == TRUE)
                     /* update DI information */
@@ -969,7 +966,6 @@ void bta_hh_maint_dev_act(tBTA_HH_DEV_CB *p_cb, tBTA_HH_DATA *p_data)
                     /* update cb_index[] map */
                     bta_hh_cb.cb_index[dev_handle] = p_cb->index;
                 }
-            }
         } else { /* device already been added */
             dev_info.handle = p_cb->hid_handle;
             dev_info.status = BTA_HH_OK;

components/bt/bluedroid/bta/hh/bta_hh_le.c

@@ -2183,10 +2183,9 @@ void bta_hh_le_write_char_descr_cmpl(tBTA_HH_DEV_CB *p_dev_cb, tBTA_HH_DATA *p_b
         case GATT_UUID_HID_BT_KB_INPUT:
         case GATT_UUID_HID_BT_MOUSE_INPUT:
         case GATT_UUID_HID_REPORT:
-            if (p_data->status == BTA_GATT_OK) {
+            if (p_data->status == BTA_GATT_OK)
                 p_dev_cb->hid_srvc[hid_inst_id].report[p_dev_cb->clt_cfg_idx].client_cfg_value =
                     BTA_GATT_CLT_CONFIG_NOTIFICATION;
-            }
             p_dev_cb->clt_cfg_idx ++;
             bta_hh_le_write_rpt_clt_cfg(p_dev_cb, hid_inst_id);
 

components/bt/bluedroid/bta/hh/bta_hh_utils.c

@@ -75,12 +75,11 @@ UINT8  bta_hh_find_cb(BD_ADDR bda)
             return xx;
         }
 #if BTA_HH_DEBUG
-        else {
+        else
             APPL_TRACE_DEBUG("in_use ? [%d] kdev[%d].hid_handle = %d state = [%d]",
                              bta_hh_cb.kdev[xx].in_use, xx,
                              bta_hh_cb.kdev[xx].hid_handle,
                              bta_hh_cb.kdev[xx].state);
-        }
 #endif
     }
 
@@ -124,9 +123,7 @@ void bta_hh_clean_up_kdev(tBTA_HH_DEV_CB *p_cb)
             bta_hh_cb.le_cb_index[BTA_HH_GET_LE_CB_IDX(p_cb->hid_handle)] = BTA_HH_IDX_INVALID;
         } else
 #endif
-        {
             bta_hh_cb.cb_index[p_cb->hid_handle] = BTA_HH_IDX_INVALID;
-        }
     }
 
     /* reset device control block */
@@ -489,12 +486,11 @@ UINT8 bta_hh_dev_handle_to_cb_idx(UINT8 dev_handle)
 #endif
     } else
 #endif
-    {
         /* regular HID device checking */
         if (dev_handle < BTA_HH_MAX_KNOWN ) {
             index = bta_hh_cb.cb_index[dev_handle];
         }
-    }
+
     return index;
 
 }

components/bt/bluedroid/bta/include/bta/bta_api.h

@@ -1024,7 +1024,6 @@ typedef struct {
 #define BTA_DM_DISC_CMPL_EVT            4       /* Discovery complete. */
 #define BTA_DM_DI_DISC_CMPL_EVT         5       /* Discovery complete. */
 #define BTA_DM_SEARCH_CANCEL_CMPL_EVT   6       /* Search cancelled */
-#define BTA_DM_INQ_DISCARD_NUM_EVT      7       /* The number of inquiry discarded packets */
 
 typedef UINT8 tBTA_DM_SEARCH_EVT;
 
@@ -1056,11 +1055,6 @@ typedef struct {
     UINT8           num_resps;          /* Number of inquiry responses. */
 } tBTA_DM_INQ_CMPL;
 
-/* Structure associated with BTA_DM_INQ_DISCARD_NUM_EVT */
-typedef struct {
-    UINT32           num_dis;          /* The number of inquiry discarded packets. */
-} tBTA_DM_INQ_DISCARD;
-
 /* Structure associated with BTA_DM_DI_DISC_CMPL_EVT */
 typedef struct {
     BD_ADDR             bd_addr;        /* BD address peer device. */
@@ -1098,7 +1092,6 @@ typedef union {
     tBTA_DM_DISC_RES    disc_res;       /* Discovery result for a peer device. */
     tBTA_DM_DISC_BLE_RES    disc_ble_res;   /* Discovery result for GATT based service */
     tBTA_DM_DI_DISC_CMPL    di_disc;        /* DI discovery result for a peer device */
-    tBTA_DM_INQ_DISCARD     inq_dis;       /* the discarded packets information of inquiry */
 } tBTA_DM_SEARCH;
 
 /* Structure of search callback event and structures */
@@ -1625,6 +1618,22 @@ extern void BTA_DmPinReply(BD_ADDR bd_addr, BOOLEAN accept, UINT8 pin_len,
 **
 *******************************************************************************/
 extern void BTA_DmLocalOob(void);
+
+/*******************************************************************************
+**
+** Function         BTA_DmOobReply
+**
+**                  This function is called to provide the OOB data for
+**                  SMP in response to BTM_LE_OOB_REQ_EVT
+**
+** Parameters:      bd_addr     - Address of the peer device
+**                  len         - length of simple pairing Randomizer  C
+**                  p_value     - simple pairing Randomizer  C.
+**
+** Returns          void
+**
+*******************************************************************************/
+extern void BTA_DmOobReply(BD_ADDR bd_addr, UINT8 len, UINT8 *p_value);
 #endif /* BTM_OOB_INCLUDED */
 
 /*******************************************************************************
@@ -1879,13 +1888,12 @@ extern void BTA_DmBleConfirmReply(BD_ADDR bd_addr, BOOLEAN accept);
 **
 ** Parameters:      bd_addr          - BD address of the peer
 **                  dev_type         - Remote device's device type.
-**                  auth_mode        - auth mode
 **                  addr_type        - LE device address type.
 **
 ** Returns          void
 **
 *******************************************************************************/
-extern void BTA_DmAddBleDevice(BD_ADDR bd_addr, tBLE_ADDR_TYPE addr_type, int auth_mode,
+extern void BTA_DmAddBleDevice(BD_ADDR bd_addr, tBLE_ADDR_TYPE addr_type,
                                tBT_DEVICE_TYPE dev_type);
 
 
@@ -2215,6 +2223,22 @@ extern void BTA_DmBleSetAdvConfig (tBTA_BLE_AD_MASK data_mask,
 extern void BTA_DmBleSetAdvConfigRaw (UINT8 *p_raw_adv, UINT32 raw_adv_len,
                             tBTA_SET_ADV_DATA_CMPL_CBACK *p_adv_data_cback);
 
+/*******************************************************************************
+**
+** Function         BTA_DmBleSetLongAdv
+**
+** Description      This function is called to set long Advertising data
+**
+** Parameters       adv_data : long advertising data.
+**                  adv_data_len : long advertising data length.
+**                  p_adv_data_cback : set long adv data complete callback.
+**
+** Returns          None
+**
+*******************************************************************************/
+void BTA_DmBleSetLongAdv (UINT8 *adv_data, UINT32 adv_data_len,
+                            tBTA_SET_ADV_DATA_CMPL_CBACK *p_adv_data_cback);
+
 /*******************************************************************************
 **
 ** Function         BTA_DmBleSetScanRsp

components/bt/bluedroid/bta/include/bta/bta_dm_co.h

@@ -210,4 +210,6 @@ extern void bta_dm_co_ble_set_accept_auth_enable(UINT8 enable);
 extern UINT8 bta_dm_co_ble_get_accept_auth_enable(void);
 
 extern UINT8 bta_dm_co_ble_get_auth_req(void);
+
+extern void bta_dm_co_ble_oob_support(UINT8 enable);
 #endif

components/bt/bluedroid/bta/jv/bta_jv_act.c

@@ -26,7 +26,6 @@
 #include <stdlib.h>
 
 #include "osi/allocator.h"
-#include "osi/osi.h"
 #include "stack/bt_types.h"
 #include "bta/utl.h"
 #include "bta/bta_sys.h"
@@ -138,7 +137,7 @@ UINT8 bta_jv_alloc_sec_id(void)
     return ret;
 
 }
-UNUSED_ATTR static int get_sec_id_used(void)
+static int get_sec_id_used(void)
 {
     int i;
     int used = 0;
@@ -147,13 +146,12 @@ UNUSED_ATTR static int get_sec_id_used(void)
             used++;
         }
     }
-    if (used == BTA_JV_NUM_SERVICE_ID) {
+    if (used == BTA_JV_NUM_SERVICE_ID)
         APPL_TRACE_ERROR("get_sec_id_used, sec id exceeds the limit:%d",
                          BTA_JV_NUM_SERVICE_ID);
-    }
     return used;
 }
-UNUSED_ATTR static int get_rfc_cb_used(void)
+static int get_rfc_cb_used(void)
 {
     int i;
     int used = 0;
@@ -162,10 +160,9 @@ UNUSED_ATTR static int get_rfc_cb_used(void)
             used++;
         }
     }
-    if (used == BTA_JV_MAX_RFC_CONN) {
+    if (used == BTA_JV_MAX_RFC_CONN)
         APPL_TRACE_ERROR("get_sec_id_used, rfc ctrl block exceeds the limit:%d",
                          BTA_JV_MAX_RFC_CONN);
-    }
     return used;
 }
 
@@ -477,21 +474,19 @@ static tBTA_JV_STATUS bta_jv_free_set_pm_profile_cb(UINT32 jv_handle)
                         < BTA_JV_MAX_RFC_SR_SESSION && bta_jv_cb.rfc_cb[hi].rfc_hdl[si]) {
                     tBTA_JV_PCB *p_pcb = bta_jv_rfc_port_to_pcb(bta_jv_cb.rfc_cb[hi].rfc_hdl[si]);
                     if (p_pcb) {
-                        if (NULL == p_pcb->p_pm_cb) {
+                        if (NULL == p_pcb->p_pm_cb)
                             APPL_TRACE_WARNING("%s(jv_handle:"
                                                " 0x%x):port_handle: 0x%x, p_pm_cb: %d: no link to "
                                                "pm_cb?", __func__, jv_handle, p_pcb->port_handle, i);
-                        }
                         p_cb = &p_pcb->p_pm_cb;
                     }
                 }
             } else {
                 if (jv_handle < BTA_JV_MAX_L2C_CONN) {
                     tBTA_JV_L2C_CB *p_l2c_cb = &bta_jv_cb.l2c_cb[jv_handle];
-                    if (NULL == p_l2c_cb->p_pm_cb) {
+                    if (NULL == p_l2c_cb->p_pm_cb)
                         APPL_TRACE_WARNING("%s(jv_handle: "
                                            "0x%x): p_pm_cb: %d: no link to pm_cb?", __func__, jv_handle, i);
-                    }
                     p_cb = &p_l2c_cb->p_pm_cb;
                 }
             }
@@ -747,10 +742,9 @@ void bta_jv_get_channel_id(tBTA_JV_MSG *p_data)
             bta_jv_cb.scn[channel - 1] = TRUE;
             scn = (UINT8) channel;
         }
-        if (bta_jv_cb.p_dm_cback) {
+        if (bta_jv_cb.p_dm_cback)
             bta_jv_cb.p_dm_cback(BTA_JV_GET_SCN_EVT, (tBTA_JV *)&scn,
                                  p_data->alloc_channel.user_data);
-        }
         return;
     }
     case BTA_JV_CONN_TYPE_L2CAP:
@@ -1004,9 +998,6 @@ static bool create_base_record(const uint32_t sdp_handle, const char *name, cons
     APPL_TRACE_DEBUG("create_base_record: successfully created base service "
                    "record, handle: 0x%08x, scn: %d, name: %s, with_obex: %d",
                    sdp_handle, channel, name, with_obex);
-
-    UNUSED(stage);
-
     return TRUE;
 }
 
@@ -1040,8 +1031,6 @@ static int add_spp_sdp(const char *name, const int channel) {
 
     APPL_TRACE_DEBUG("add_spp_sdp: service registered successfully, "
                    "service_name: %s, handle 0x%08x)", name, handle);
-    UNUSED(stage);
-
     return handle;
 }
 
@@ -1534,7 +1523,6 @@ static int bta_jv_port_data_co_cback(UINT16 port_handle, UINT8 *buf, UINT16 len,
     tBTA_JV_PCB     *p_pcb = bta_jv_rfc_port_to_pcb(port_handle);
     int ret = 0;
     APPL_TRACE_DEBUG("%s, p_cb:%p, p_pcb:%p, len:%d, type:%d", __func__, p_cb, p_pcb, len, type);
-    UNUSED(p_cb);
     if (p_pcb != NULL) {
         switch (type) {
         case DATA_CO_CALLBACK_TYPE_INCOMING:

components/bt/bluedroid/btc/core/btc_ble_storage.c

@@ -553,91 +553,6 @@ bt_status_t btc_storage_remove_ble_dev_type(bt_bdaddr_t *remote_bd_addr, bool fl
     return ret;
 }
 
-static bt_status_t _btc_storage_set_ble_dev_auth_mode(bt_bdaddr_t *remote_bd_addr, uint8_t auth_mode, bool flush)
-{
-    int ret;
-    bdstr_t bdstr;
-
-    bdaddr_to_string(remote_bd_addr, bdstr, sizeof(bdstr_t));
-    ret = btc_config_set_int(bdstr, BTC_BLE_STORAGE_LE_AUTH_MODE_STR, (int)auth_mode);
-    if (ret == false) {
-        return BT_STATUS_FAIL;
-    }
-
-    if (flush) {
-        _btc_storage_save();
-    }
-
-    return BT_STATUS_SUCCESS;
-}
-
-bt_status_t btc_storage_set_ble_dev_auth_mode(bt_bdaddr_t *remote_bd_addr, uint8_t auth_mode, bool flush)
-{
-    bt_status_t ret;
-
-    btc_config_lock();
-    ret = _btc_storage_set_ble_dev_auth_mode(remote_bd_addr, auth_mode, flush);
-    btc_config_unlock();
-
-    return ret;
-}
-
-static bt_status_t _btc_storage_get_ble_dev_auth_mode(bt_bdaddr_t *remote_bd_addr, int* auth_mode)
-{
-    bdstr_t bdstr;
-    bdaddr_to_string(remote_bd_addr, bdstr, sizeof(bdstr));
-    int ret = btc_config_get_int(bdstr, BTC_BLE_STORAGE_LE_AUTH_MODE_STR, auth_mode);
-    return ret ? BT_STATUS_SUCCESS : BT_STATUS_FAIL;
-}
-
-bt_status_t btc_storage_get_ble_dev_auth_mode(bt_bdaddr_t *remote_bd_addr, int* auth_mode)
-{
-    bt_status_t ret;
-
-    btc_config_lock();
-    ret = _btc_storage_get_ble_dev_auth_mode(remote_bd_addr, auth_mode);
-    btc_config_unlock();
-
-    return ret;
-}
-
-static bt_status_t _btc_storage_remove_ble_dev_auth_mode(bt_bdaddr_t *remote_bd_addr, bool flush)
-{
-    bool ret = true;
-    bdstr_t bdstr;
-    uint32_t auth_mode = 0;
-
-    bdaddr_to_string(remote_bd_addr, bdstr, sizeof(bdstr));
-
-    ret = btc_config_get_int(bdstr, BTC_BLE_STORAGE_LE_AUTH_MODE_STR, (int *)&auth_mode);
-    if (ret == false) {
-        //cannot find the key, just return SUCCESS, indicate already removed
-        return BT_STATUS_SUCCESS;
-    }
-
-    ret = btc_config_remove(bdstr, BTC_BLE_STORAGE_LE_AUTH_MODE_STR);
-    if (ret == false) {
-        return BT_STATUS_FAIL;
-    }
-
-    if (flush) {
-        _btc_storage_save();
-    }
-
-    return  BT_STATUS_SUCCESS;
-}
-
-bt_status_t btc_storage_remove_ble_dev_auth_mode(bt_bdaddr_t *remote_bd_addr, bool flush)
-{
-    bt_status_t ret;
-
-    btc_config_lock();
-    ret = _btc_storage_remove_ble_dev_auth_mode(remote_bd_addr, flush);
-    btc_config_unlock();
-
-    return ret;
-}
-
 static bt_status_t _btc_storage_set_remote_addr_type(bt_bdaddr_t *remote_bd_addr, uint8_t addr_type, bool flush)
 {
     int ret;
@@ -742,17 +657,11 @@ static void _btc_read_le_key(const uint8_t key_type, const size_t key_len, bt_bd
             bdcpy(bta_bd_addr, bd_addr.address);
 
             if (!*device_added) {
-                int auth_mode = 0;
-                if(_btc_storage_get_ble_dev_auth_mode(&bd_addr, &auth_mode) != BT_STATUS_SUCCESS) {
-                    BTC_TRACE_WARNING("%s Failed to get auth mode from flash, please erase flash and download the firmware again", __func__);
-                }
-                BTA_DmAddBleDevice(bta_bd_addr, addr_type, auth_mode, BT_DEVICE_TYPE_BLE);
+                BTA_DmAddBleDevice(bta_bd_addr, addr_type, BT_DEVICE_TYPE_BLE);
                 *device_added = true;
             }
 
-#if (!CONFIG_BT_STACK_NO_LOG)
             char bd_str[20] = {0};
-#endif
             BTC_TRACE_DEBUG("%s() Adding key type %d for %s", __func__,
                 key_type, bdaddr_to_string(&bd_addr, bd_str, sizeof(bd_str)));
             BTA_DmAddBleKey(bta_bd_addr, (tBTA_LE_KEY_VALUE *)buffer, key_type);

components/bt/bluedroid/btc/core/btc_dm.c

@@ -176,7 +176,6 @@ static void btc_dm_remove_ble_bonding_keys(void)
     bdcpy(bd_addr.address, pairing_cb.bd_addr);
 
     btc_storage_remove_remote_addr_type(&bd_addr, false);
-    btc_storage_remove_ble_dev_auth_mode(&bd_addr, false);
     btc_storage_remove_ble_dev_type(&bd_addr, false);
     btc_storage_remove_ble_bonding_keys(&bd_addr);
 }
@@ -262,14 +261,9 @@ static void btc_dm_ble_auth_cmpl_evt (tBTA_DM_AUTH_CMPL *p_auth_cmpl)
         BTC_TRACE_DEBUG ("%s, -  pairing_cb.bd_addr: %08x%04x", __func__,
                              (pairing_cb.bd_addr[0] << 24) + (pairing_cb.bd_addr[1] << 16) + (pairing_cb.bd_addr[2] << 8) + pairing_cb.bd_addr[3],
                              (pairing_cb.bd_addr[4] << 8) + pairing_cb.bd_addr[5]);
-        // Check if need to save BLE keys
-        if((p_auth_cmpl->auth_mode & SMP_AUTH_GEN_BOND) == 0) {
-            return;
-        }
          if (btc_storage_get_remote_addr_type(&bdaddr, &addr_type) != BT_STATUS_SUCCESS) {
             btc_storage_set_remote_addr_type(&bdaddr, p_auth_cmpl->addr_type, true);
         }
-        btc_storage_set_ble_dev_auth_mode(&bdaddr, p_auth_cmpl->auth_mode, true);
         btc_dm_save_ble_bonding_keys();
     } else {
         /*Map the HCI fail reason  to  bt status  */
@@ -290,9 +284,6 @@ static void btc_dm_ble_auth_cmpl_evt (tBTA_DM_AUTH_CMPL *p_auth_cmpl)
 
     }
 
-#if (CONFIG_BT_STACK_NO_LOG)
-    (void) status;
-#endif
     BTC_TRACE_DEBUG("%s, authentication status = %x", __func__, status);
     return;
 
@@ -647,7 +638,6 @@ void btc_dm_sec_cb_handler(btc_msg_t *msg)
             //remove the bonded key in the config and nvs flash.
             btc_storage_remove_ble_dev_type(&bd_addr, false);
             btc_storage_remove_remote_addr_type(&bd_addr, false);
-            btc_storage_remove_ble_dev_auth_mode(&bd_addr, false);
             param.remove_bond_dev_cmpl.status = btc_storage_remove_ble_bonding_keys(&bd_addr);
         }
         ble_msg.act = ESP_GAP_BLE_REMOVE_BOND_DEV_COMPLETE_EVT;

components/bt/bluedroid/btc/include/btc/btc_ble_storage.h

@@ -32,7 +32,6 @@
 #define BTC_BLE_STORAGE_LE_KEY_LENC_STR             "LE_KEY_LENC"
 #define BTC_BLE_STORAGE_LE_KEY_LID_STR              "LE_KEY_LID"
 #define BTC_BLE_STORAGE_LE_KEY_LCSRK_STR            "LE_KEY_LCSRK"
-#define BTC_BLE_STORAGE_LE_AUTH_MODE_STR            "AuthMode"
 
 #define BTC_BLE_STORAGE_LOCAL_ADAPTER_STR           "Adapter"
 #define BTC_BLE_STORAGE_LE_LOCAL_KEY_IR_STR         "LE_LOCAL_KEY_IR"
@@ -67,12 +66,6 @@ bt_status_t btc_storage_remove_ble_local_keys(void);
 
 bt_status_t btc_storage_get_ble_local_key(uint8_t key_type, char *key_value, int key_len);
 
-bt_status_t btc_storage_set_ble_dev_auth_mode(bt_bdaddr_t *remote_bd_addr, uint8_t auth_mode, bool flush);
-
-bt_status_t btc_storage_get_ble_dev_auth_mode(bt_bdaddr_t *remote_bd_addr, int* auth_mode);
-
-bt_status_t btc_storage_remove_ble_dev_auth_mode(bt_bdaddr_t *remote_bd_addr, bool flush);
-
 bt_status_t btc_storage_get_remote_addr_type(bt_bdaddr_t *remote_bd_addr, int *addr_type);
 
 bt_status_t btc_storage_set_remote_addr_type(bt_bdaddr_t *remote_bd_addr, uint8_t addr_type, bool flush);

components/bt/bluedroid/btc/profile/esp/blufi/blufi_prf.c

@@ -170,14 +170,6 @@ static void blufi_profile_cb(tBTA_GATTS_EVT event, tBTA_GATTS *p_data)
             BTA_GATTS_SendRsp(p_data->req_data.conn_id, p_data->req_data.trans_id,
                           status, &rsp);
 
-            if(status != GATT_SUCCESS) {
-                if (blufi_env.prepare_buf) {
-                    osi_free(blufi_env.prepare_buf);
-                    blufi_env.prepare_buf = NULL;
-                }
-                BLUFI_TRACE_ERROR("write data error , error code 0x%x\n", status);
-                return;
-            }
             memcpy(blufi_env.prepare_buf + p_data->req_data.p_data->write_req.offset,
                    p_data->req_data.p_data->write_req.value,
                    p_data->req_data.p_data->write_req.len);
@@ -202,7 +194,7 @@ static void blufi_profile_cb(tBTA_GATTS_EVT event, tBTA_GATTS *p_data)
         BTA_GATTS_SendRsp(p_data->req_data.conn_id, p_data->req_data.trans_id,
                     GATT_SUCCESS, NULL);
 
-        if (blufi_env.prepare_buf && p_data->req_data.p_data->exec_write == GATT_PREP_WRITE_EXEC) {
+        if (p_data->req_data.p_data->exec_write == GATT_PREP_WRITE_EXEC) {
             btc_blufi_recv_handler(blufi_env.prepare_buf, blufi_env.prepare_len);
         }
 

components/bt/bluedroid/btc/profile/std/a2dp/btc_a2dp_sink.c

@@ -615,7 +615,6 @@ static void btc_a2dp_sink_handle_decoder_reset(tBTC_MEDIA_SINK_CFG_UPDATE *p_msg
 
     int frames_to_process = ((freq_multiple) / (num_blocks * num_subbands)) + 1;
     APPL_TRACE_EVENT(" Frames to be processed in 20 ms %d\n", frames_to_process);
-    UNUSED(frames_to_process);
 }
 
 /*******************************************************************************

components/bt/bluedroid/btc/profile/std/a2dp/btc_a2dp_source.c

@@ -495,11 +495,10 @@ static UINT64 time_now_us()
 static void log_tstamps_us(char *comment)
 {
     static UINT64 prev_us = 0;
-    UINT64 now_us = time_now_us();
+    const UINT64 now_us = time_now_us();
     APPL_TRACE_DEBUG("[%s] ts %08llu, diff : %08llu, queue sz %d", comment, now_us, now_us - prev_us,
                      fixed_queue_length(btc_aa_src_cb.TxAaQ));
     prev_us = now_us;
-    UNUSED(prev_us);
 }
 
 /* when true media task discards any tx frames */

components/bt/bluedroid/btc/profile/std/a2dp/btc_av.c

@@ -1199,13 +1199,10 @@ static void bte_av_media_callback(tBTA_AV_EVT event, tBTA_AV_MEDIA *p_data)
             BTC_TRACE_ERROR("ERROR dump_codec_info A2D_ParsSbcInfo fail:%d\n", a2d_status);
         }
     }
-    UNUSED(que_len);
 }
 #else
 static void bte_av_media_callback(tBTA_AV_EVT event, tBTA_AV_MEDIA *p_data)
 {
-    UNUSED(event);
-    UNUSED(p_data);
     BTC_TRACE_WARNING("%s : event %u\n", __func__, event);
 }
 #endif

components/bt/bluedroid/btc/profile/std/avrc/btc_avrc.c

@@ -335,8 +335,6 @@ static void handle_rc_passthrough_rsp ( tBTA_AV_REMOTE_RSP *p_remote_rsp)
     } else {
         BTC_TRACE_ERROR("%s DUT does not support AVRCP controller role", __FUNCTION__);
     }
-
-    UNUSED(status);
 #else
     BTC_TRACE_ERROR("%s AVRCP controller role is not enabled", __FUNCTION__);
 #endif

components/bt/bluedroid/btc/profile/std/gap/btc_gap_ble.c

@@ -604,9 +604,6 @@ static void btc_search_callback(tBTA_DM_SEARCH_EVT event, tBTA_DM_SEARCH *p_data
     case BTA_DM_SEARCH_CANCEL_CMPL_EVT:
         BTC_TRACE_DEBUG("BTA_DM_SEARCH_CANCEL_CMPL_EVT\n");
         break;
-    case BTA_DM_INQ_DISCARD_NUM_EVT:
-        param.scan_rst.num_dis = p_data->inq_dis.num_dis;
-        break;
     default:
         BTC_TRACE_ERROR("%s : Unknown event 0x%x\n", __FUNCTION__, event);
         return;
@@ -967,6 +964,21 @@ void btc_gap_ble_arg_deep_copy(btc_msg_t *msg, void *p_dest, void *p_src)
         }
         break;
     }
+    case BTC_GAP_BLE_OOB_REQ_REPLY_EVT: {
+        btc_ble_gap_args_t *src = (btc_ble_gap_args_t *)p_src;
+        btc_ble_gap_args_t  *dst = (btc_ble_gap_args_t *) p_dest;
+        uint8_t length = 0;
+        if (src->oob_req_reply.p_value) {
+            length = dst->oob_req_reply.len;
+            dst->oob_req_reply.p_value = osi_malloc(length);
+            if (dst->oob_req_reply.p_value != NULL) {
+                memcpy(dst->oob_req_reply.p_value, src->oob_req_reply.p_value, length);
+            } else {
+                BTC_TRACE_ERROR("%s %d no mem\n",__func__, msg->act);
+            }
+        }
+        break;
+    }
     default:
         BTC_TRACE_ERROR("Unhandled deep copy %d\n", msg->act);
         break;
@@ -1022,6 +1034,13 @@ void btc_gap_ble_arg_deep_free(btc_msg_t *msg)
         }
         break;
     }
+    case BTC_GAP_BLE_OOB_REQ_REPLY_EVT: {
+        uint8_t *value = ((btc_ble_gap_args_t *)msg->arg)->oob_req_reply.p_value;
+        if (value) {
+            osi_free(value);
+        }
+        break;
+    }
     default:
         BTC_TRACE_DEBUG("Unhandled deep free %d\n", msg->act);
         break;
@@ -1186,6 +1205,12 @@ void btc_gap_ble_call_handler(btc_msg_t *msg)
                 bta_dm_co_ble_set_accept_auth_enable(enable);
                 break;
             }
+            case ESP_BLE_SM_OOB_SUPPORT: {
+                uint8_t enable = 0;
+                STREAM_TO_UINT8(enable, value);
+                bta_dm_co_ble_oob_support(enable);
+                break;
+            }
             default:
                 break;
         }
@@ -1216,6 +1241,9 @@ void btc_gap_ble_call_handler(btc_msg_t *msg)
         BTA_DmRemoveDevice(bd_addr, BT_TRANSPORT_LE);
         break;
     }
+    case BTC_GAP_BLE_OOB_REQ_REPLY_EVT:
+        BTA_DmOobReply(arg->oob_req_reply.bd_addr, arg->oob_req_reply.len, arg->oob_req_reply.p_value);
+        break;
 #endif  ///SMP_INCLUDED == TRUE
     case BTC_GAP_BLE_DISCONNECT_EVT:
         btc_ble_disconnect(arg->disconnect.remote_device);

components/bt/bluedroid/btc/profile/std/gap/btc_gap_bt.c

@@ -750,7 +750,7 @@ void btc_gap_bt_arg_deep_free(btc_msg_t *msg)
         break;
 #endif ///BT_SSP_INCLUDED == TRUE
     default:
-        BTC_TRACE_ERROR("Unhandled deep copy %d, arg: %p\n", msg->act, arg);
+        BTC_TRACE_ERROR("Unhandled deep copy %d\n", msg->act);
         break;
     }
 }

components/bt/bluedroid/btc/profile/std/gatt/btc_gatts.c

@@ -81,72 +81,105 @@ void btc_gatts_arg_deep_copy(btc_msg_t *msg, void *p_dest, void *p_src)
 
     switch (msg->act) {
     case BTC_GATTS_ACT_SEND_INDICATE: {
-        dst->send_ind.value = (uint8_t *)osi_malloc(src->send_ind.value_len);
-        if (dst->send_ind.value) {
-            memcpy(dst->send_ind.value, src->send_ind.value, src->send_ind.value_len);
+        if (src->send_ind.value && (src->send_ind.value_len > 0)) {
+            dst->send_ind.value = (uint8_t *) osi_malloc(src->send_ind.value_len);
+            if (dst->send_ind.value) {
+                memcpy(dst->send_ind.value, src->send_ind.value, src->send_ind.value_len);
+            } else {
+                BTC_TRACE_ERROR("%s %d no mem\n", __func__, msg->act);
+            }
         } else {
-            BTC_TRACE_ERROR("%s %d no mem\n", __func__, msg->act);
+            dst->send_ind.value = NULL;
+            if (src->send_ind.value) {
+                BTC_TRACE_ERROR("%s %d, invalid length", __func__, msg->act);
+            } else {
+                BTC_TRACE_WARNING("%s %d, NULL value", __func__, msg->act);
+            }
         }
         break;
     }
     case BTC_GATTS_ACT_SEND_RESPONSE: {
         if (src->send_rsp.rsp) {
-            dst->send_rsp.rsp = (esp_gatt_rsp_t *)osi_malloc(sizeof(esp_gatt_rsp_t));
+            dst->send_rsp.rsp = (esp_gatt_rsp_t *) osi_malloc(sizeof(esp_gatt_rsp_t));
             if (dst->send_rsp.rsp) {
                 memcpy(dst->send_rsp.rsp, src->send_rsp.rsp, sizeof(esp_gatt_rsp_t));
             } else {
                 BTC_TRACE_ERROR("%s %d no mem\n", __func__, msg->act);
             }
+        } else {
+            BTC_TRACE_WARNING("%s %d, NULL response", __func__, msg->act);
         }
         break;
     
     }
-    case BTC_GATTS_ACT_ADD_CHAR:{
-        if (src->add_char.char_val.attr_value != NULL){
-            dst->add_char.char_val.attr_value = (uint8_t *)osi_malloc(src->add_char.char_val.attr_len);
-            if(dst->add_char.char_val.attr_value != NULL){
+    case BTC_GATTS_ACT_ADD_CHAR: {
+        if (src->add_char.char_val.attr_value && (src->add_char.char_val.attr_len > 0)) {
+            dst->add_char.char_val.attr_value = (uint8_t *) osi_malloc(src->add_char.char_val.attr_len);
+            if (dst->add_char.char_val.attr_value) {
                 memcpy(dst->add_char.char_val.attr_value, src->add_char.char_val.attr_value, 
                         src->add_char.char_val.attr_len);
-            }else{
+            } else {
                 BTC_TRACE_ERROR("%s %d no mem\n", __func__, msg->act);
             }
+        } else {
+            dst->add_char.char_val.attr_value = NULL;
+            if (src->add_char.char_val.attr_value) {
+                BTC_TRACE_ERROR("%s %d, invalid length", __func__, msg->act);
+            } else {
+                BTC_TRACE_WARNING("%s %d, NULL value", __func__, msg->act);
+            }
         }
         break;
     }
-    case BTC_GATTS_ACT_ADD_CHAR_DESCR:{
-        if(src->add_descr.descr_val.attr_value != NULL){
-            dst->add_descr.descr_val.attr_value = (uint8_t *)osi_malloc(src->add_descr.descr_val.attr_len);
-            if(dst->add_descr.descr_val.attr_value != NULL){
+    case BTC_GATTS_ACT_ADD_CHAR_DESCR: {
+        if (src->add_descr.descr_val.attr_value && (src->add_descr.descr_val.attr_len > 0)) {
+            dst->add_descr.descr_val.attr_value = (uint8_t *) osi_malloc(src->add_descr.descr_val.attr_len);
+            if (dst->add_descr.descr_val.attr_value) {
                 memcpy(dst->add_descr.descr_val.attr_value, src->add_descr.descr_val.attr_value,
                         src->add_descr.descr_val.attr_len);
-            }else{
+            } else {
                 BTC_TRACE_ERROR("%s %d no mem\n", __func__, msg->act);
             }
-        }
-        break;
-    }
-    case BTC_GATTS_ACT_CREATE_ATTR_TAB:{
-        uint8_t num_attr = src->create_attr_tab.max_nb_attr;
-        if(src->create_attr_tab.gatts_attr_db != NULL){
-            dst->create_attr_tab.gatts_attr_db = (esp_gatts_attr_db_t *)osi_malloc(sizeof(esp_gatts_attr_db_t)*num_attr);
-            if(dst->create_attr_tab.gatts_attr_db != NULL){
-                memcpy(dst->create_attr_tab.gatts_attr_db, src->create_attr_tab.gatts_attr_db,
-                        sizeof(esp_gatts_attr_db_t)*num_attr);
-            }else{
-                BTC_TRACE_ERROR("%s %d no mem\n",__func__, msg->act);
+        } else {
+            dst->add_descr.descr_val.attr_value = NULL;
+            if (src->add_descr.descr_val.attr_value) {
+                BTC_TRACE_ERROR("%s %d, invalid length", __func__, msg->act);
+            } else {
+                BTC_TRACE_WARNING("%s %d, NULL value", __func__, msg->act);
             }
         }
         break;
     }
-   case BTC_GATTS_ACT_SET_ATTR_VALUE:{
-        uint16_t len = src->set_attr_val.length;
-        if(src->set_attr_val.value){
-            dst->set_attr_val.value = (uint8_t *)osi_malloc(len);
-            if(dst->set_attr_val.value != NULL){
-                memcpy(dst->set_attr_val.value, src->set_attr_val.value, len);
-            }else{
+    case BTC_GATTS_ACT_CREATE_ATTR_TAB: {
+        uint8_t num_attr = src->create_attr_tab.max_nb_attr;
+        if (src->create_attr_tab.gatts_attr_db && (num_attr > 0)) {
+            dst->create_attr_tab.gatts_attr_db = (esp_gatts_attr_db_t *) osi_malloc(sizeof(esp_gatts_attr_db_t) * num_attr);
+            if (dst->create_attr_tab.gatts_attr_db) {
+                memcpy(dst->create_attr_tab.gatts_attr_db, src->create_attr_tab.gatts_attr_db,
+                        sizeof(esp_gatts_attr_db_t) * num_attr);
+            } else {
                 BTC_TRACE_ERROR("%s %d no mem\n",__func__, msg->act);
             }
+        } else {
+            BTC_TRACE_ERROR("%s %d, NULL data", __func__, msg->act);
+        }
+        break;
+    }
+   case BTC_GATTS_ACT_SET_ATTR_VALUE: {
+        if (src->set_attr_val.value && (src->set_attr_val.length > 0)) {
+            dst->set_attr_val.value = (uint8_t *) osi_malloc(src->set_attr_val.length);
+            if (dst->set_attr_val.value) {
+                memcpy(dst->set_attr_val.value, src->set_attr_val.value, src->set_attr_val.length);
+            } else {
+                BTC_TRACE_ERROR("%s %d no mem\n",__func__, msg->act);
+            }
+        } else {
+            dst->set_attr_val.value = NULL;
+            if (src->set_attr_val.value) {
+                BTC_TRACE_ERROR("%s %d, invalid length", __func__, msg->act);
+            } else {
+                BTC_TRACE_WARNING("%s %d, NULL value", __func__, msg->act);
+            }
         }
         break;
     }
@@ -690,13 +723,10 @@ void btc_gatts_call_handler(btc_msg_t *msg)
 #else
         //BTA_DmAddBleDevice(p_cb->bd_addr.address, addr_type, device_type);
 #endif
-        /*
-         not support background connection
         // Mark background connections
         if (!arg->open.is_direct) {
             BTA_DmBleSetBgConnType(BTM_BLE_CONN_AUTO, NULL);
         }
-        */
 
         transport = BTA_GATT_TRANSPORT_LE;
 

components/bt/bluedroid/btc/profile/std/hf_client/btc_hf_client.c

@@ -195,9 +195,8 @@ bt_status_t btc_hf_client_init(void)
 *******************************************************************************/
 static bt_status_t connect_int( bt_bdaddr_t *bd_addr, uint16_t uuid )
 {
-    if (is_connected(bd_addr)) {
+    if (is_connected(bd_addr))
         return BT_STATUS_BUSY;
-    }
 
     btc_hf_client_cb.state = ESP_HF_CLIENT_CONNECTION_STATE_CONNECTING;
     bdcpy(btc_hf_client_cb.connected_bda.address, bd_addr->address);
@@ -714,14 +713,14 @@ static void process_ind_evt(tBTA_HF_CLIENT_IND *ind)
 {
     esp_hf_client_cb_param_t param;
     memset(&param, 0, sizeof(esp_hf_client_cb_param_t));
-
+    
     switch (ind->type)
     {
         case BTA_HF_CLIENT_IND_CALL:
             param.call.status = ind->value;
             btc_hf_client_cb_to_app(ESP_HF_CLIENT_CIND_CALL_EVT, &param);
             break;
-
+    
         case BTA_HF_CLIENT_IND_CALLSETUP:
             param.call_setup.status = ind->value;
             btc_hf_client_cb_to_app(ESP_HF_CLIENT_CIND_CALL_SETUP_EVT, &param);
@@ -788,7 +787,6 @@ void btc_hf_client_cb_handler(btc_msg_t *msg)
             {
                 BTC_TRACE_WARNING("%s: HF CLient open failed, but another device connected. status=%d state=%d connected device=%s",
                         __FUNCTION__, p_data->open.status, btc_hf_client_cb.state, bdaddr_to_string(&btc_hf_client_cb.connected_bda, bdstr, sizeof(bdstr)));
-                UNUSED(bdstr);
                 break;
             }
 
@@ -797,20 +795,18 @@ void btc_hf_client_cb_handler(btc_msg_t *msg)
                 param.conn_stat.state = btc_hf_client_cb.state;
                 param.conn_stat.peer_feat = 0;
                 param.conn_stat.chld_feat = 0;
-
+            
                 memcpy(param.conn_stat.remote_bda, &btc_hf_client_cb.connected_bda,
                        sizeof(esp_bd_addr_t));
 
                 btc_hf_client_cb_to_app(ESP_HF_CLIENT_CONNECTION_STATE_EVT, &param);
             } while (0);
-
-            if (btc_hf_client_cb.state == ESP_HF_CLIENT_CONNECTION_STATE_DISCONNECTED) {
+            
+            if (btc_hf_client_cb.state == ESP_HF_CLIENT_CONNECTION_STATE_DISCONNECTED)
                 bdsetany(btc_hf_client_cb.connected_bda.address);
-            }
 
-            if (p_data->open.status != BTA_HF_CLIENT_SUCCESS) {
+            if (p_data->open.status != BTA_HF_CLIENT_SUCCESS)
                 btc_queue_advance();
-            }
 
             break;
 
@@ -824,13 +820,13 @@ void btc_hf_client_cb_handler(btc_msg_t *msg)
                 param.conn_stat.state = btc_hf_client_cb.state;
                 param.conn_stat.peer_feat = btc_hf_client_cb.peer_feat;
                 param.conn_stat.chld_feat = btc_hf_client_cb.chld_feat;
-
+            
                 memcpy(param.conn_stat.remote_bda, &btc_hf_client_cb.connected_bda,
                        sizeof(esp_bd_addr_t));
 
                 btc_hf_client_cb_to_app(ESP_HF_CLIENT_CONNECTION_STATE_EVT, &param);
             } while (0);
-
+            
             /* Inform the application about in-band ringtone */
             if (btc_hf_client_cb.peer_feat & BTA_HF_CLIENT_PEER_INBAND)
             {
@@ -843,7 +839,7 @@ void btc_hf_client_cb_handler(btc_msg_t *msg)
 
             btc_queue_advance();
             break;
-
+            
         case BTA_HF_CLIENT_CLOSE_EVT:
             btc_hf_client_cb.state = ESP_HF_CLIENT_CONNECTION_STATE_DISCONNECTED;
             do {
@@ -851,7 +847,7 @@ void btc_hf_client_cb_handler(btc_msg_t *msg)
                 param.conn_stat.state = ESP_HF_CLIENT_CONNECTION_STATE_DISCONNECTED;
                 param.conn_stat.peer_feat = 0;
                 param.conn_stat.chld_feat = 0;
-
+            
                 memcpy(param.conn_stat.remote_bda, &btc_hf_client_cb.connected_bda,
                        sizeof(esp_bd_addr_t));
 
@@ -984,7 +980,7 @@ void btc_hf_client_cb_handler(btc_msg_t *msg)
                 memset(&param, 0, sizeof(esp_hf_client_cb_param_t));
                 param.audio_stat.state = ESP_HF_CLIENT_AUDIO_STATE_CONNECTED;
                 memcpy(param.audio_stat.remote_bda, &btc_hf_client_cb.connected_bda,
-                       sizeof(esp_bd_addr_t));
+                       sizeof(esp_bd_addr_t));                
                 btc_hf_client_cb_to_app(ESP_HF_CLIENT_AUDIO_STATE_EVT, &param);
             } while (0);
             break;
@@ -993,7 +989,7 @@ void btc_hf_client_cb_handler(btc_msg_t *msg)
                 memset(&param, 0, sizeof(esp_hf_client_cb_param_t));
                 param.audio_stat.state = ESP_HF_CLIENT_AUDIO_STATE_CONNECTED_MSBC;
                 memcpy(param.audio_stat.remote_bda, &btc_hf_client_cb.connected_bda,
-                       sizeof(esp_bd_addr_t));
+                       sizeof(esp_bd_addr_t));                
                 btc_hf_client_cb_to_app(ESP_HF_CLIENT_AUDIO_STATE_EVT, &param);
             } while (0);
             break;

components/bt/bluedroid/btc/profile/std/include/btc_gap_ble.h

@@ -46,6 +46,7 @@ typedef enum {
     BTC_GAP_BLE_CONFIRM_REPLY_EVT,
     BTC_GAP_BLE_DISCONNECT_EVT,
     BTC_GAP_BLE_REMOVE_BOND_DEV_EVT,
+    BTC_GAP_BLE_OOB_REQ_REPLY_EVT,
     BTC_GAP_BLE_UPDATE_DUPLICATE_SCAN_EXCEPTIONAL_LIST,
 } btc_gap_ble_act_t;
 
@@ -151,6 +152,12 @@ typedef union {
         esp_bd_addr_t bd_addr;
         bool accept;
     } enc_comfirm_replay;
+    //BTC_GAP_BLE_OOB_DATA_REPLY_EVT
+    struct oob_req_reply_args {
+        esp_bd_addr_t bd_addr;
+        uint8_t len;
+        uint8_t *p_value;
+    } oob_req_reply;
     //BTC_GAP_BLE_DISCONNECT_EVT
     struct disconnect_args {
         esp_bd_addr_t remote_device;

components/bt/bluedroid/btc/profile/std/spp/btc_spp.c

@@ -315,7 +315,6 @@ static void btc_spp_init(btc_spp_args_t *arg)
 {
     if (osi_mutex_new(&spp_local_param.spp_slot_mutex) != 0) {
         BTC_TRACE_ERROR("%s osi_mutex_new failed\n", __func__);
-        return;
     }
     spp_local_param.spp_mode = arg->init.mode;
     spp_local_param.spp_slot_id = 0;
@@ -324,10 +323,6 @@ static void btc_spp_init(btc_spp_args_t *arg)
 
 static void btc_spp_uninit(void)
 {
-    if (!spp_local_param.spp_slot_mutex) {
-        BTC_TRACE_ERROR("%s SPP have not been init\n", __func__);
-        return;
-    }
     osi_mutex_lock(&spp_local_param.spp_slot_mutex, OSI_MUTEX_MAX_TIMEOUT);
     for (size_t i = 1; i <= BTA_JV_MAX_RFC_SR_SESSION; i++) {
         if (spp_local_param.spp_slots[i] != NULL && spp_local_param.spp_slots[i]->connected) {

components/bt/bluedroid/common/include/common/bt_target.h

@@ -130,45 +130,11 @@
 #define BLE_PRIVACY_SPT           FALSE
 #endif  /* CONFIG_SMP_ENABLE */
 
-#ifdef CONFIG_SMP_SLAVE_CON_PARAMS_UPD_ENABLE
-#if(CONFIG_SMP_SLAVE_CON_PARAMS_UPD_ENABLE)
-#define SMP_SLAVE_CON_PARAMS_UPD_ENABLE  TRUE
-#else
-#define SMP_SLAVE_CON_PARAMS_UPD_ENABLE  FALSE
-#endif
-#else
-#define SMP_SLAVE_CON_PARAMS_UPD_ENABLE  FALSE
-#endif
-
-#ifndef CONFIG_BLE_ADV_REPORT_FLOW_CONTROL_SUPPORTED
-#define BLE_ADV_REPORT_FLOW_CONTROL  FALSE
-#else
-#define BLE_ADV_REPORT_FLOW_CONTROL  CONFIG_BLE_ADV_REPORT_FLOW_CONTROL_SUPPORTED
-#endif /* CONFIG_BLE_ADV_REPORT_FLOW_CONTROL_SUPPORTED */
-
-#ifndef CONFIG_BLE_ADV_REPORT_FLOW_CONTROL_NUM
-#define BLE_ADV_REPORT_FLOW_CONTROL_NUM   100
-#else 
-#define BLE_ADV_REPORT_FLOW_CONTROL_NUM     CONFIG_BLE_ADV_REPORT_FLOW_CONTROL_NUM
-#endif /* CONFIG_BLE_ADV_REPORT_FLOW_CONTROL_NUM */
-
-#ifndef CONFIG_BLE_ADV_REPORT_DISCARD_THRSHOLD
-#define BLE_ADV_REPORT_DISCARD_THRSHOLD  20
-#else 
-#define BLE_ADV_REPORT_DISCARD_THRSHOLD  CONFIG_BLE_ADV_REPORT_DISCARD_THRSHOLD
-#endif /* CONFIG_BLE_ADV_REPORT_DISCARD_THRSHOLD */
-
 #if (CONFIG_BT_ACL_CONNECTIONS)
 #define MAX_ACL_CONNECTIONS  CONFIG_BT_ACL_CONNECTIONS
 #define GATT_MAX_PHY_CHANNEL CONFIG_BT_ACL_CONNECTIONS
 #endif  /* CONFIG_BT_ACL_CONNECTIONS */
 
-#if(CONFIG_BLE_ESTABLISH_LINK_CONNECTION_TIMEOUT)
-#define BLE_ESTABLISH_LINK_CONNECTION_TIMEOUT CONFIG_BLE_ESTABLISH_LINK_CONNECTION_TIMEOUT
-#else
-#define BLE_ESTABLISH_LINK_CONNECTION_TIMEOUT 30
-#endif
-
 //------------------Added from bdroid_buildcfg.h---------------------
 #ifndef L2CAP_EXTFEA_SUPPORTED_MASK
 #define L2CAP_EXTFEA_SUPPORTED_MASK (L2CAP_EXTFEA_ENH_RETRANS | L2CAP_EXTFEA_STREAM_MODE | L2CAP_EXTFEA_NO_CRC | L2CAP_EXTFEA_FIXED_CHNLS)
@@ -358,12 +324,6 @@
 #define GATTS_SEND_SERVICE_CHANGE_MODE CONFIG_GATTS_SEND_SERVICE_CHANGE_MODE
 #endif
 
-#ifndef CONFIG_BLE_ACTIVE_SCAN_REPORT_ADV_SCAN_RSP_INDIVIDUALLY
-#define BTM_BLE_ACTIVE_SCAN_REPORT_ADV_SCAN_RSP_INDIVIDUALLY    FALSE
-#else
-#define BTM_BLE_ACTIVE_SCAN_REPORT_ADV_SCAN_RSP_INDIVIDUALLY    CONFIG_BLE_ACTIVE_SCAN_REPORT_ADV_SCAN_RSP_INDIVIDUALLY
-#endif
-
 /* This feature is used to eanble interleaved scan*/
 #ifndef BTA_HOST_INTERLEAVE_SEARCH
 #define BTA_HOST_INTERLEAVE_SEARCH FALSE//FALSE

components/bt/bluedroid/common/include/common/bte_appl.h

@@ -32,6 +32,7 @@ typedef struct {
     UINT8   ble_resp_key;
     UINT8   ble_max_key_size;
     UINT8   ble_accept_auth_enable;
+    UINT8   oob_support;
 #endif
 
 } tBTE_APPL_CFG;

components/bt/bluedroid/device/controller.c

@@ -100,11 +100,7 @@ static void start_up(void)
     response = AWAIT_COMMAND(packet_factory->make_set_c2h_flow_control(HCI_HOST_FLOW_CTRL_ACL_ON));
     packet_parser->parse_generic_command_complete(response);
 #endif ///C2H_FLOW_CONTROL_INCLUDED == TRUE
-#if (BLE_ADV_REPORT_FLOW_CONTROL == TRUE)
-    // Enable adv flow control
-    response = AWAIT_COMMAND(packet_factory->make_set_adv_report_flow_control(HCI_HOST_FLOW_CTRL_ADV_REPORT_ON, (uint16_t)BLE_ADV_REPORT_FLOW_CONTROL_NUM, (uint16_t)BLE_ADV_REPORT_DISCARD_THRSHOLD));
-    packet_parser->parse_generic_command_complete(response);
-#endif
+
     // Tell the controller about our buffer sizes and buffer counts next
     // TODO(zachoverflow): factor this out. eww l2cap contamination. And why just a hardcoded 10?
     response = AWAIT_COMMAND(
@@ -254,10 +250,10 @@ static void start_up(void)
     }
 #endif
 
-
-    response = AWAIT_COMMAND(packet_factory->make_set_event_mask(&CLASSIC_EVENT_MASK));
-    packet_parser->parse_generic_command_complete(response);
-
+    if (simple_pairing_supported) {
+        response = AWAIT_COMMAND(packet_factory->make_set_event_mask(&CLASSIC_EVENT_MASK));
+        packet_parser->parse_generic_command_complete(response);
+    }
 
 #if (BTM_SCO_HCI_INCLUDED == TRUE)
     response = AWAIT_COMMAND(packet_factory->make_write_sync_flow_control_enable(1));

components/bt/bluedroid/device/interop.c

@@ -27,7 +27,6 @@
 #define CASE_RETURN_STR(const) case const: return #const;
 
 #if (SMP_INCLUDED == TRUE)
-#if (!CONFIG_BT_STACK_NO_LOG)
 static const char *interop_feature_string(const interop_feature_t feature)
 {
     switch (feature) {
@@ -37,7 +36,7 @@ static const char *interop_feature_string(const interop_feature_t feature)
 
     return "UNKNOWN";
 }
-#endif // (!CONFIG_BT_STACK_NO_LOG)
+
 // Interface functions
 bool interop_match(const interop_feature_t feature, const bt_bdaddr_t *addr)
 {
@@ -48,9 +47,7 @@ bool interop_match(const interop_feature_t feature, const bt_bdaddr_t *addr)
     for (size_t i = 0; i != db_size; ++i) {
         if (feature == interop_database[i].feature &&
                 memcmp(addr, &interop_database[i].addr, interop_database[i].len) == 0) {
-#if (!CONFIG_BT_STACK_NO_LOG)
             char bdstr[20] = {0};
-#endif
             LOG_WARN("%s() Device %s is a match for interop workaround %s", __func__,
                      bdaddr_to_string(addr, bdstr, sizeof(bdstr)), interop_feature_string(feature));
             return true;

components/bt/bluedroid/external/sbc/encoder/srce/sbc_enc_bit_alloc_mono.c

@@ -145,10 +145,9 @@ void sbc_enc_bit_alloc_mono(SBC_ENC_PARAMS *pstrCodecParams)
         for (s32Sb = 0; s32Sb < s32NumOfSubBands; s32Sb++) {
             if (*(ps16GenBufPtr) < s32BitSlice + 2) {
                 *(ps16GenArrPtr) = 0;
-            } else {
+            } else
                 *(ps16GenArrPtr) = ((*(ps16GenBufPtr) - s32BitSlice) < 16) ?
                                    (SINT16)(*(ps16GenBufPtr) - s32BitSlice) : 16;
-            }
 
             ps16GenBufPtr++;
             ps16GenArrPtr++;

components/bt/bluedroid/external/sbc/encoder/srce/sbc_enc_bit_alloc_ste.c

@@ -132,10 +132,9 @@ void sbc_enc_bit_alloc_ste(SBC_ENC_PARAMS *pstrCodecParams)
         for (s32Sb = 0; s32Sb < s32NumOfSubBands; s32Sb++) {
             if (*ps16GenBufPtr < s32BitSlice + 2) {
                 *ps16GenArrPtr = 0;
-            } else {
+            } else
                 *ps16GenArrPtr = ((*(ps16GenBufPtr) - s32BitSlice) < 16) ?
                                  (SINT16)(*(ps16GenBufPtr) - s32BitSlice) : 16;
-            }
             ps16GenBufPtr++;
             ps16GenArrPtr++;
         }

components/bt/bluedroid/hci/hci_hal_h4.c

@@ -55,7 +55,6 @@ static const uint16_t outbound_event_types[] = {
 typedef struct {
     size_t buffer_size;
     fixed_queue_t *rx_q;
-    uint16_t adv_free_num;
 } hci_hal_env_t;
 
 
@@ -82,7 +81,6 @@ static void hci_hal_env_init(
     assert(max_buffer_count > 0);
 
     hci_hal_env.buffer_size = buffer_size;
-    hci_hal_env.adv_free_num = 0;
 
     hci_hal_env.rx_q = fixed_queue_new(max_buffer_count);
     if (hci_hal_env.rx_q) {
@@ -104,11 +102,8 @@ static bool hal_open(const hci_hal_callbacks_t *upper_callbacks)
 {
     assert(upper_callbacks != NULL);
     callbacks = upper_callbacks;
-#if (BLE_ADV_REPORT_FLOW_CONTROL == TRUE)
-    hci_hal_env_init(HCI_HAL_SERIAL_BUFFER_SIZE, BLE_ADV_REPORT_FLOW_CONTROL_NUM + L2CAP_HOST_FC_ACL_BUFS + QUEUE_SIZE_MAX); // adv flow control num + ACL flow control num + hci cmd numeber
-#else
+
     hci_hal_env_init(HCI_HAL_SERIAL_BUFFER_SIZE, QUEUE_SIZE_MAX);
-#endif
 
     xHciH4Queue = xQueueCreate(HCI_H4_QUEUE_LEN, sizeof(BtTaskEvt_t));
     xTaskCreatePinnedToCore(hci_hal_h4_rx_handler, HCI_H4_TASK_NAME, HCI_H4_TASK_STACK_SIZE, NULL, HCI_H4_TASK_PRIO, &xHciH4TaskHandle, HCI_H4_TASK_PINNED_TO_CORE);
@@ -228,37 +223,12 @@ static void hci_packet_complete(BT_HDR *packet){
 bool host_recv_adv_packet(BT_HDR *packet)
 {
     assert(packet);
-    if(packet->data[0] == DATA_TYPE_EVENT && packet->data[1] == HCI_BLE_EVENT) {
-        if(packet->data[3] ==  HCI_BLE_ADV_PKT_RPT_EVT 
-#if (BLE_ADV_REPORT_FLOW_CONTROL == TRUE)
-        || packet->data[3] ==  HCI_BLE_ADV_DISCARD_REPORT_EVT
-#endif
-        ) {
-            return true;
-        }
+    if(packet->data[0] == DATA_TYPE_EVENT && packet->data[1] == HCI_BLE_EVENT && packet->data[3] ==  HCI_BLE_ADV_PKT_RPT_EVT) {
+        return true;
     }
     return false;
 }
 
-#if (BLE_ADV_REPORT_FLOW_CONTROL == TRUE)
-static void hci_update_adv_report_flow_control(BT_HDR *packet)
-{
-    // this is adv packet
-    if(host_recv_adv_packet(packet)) {
-        // update adv free number
-        hci_hal_env.adv_free_num ++;
-        if (esp_vhci_host_check_send_available()){
-            // send hci cmd
-            btsnd_hcic_ble_update_adv_report_flow_control(hci_hal_env.adv_free_num);
-            hci_hal_env.adv_free_num = 0;
-        } else {
-            //do nothing
-        }
-    }
-
-}
-#endif
-
 static void hci_hal_h4_hdl_rx_packet(BT_HDR *packet)
 {
     uint8_t type, hdr_size;
@@ -277,10 +247,8 @@ static void hci_hal_h4_hdl_rx_packet(BT_HDR *packet)
     packet->offset++;
     packet->len--;
     if (type == HCI_BLE_EVENT) {
-#if (!CONFIG_BT_STACK_NO_LOG)
         uint8_t len = 0;
         STREAM_TO_UINT8(len, stream);
-#endif
         HCI_TRACE_ERROR("Workround stream corrupted during LE SCAN: pkt_len=%d ble_event_len=%d\n",
                   packet->len, len);
         osi_free(packet);
@@ -314,11 +282,6 @@ static void hci_hal_h4_hdl_rx_packet(BT_HDR *packet)
         osi_free(packet);
         return;
     }
-
-#if (BLE_ADV_REPORT_FLOW_CONTROL == TRUE)
-    hci_update_adv_report_flow_control(packet);
-#endif
-
 #if SCAN_QUEUE_CONGEST_CHECK
     if(BTU_check_queue_is_congest() && host_recv_adv_packet(packet)) {
         HCI_TRACE_ERROR("BtuQueue is congested");
@@ -326,6 +289,7 @@ static void hci_hal_h4_hdl_rx_packet(BT_HDR *packet)
         return;
     }
 #endif
+
     packet->event = outbound_event_types[PACKET_TYPE_TO_INDEX(type)];
     callbacks->packet_ready(packet);
 }

components/bt/bluedroid/hci/hci_layer.c

@@ -317,11 +317,7 @@ static void event_command_ready(fixed_queue_t *queue)
 
     wait_entry = fixed_queue_dequeue(queue);
 
-    if(wait_entry->opcode == HCI_HOST_NUM_PACKETS_DONE 
-#if (BLE_ADV_REPORT_FLOW_CONTROL == TRUE)
-    || wait_entry->opcode == HCI_VENDOR_BLE_ADV_REPORT_FLOW_CONTROL
-#endif
-    ){
+    if(wait_entry->opcode == HCI_HOST_NUM_PACKETS_DONE){
         packet_fragmenter->fragment_and_dispatch(wait_entry->command);
         osi_free(wait_entry->command);
         osi_free(wait_entry);

components/bt/bluedroid/hci/hci_packet_factory.c

@@ -53,18 +53,6 @@ static BT_HDR *make_set_c2h_flow_control(uint8_t enable)
     return packet;
 }
 
-static BT_HDR *make_set_adv_report_flow_control(uint8_t enable, uint16_t num, uint16_t lost_threshold)
-{
-    uint8_t *stream;
-    const uint8_t parameter_size = 1 + 2 + 2;
-    BT_HDR *packet = make_command(HCI_VENDOR_BLE_SET_ADV_FLOW_CONTROL, parameter_size, &stream);
-
-    UINT8_TO_STREAM(stream, enable);
-    UINT16_TO_STREAM(stream, num);
-    UINT16_TO_STREAM(stream, lost_threshold);
-    return packet;
-}
-
 static BT_HDR *make_host_buffer_size(uint16_t acl_size, uint8_t sco_size, uint16_t acl_count, uint16_t sco_count)
 {
     uint8_t *stream;
@@ -251,7 +239,6 @@ static const hci_packet_factory_t interface = {
     make_reset,
     make_read_buffer_size,
     make_set_c2h_flow_control,
-    make_set_adv_report_flow_control,
     make_host_buffer_size,
     make_read_local_version_info,
     make_read_bd_addr,

components/bt/bluedroid/hci/include/hci/hci_packet_factory.h

@@ -26,7 +26,6 @@ typedef struct {
     BT_HDR *(*make_reset)(void);
     BT_HDR *(*make_read_buffer_size)(void);
     BT_HDR *(*make_set_c2h_flow_control)(uint8_t enable);
-    BT_HDR *(*make_set_adv_report_flow_control)(uint8_t enable, uint16_t num, uint16_t lost_threshold);
     BT_HDR *(*make_host_buffer_size)(uint16_t acl_size, uint8_t sco_size, uint16_t acl_count, uint16_t sco_count);
     BT_HDR *(*make_read_local_version_info)(void);
     BT_HDR *(*make_read_bd_addr)(void);

components/bt/bluedroid/osi/list.c

@@ -61,9 +61,8 @@ bool list_contains(const list_t *list, const void *data)
   assert(data != NULL);
 
   for (const list_node_t *node = list_begin(list); node != list_end(list); node = list_next(node)) {
-    if (list_node(node) == data) {
+    if (list_node(node) == data)
       return true;
-    }
   }
 
   return false;
@@ -202,9 +201,8 @@ list_node_t *list_foreach(const list_t *list, list_iter_cb callback, void *conte
 
   for (list_node_t *node = list->head; node; ) {
     list_node_t *next = node->next;
-    if (!callback(node->data, context)) {
+    if (!callback(node->data, context))
       return node;
-    }
     node = next;
   }
   return NULL;

components/bt/bluedroid/stack/avct/avct_lcb_act.c

@@ -605,9 +605,8 @@ void avct_lcb_free_msg_ind(tAVCT_LCB *p_lcb, tAVCT_LCB_EVT *p_data)
 {
     UNUSED(p_lcb);
 
-    if (p_data == NULL) {
+    if (p_data == NULL)
         return;
-    }
 
     osi_free(p_data->p_buf);
     p_data->p_buf = NULL;

components/bt/bluedroid/stack/avdt/avdt_scb_act.c

@@ -345,10 +345,8 @@ UINT8 *avdt_scb_hdl_report(tAVDT_SCB *p_scb, UINT8 *p, UINT16 len)
         p += 2;
         BE_STREAM_TO_UINT32(ssrc, p);
 
-        UNUSED(ssrc);
         UNUSED(o_p);
         UNUSED(o_v);
-        UNUSED(o_cc);
 
         switch (pt) {
         case AVDT_RTCP_PT_SR:   /* the packet type - SR (Sender Report) */
@@ -629,19 +627,15 @@ void avdt_scb_hdl_pkt(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
         avdt_scb_hdl_pkt_frag(p_scb, p_data);
     } else
 #endif
-    {
 #if AVDT_REPORTING == TRUE
         if (p_data->p_pkt->layer_specific == AVDT_CHAN_REPORT) {
             p = (UINT8 *)(p_data->p_pkt + 1) + p_data->p_pkt->offset;
             avdt_scb_hdl_report(p_scb, p, p_data->p_pkt->len);
-            osi_free(p_data->p_pkt);
-            p_data->p_pkt = NULL;
+        osi_free(p_data->p_pkt);
+        p_data->p_pkt = NULL;
         } else
 #endif
-        {
             avdt_scb_hdl_pkt_no_frag(p_scb, p_data);
-        }
-    }
 }
 
 /*******************************************************************************
@@ -1309,9 +1303,7 @@ void avdt_scb_hdl_write_req(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
 #if AVDT_MULTIPLEXING == TRUE
     if (fixed_queue_is_empty(p_scb->frag_q))
 #endif
-    {
         avdt_scb_hdl_write_req_no_frag(p_scb, p_data);
-    }
 #if AVDT_MULTIPLEXING == TRUE
     else {
         avdt_scb_hdl_write_req_frag(p_scb, p_data);

components/bt/bluedroid/stack/avrc/avrc_utils.c

@@ -120,11 +120,10 @@ BOOLEAN avrc_is_valid_player_attrib_value(UINT8 attrib, UINT8 value)
         result = TRUE;
     }
 
-    if (!result) {
+    if (!result)
         AVRC_TRACE_ERROR(
             "avrc_is_valid_player_attrib_value() found not matching attrib(x%x)-value(x%x) pair!",
             attrib, value);
-    }
 
     return result;
 }

components/bt/bluedroid/stack/btm/btm_acl.c

@@ -261,10 +261,9 @@ void btm_acl_created (BD_ADDR bda, DEV_CLASS dc, BD_NAME bdn,
 #if BLE_INCLUDED == TRUE
             p->transport = transport;
 #if BLE_PRIVACY_SPT == TRUE
-            if (transport == BT_TRANSPORT_LE) {
+            if (transport == BT_TRANSPORT_LE)
                 btm_ble_refresh_local_resolvable_private_addr(bda,
                         btm_cb.ble_ctr_cb.addr_mgnt_cb.private_addr);
-            }
 #else
             p->conn_addr_type = BLE_ADDR_PUBLIC;
             memcpy(p->conn_addr, &controller_get_interface()->get_address()->address, BD_ADDR_LEN);
@@ -2496,17 +2495,15 @@ void btm_acl_chk_peer_pkt_type_support (tACL_CONN *p, UINT16 *p_pkt_type)
     }
 
     /* 2 and 3 MPS support? */
-    if (!HCI_EDR_ACL_2MPS_SUPPORTED(p->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0])) {
+    if (!HCI_EDR_ACL_2MPS_SUPPORTED(p->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0]))
         /* Not supported. Add 'not_supported' mask for all 2MPS packet types */
         *p_pkt_type |= (BTM_ACL_PKT_TYPES_MASK_NO_2_DH1 + BTM_ACL_PKT_TYPES_MASK_NO_2_DH3 +
                         BTM_ACL_PKT_TYPES_MASK_NO_2_DH5);
-    }
 
-    if (!HCI_EDR_ACL_3MPS_SUPPORTED(p->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0])) {
+    if (!HCI_EDR_ACL_3MPS_SUPPORTED(p->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0]))
         /* Not supported. Add 'not_supported' mask for all 3MPS packet types */
         *p_pkt_type |= (BTM_ACL_PKT_TYPES_MASK_NO_3_DH1 + BTM_ACL_PKT_TYPES_MASK_NO_3_DH3 +
                         BTM_ACL_PKT_TYPES_MASK_NO_3_DH5);
-    }
 
     /* EDR 3 and 5 slot support? */
     if (HCI_EDR_ACL_2MPS_SUPPORTED(p->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0])

components/bt/bluedroid/stack/btm/btm_ble.c

@@ -66,14 +66,13 @@ extern void gatt_notify_enc_cmpl(BD_ADDR bd_addr);
 **                  bd_name          - Name of the peer device.  NULL if unknown.
 **                  dev_type         - Remote device's device type.
 **                  addr_type        - LE device address type.
-**                  auth_mode        - auth mode
 **
 ** Returns          TRUE if added OK, else FALSE
 **
 *******************************************************************************/
 #if (SMP_INCLUDED == TRUE)
 BOOLEAN BTM_SecAddBleDevice (BD_ADDR bd_addr, BD_NAME bd_name, tBT_DEVICE_TYPE dev_type,
-                             tBLE_ADDR_TYPE addr_type, UINT32 auth_mode)
+                             tBLE_ADDR_TYPE addr_type)
 {
     tBTM_SEC_DEV_REC  *p_dev_rec;
     UINT8               i = 0;
@@ -126,7 +125,6 @@ BOOLEAN BTM_SecAddBleDevice (BD_ADDR bd_addr, BD_NAME bd_name, tBT_DEVICE_TYPE d
     }
     p_dev_rec->device_type |= dev_type;
     p_dev_rec->ble.ble_addr_type = addr_type;
-    p_dev_rec->ble.auth_mode = auth_mode;
 
     memcpy (p_dev_rec->ble.pseudo_addr, bd_addr, BD_ADDR_LEN);
     /* sync up with the Inq Data base*/
@@ -887,9 +885,8 @@ tBTM_SEC_ACTION btm_ble_determine_security_act(BOOLEAN is_originator, BD_ADDR bd
             return BTM_SEC_OK;
         }
 
-        if (security_required & BTM_SEC_OUT_MITM) {
+        if (security_required & BTM_SEC_OUT_MITM)
             auth_req |= BTM_LE_AUTH_REQ_MITM;
-        }
     }
     else
     {
@@ -899,9 +896,8 @@ tBTM_SEC_ACTION btm_ble_determine_security_act(BOOLEAN is_originator, BD_ADDR bd
             return BTM_SEC_OK;
         }
 
-        if (security_required & BTM_SEC_IN_MITM) {
+        if (security_required & BTM_SEC_IN_MITM)
             auth_req |= BTM_LE_AUTH_REQ_MITM;
-        }
     }
 
     tBTM_BLE_SEC_REQ_ACT ble_sec_act = BTM_BLE_SEC_REQ_ACT_NONE;
@@ -909,13 +905,11 @@ tBTM_SEC_ACTION btm_ble_determine_security_act(BOOLEAN is_originator, BD_ADDR bd
 
     BTM_TRACE_DEBUG ("%s ble_sec_act %d", __func__ , ble_sec_act);
 
-    if (ble_sec_act == BTM_BLE_SEC_REQ_ACT_DISCARD) {
+    if (ble_sec_act == BTM_BLE_SEC_REQ_ACT_DISCARD)
         return BTM_SEC_ENC_PENDING;
-    }
 
-    if (ble_sec_act == BTM_BLE_SEC_REQ_ACT_NONE) {
+    if (ble_sec_act == BTM_BLE_SEC_REQ_ACT_NONE)
         return BTM_SEC_OK;
-    }
 
     UINT8 sec_flag = 0;
     BTM_GetSecurityFlagsByTransport(bdaddr, &sec_flag, BT_TRANSPORT_LE);
@@ -924,13 +918,11 @@ tBTM_SEC_ACTION btm_ble_determine_security_act(BOOLEAN is_originator, BD_ADDR bd
     BOOLEAN is_key_mitm = FALSE;
     if (sec_flag & (BTM_SEC_FLAG_ENCRYPTED| BTM_SEC_FLAG_LKEY_KNOWN))
     {
-        if (sec_flag & BTM_SEC_FLAG_ENCRYPTED) {
+        if (sec_flag & BTM_SEC_FLAG_ENCRYPTED)
             is_link_encrypted = TRUE;
-        }
 
-        if (sec_flag & BTM_SEC_FLAG_LKEY_AUTHED) {
+        if (sec_flag & BTM_SEC_FLAG_LKEY_AUTHED)
             is_key_mitm = TRUE;
-        }
     }
 
     if (auth_req & BTM_LE_AUTH_REQ_MITM)
@@ -939,18 +931,16 @@ tBTM_SEC_ACTION btm_ble_determine_security_act(BOOLEAN is_originator, BD_ADDR bd
         {
             return BTM_SEC_ENCRYPT_MITM;
         } else {
-            if (is_link_encrypted) {
+            if (is_link_encrypted)
                 return BTM_SEC_OK;
-            } else {
+            else
                 return BTM_SEC_ENCRYPT;
-            }
         }
     } else {
-        if (is_link_encrypted) {
+        if (is_link_encrypted)
             return BTM_SEC_OK;
-        } else {
+        else
             return BTM_SEC_ENCRYPT_NO_MITM;
-        }
     }
 
     return BTM_SEC_OK;
@@ -1020,9 +1010,8 @@ BOOLEAN btm_ble_start_sec_check(BD_ADDR bd_addr, UINT16 psm, BOOLEAN is_originat
             break;
     }
 
-    if (ble_sec_act == BTM_BLE_SEC_NONE) {
+    if (ble_sec_act == BTM_BLE_SEC_NONE)
         return status;
-    }
 
     tL2C_LCB *p_lcb = l2cu_find_lcb_by_bd_addr(bd_addr, BT_TRANSPORT_LE);
     p_lcb->sec_act = sec_act;
@@ -1477,14 +1466,13 @@ tBTM_STATUS btm_ble_set_encryption (BD_ADDR bd_addr, void *p_ref_data, UINT8 lin
                 break;
             }
         }
-#if (SMP_SLAVE_CON_PARAMS_UPD_ENABLE == TRUE)
+
         // already have encrypted information, do not need to update connection parameters
         if(link_role == BTM_ROLE_SLAVE && (p_rec->ble.key_type & BTM_LE_KEY_PENC)) {
             p_rec->ble.skip_update_conn_param = true;
         } else {
             p_rec->ble.skip_update_conn_param = false;
         }
-#endif
         if (SMP_Pair(bd_addr) == SMP_STARTED) {
             cmd = BTM_CMD_STARTED;
             p_rec->sec_state = BTM_SEC_STATE_AUTHENTICATING;
@@ -2006,18 +1994,9 @@ void btm_ble_conn_complete(UINT8 *p, UINT16 evt_len, BOOLEAN enhanced)
             btm_ble_disable_resolving_list(BTM_BLE_RL_ADV, TRUE);
 #endif
         }
-
     }
 
-    BOOLEAN bg_con = btm_ble_update_mode_operation(role, bda, status);
-    if (status != HCI_SUCCESS && !bg_con) {
-        // notify connection failed
-        l2c_link_hci_disc_comp (handle, status);
-#if (SMP_INCLUDED == TRUE)
-        /* Notify security manager */
-        btm_sec_disconnected (handle, status);
-#endif  ///SMP_INCLUDED == TRUE
-    }
+    btm_ble_update_mode_operation(role, bda, status);
 }