tree ca66e4938d5d9ef360a9ba8dcc9044a33a76451d
parent 695d0bfa7f0c521eebbf3bfa4c3bfbadfceb6dfd
author Marius Tache <102153746+marius-alex-tache@users.noreply.github.com> 1705337574 +0200
committer GitHub <noreply@github.com> 1705337574 +0000
gpgsig -----BEGIN PGP SIGNATURE-----
 
 wsBcBAABCAAQBQJlpWLmCRBK7hj4Ov3rIwAAF9YIAADV6kI1M/ErgI6+00fxi9QN
 dGs1d76iQhmdVJSvFfz+JrI5MAzWIJmCsIMvGinj6DghB7ZfpmBShtAXyKH1po30
 McDVs2G/6SLfRFdKhGwRN+tdDkcVeoPYpua0HU4+O3btBZR6gKYCilURdQkCU1UL
 agit6Ukgc4yt6lPHR2w7Uu71s4K+QJokpg1P2sWNE9pUzcvFjm4K9WpQUzsfQlh9
 YzZVxGZUCbhAVB2rSfAhjOhyLf/BUjzAGsvCK5LnRRn48ZW/pTuzCO/XKhra8tdE
 3mdPqBT/X6H7oiYVtqtDkPZxG4pPFThR8ZEyhDWeP/8cQZks5Ih/ygOewPF9Eg4=
 =QFzt
 -----END PGP SIGNATURE-----
 

[K32W0] SDK 2.6.13 additional changes (#31382)

* [K32W] Fix a corner case when switching the TLV processors

After the current block is processed, if the block size is 0, it means
that the processed data was a multiple of received BDX block size (e.g.
8 blocks of 1024 bytes were transferred). After state for selecting next
processor is reset, a request for fetching next data must be sent.

Signed-off-by: marius-alex-tache <marius.tache@nxp.com>

* [K32W] Make Validate public

Change access modifier of Validate to public, to be used by K32W0
for factory data validation after factory data OTA.

Signed-off-by: marius-alex-tache <marius.tache@nxp.com>

* [K32W0] Add CRC validation during factory data OTA

After factory data is copied into internal flash, call Validate to ensure
the CRC of factory data matches the CRC in the header. If the check fails,
then OTA is aborted and factory data is restored to previous version.

Signed-off-by: marius-alex-tache <marius.tache@nxp.com>

* [K32W0] Add additional check for provider pointer

Signed-off-by: marius-alex-tache <marius.tache@nxp.com>

* [K32W0] Change root node revision to 2

Signed-off-by: marius-alex-tache <marius.tache@nxp.com>

* [K32W] Expose SearchForId in factory data provider public API

Removed additional checks on tags with the assumption that factory data is
strictly checked at manufacturing time.
Applications can now use the public API to search the factory data section
for an id, e.g. in the case of custom factory data provider, where the app
has additional factory data information besides the default one.

Signed-off-by: marius-alex-tache <marius.tache@nxp.com>

* [K32W0] Refactor custom factory data provider

The example now leverages the actual factory data provider API to
search the factory data section for some custom ids.

Signed-off-by: marius-alex-tache <marius.tache@nxp.com>

* [K32W] Add platform support for Product Appearance

Implement GetProductFinish and GetProductPrimaryColor defined in DeviceInstanceInfoProvider.

Signed-off-by: marius-alex-tache <marius.tache@nxp.com>

* [K32W] Remove maxLengths array

This array was used to store the maximum length of factory data fields.
It's no longer used, with the assumption that the factory data is strictly
checked in manufacturing.

Signed-off-by: marius-alex-tache <marius.tache@nxp.com>

* [K32W0] Remove usage of maxLength array

Signed-off-by: marius-alex-tache <marius.tache@nxp.com>

* [K32W0] remove unused code in LowPowerHook.cpp file

* [K32W0] use Encoding::HexToBytes to parse the ota encryption key

* [K32W0] remove extra PWR_DisallowDeviceToSleep() which will cause unsleep after commissioning

* [K32W] Revert removal of disallow to sleep and enclose it in specific tag

Only call disallow to sleep when the platform is K32W1.

Signed-off-by: marius-alex-tache <marius.tache@nxp.com>

* [K32W0] Update reference app readme files

This is a minor improvement to the building instructions.
It aims to clarify the usage of west SDK or package SDK.

Signed-off-by: marius-alex-tache <marius.tache@nxp.com>

* [K32W0] Fix ICD parameters

Name of the ICD parameters were updated according with the latest stack updates.

Signed-off-by: Andrei Menzopol <andrei.menzopol@nxp.com>

* Restyled by clang-format

* Restyled by gn

* Restyled by prettier-markdown

* [K32W0] Fix gn check error

Signed-off-by: marius-alex-tache <marius.tache@nxp.com>

* Restyled by gn

* [K32W1] Fix gn check errors

Signed-off-by: marius-alex-tache <marius.tache@nxp.com>

* Restyled by gn

* [K32W1] Fix another gn error

Signed-off-by: marius-alex-tache <marius.tache@nxp.com>

* Restyled by gn

* [K32W] Send a report before resetting the device during OTA

State-transition event from Downloading to Applying was not successfully sent
to a subscriber during OTA because the device would reset before actually sending
the ReportData message.

Added an explicit call to handle server shutting down, which will sync send all events.

Signed-off-by: marius-alex-tache <marius.tache@nxp.com>

* Restyled by clang-format

* [K32W0] Remove deprecated dependency

Signed-off-by: marius-alex-tache <marius.tache@nxp.com>

* [K32W1] Remove deprecated dependency

Signed-off-by: marius-alex-tache <marius.tache@nxp.com>

* Restyled by gn

---------

Signed-off-by: marius-alex-tache <marius.tache@nxp.com>
Signed-off-by: Andrei Menzopol <andrei.menzopol@nxp.com>
Co-authored-by: Damien Vagner <damien.vagner@nxp.com>
Co-authored-by: tanyue518 <ethan.tan@nxp.com>
Co-authored-by: Ethan Tan <nxf42555@lsvm11u0000160.swis.ap-northeast-2.aws.nxp.com>
Co-authored-by: Andrei Menzopol <andrei.menzopol@nxp.com>
Co-authored-by: Restyled.io <commits@restyled.io>