tree 2278a8593c2132a325ccb96b68d2e378733d62ab
parent 1a38286a552f0b41d9f0147bc73fc9e7fa232c6c
author jby-nxp <113013617+jby-nxp@users.noreply.github.com> 1729171758 +0200
committer GitHub <noreply@github.com> 1729171758 +0000
gpgsig -----BEGIN PGP SIGNATURE-----
 
 wsFcBAABCAAQBQJnEREuCRC1aQ7uu5UhlAAA2t0QAH7MSXuEfq0pKX2DNvMkXxtc
 Df23j/6kHFdrYjtiE9O5HgUooMDdyO0txhcnZNA5h2SGucEgw6qrb8+F3tNLyavB
 8BnPQxV0GfcpZFXEFW0muVHvAr12wL4TwU3F5ZPhpKn3d4Ma6INnJB9VJTdN+lLc
 yIKkzRt4eQn2FzN/SkznPi/CX13DuhVmNOgnjtT3aZP4E4cOLo2TDHlBclJ5E3Xn
 ke+wFIFNxVWfdwXVgghlogf1c4f+8raRNrj+bSn9BJFMl8QaIJgjlTOshz9IZ+6z
 FIU433/XqqKy6k9/knSXxa4h35Sqbr4An0FRqZNuN/wYc6OGIlxkh12E4j3njUKE
 nAJ+F+hoEQgExUy5+NHnQUTDDEd0RKFJ3hYdubf75igu/IN6tCBhiICFBI8ZBS6U
 PtQHGPFK7u7jcH4onVBIEslDtD2S7YeRvFOUIfQoezAC40gjAdHiCepJ29kI5Wh2
 y7Zs22cl0x/H5WyymxdMPxo4RpVJIAKFftBYLGDopeNMQIUpDaZ71rIhgtP3vcKg
 RbKmcEsPgPCRUQbOE88tcgVxWPFKGo4BJEmDsa1tEWAiF/MnmfLSrXWbnjMH1XRO
 RY5/XxCYVLbnVL3fvdaL8gNZi25ffQUlGSl9oIlhUuBYhwHz3aPPtS11obKWXFp0
 1D6zoEbl9j+QS0g3hQO1
 =z0lI
 -----END PGP SIGNATURE-----
 

NXP : Add support of RT1060 and RT1170 boards (#35842)

* [NXP][rt1170] Matter enablement on RT1170

It includes:

- Matter port files for RT1170
- example files for Laundry-washer, thermostat and all-cluster-app
- documentations

Signed-off-by: Gatien Chapon <gatien.chapon@nxp.com>

[border router][rt1170] RT1170 platform and README updates to support OTBR with new OT stack version

(cherry picked from commit f97d5c58c866774c787ec4417bca075ce45eece0)

[platform][rt1170] Enable lwip and ephemeral key CLI addons

(cherry picked from commit fb3320eabd3c3f6c8c75c4094d6426fcc0cfed57)

[2.16][rt1170] SDK 2.16 rt1170 API name changed

Signed-off-by: Gatien Chapon <gatien.chapon@nxp.com>
(cherry picked from commit 67f183263466267bc1c7da6fd3a05743fd268ea2)

Signed-off-by: Gatien Chapon <gatien.chapon@nxp.com>

[examples][rt1170] Enable Disgnostic log for thermostat app

Signed-off-by: Martin Girardot <martin.girardot@nxp.com>
(cherry picked from commit cce6267446d035e7966c7f5f17d112fb5f1557c5)

[platform][rt1170] Rename rt_nvm_component to nxp_nvm_component

Signed-off-by: Dina Benamar <dina.benamarelmaaroufi@nxp.com>
(cherry picked from commit f5fb5f4e8b2be45fc97c2a7c7a2d5a453adf9b34)

[doc][rt1170] update OTA guidelines to generate mcuboot binary

(cherry picked from commit 27f58810a07343234d0d884f385eb407998a9220)

* [NXP][rt1060] Adding RT1060 Matter support

It includes following changes:

- Matter port files for RT1060
- examples support for Laundry-washer, thermostat and all-cluster-app
- Support for configurations: RT1060 evkb+8801, RT1060 evkb+IW416, RT1060 evkc+IW612 and RT1060 evkb+k32w0

Signed-off-by: Gatien Chapon <gatien.chapon@nxp.com>

[platform][rt1060] Rename rt_nvm_component to nxp_nvm_component

Signed-off-by: Dina Benamar <dina.benamarelmaaroufi@nxp.com>
(cherry picked from commit 316450da02b365aa61bcb53a0dc6b50512fb6435)

[border router][rt1060] RT1060 platform and README updates to support OTBR with new OT stack version

(cherry picked from commit 231a4c15c4abca40d5759194fb61b9636c8f67e8)

[platform][rt1060] Enable lwip and ephemeral key CLI addons

(cherry picked from commit 463749a12abcc68fc5f6569f98c27b574b3516bd)

[2.16][rt1060] SDK 2.16 rt1060 API name changed

Signed-off-by: Gatien Chapon <gatien.chapon@nxp.com>
(cherry picked from commit 42f7d8771329172aaeedfde1b2bab86b1799f6d9)

[examples][rt1060] Enable Diagnostic log for thermostat app

Signed-off-by: Martin Girardot <martin.girardot@nxp.com>
(cherry picked from commit 7c4cbeb41d3a00ec90525bb084f7bc278d5ecb8e)

* [NXP][rt1060][doc] Update WiFi build instructions

* [NXP][border router][rt1060] Platform updates to support TBR cluster and secondary nwk if

A new gn variable was created, chip_enable_secondary_nwk_if, to enable or disable Thread as secondary network commissioning interface when building with BR support.

* [NXP][border router][rt1170] Platform updates to support TBR cluster and secondary nwk if

A new gn variable was created, chip_enable_secondary_nwk_if, to enable or disable Thread as secondary network commissioning interface when building with BR support.

* [NXP] Add targets RT1060 and RT1170 to NXP builds

* [NXP][OTA][doc] update OTA doc for RTs boards

* [NXP][border router][rt1060] fix compilation issue

* [NXP][border router][rt1170] fix compilation issue

* [NXP][doc][rt1060] minor changes

* [NXP] [rt1060] OTA requestor enablement on RT1060-EVKC+Firecrest

* [NXP] Add OTA variant to RT1060 and RT1170 builds

* [NXP][doc][rt] changes since workflow feedback

* [NXP][examples][rt1060] Update empty button registration path

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

* [NXP][examples][rt1170] Update empty button registration path

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

* [NXP] [gn] Restyle gn files

* [NXP][doc] Restyle md files

* [NXP] Restyle build scripts

* [NXP][RT] fix OTBR compile issue

* [NXP][RT][doc] rework documentation

* [NXP] Reduce and collapse NXP targets list

* [NXP] filter which target to be build on PR

* [NXP] [rt1170] remove useless flag

* [NXP] [rt1060] remove useless flag

* [NXP] [doc] fix path to referenced docs since NXP documentation moved

---------

Signed-off-by: marius-alex-tache <marius.tache@nxp.com>
Co-authored-by: Gatien Chapon <gatien.chapon@nxp.com>
Co-authored-by: Mihai Ignat <mihai.ignat@nxp.com>
Co-authored-by: Marius Preda <marius.preda@nxp.com>
Co-authored-by: marius-alex-tache <marius.tache@nxp.com>
Co-authored-by: Restyled.io <commits@restyled.io>