…telist

* Modify test case `*_wl_bad_args` to accept 0 whitelist entries.

We never include AdvA on primary channel so TxAdd should be set to 0 as
it's RFU in such case.

If scanned chain was truncated due to low buffers for HCI event we may
be already too late to remove next AUX from scheduler and thus can
receive next packet. Just ignore PDU if truncated was already sent.

Add new instance that advertises 1650 bytes of periodic data.

Fix typo in assert which make it never catch intended error.

hal_timer executes from ISR which was preempting LL task
and could result in HCI flow issues if unlucky.

controller/ble_ll_scan: For callouts number of ticks should be used

Those functions are expected to always consume txom.

Host Number of Completed Packets command is special as it doesn't
generate status event and thus is not send with ble_hs_hci_cmd_tx.

We should stil sync sending it with ble_hs_hci_cmd_tx() though to
avoid requesting more than one command buffer from HCI transport
(which may not be able to provide more).

Recently the RIOT IRQ API was extended to support irq_is_enabled(),
so time to switch away from the hacked implementation of
ble_npl_hw_is_in_critical().

When HCI command was received from USB transport cmd_len was not checked
and was used for memcpy.
It could lead to memory corruption if USB stack called this function with
size exceeding maximum command size. This is currently possible scenario
with TinyUSB stack (it will be fixed there as well).

If ble_hs_conn_chan_find_by_scid fails to find channel, it means
that destination CID in L2CAP Disconnection Request is invalid.
Send L2CAP_COMMAND_REJECT_RSP with BLE_L2CAP_SIG_ERR_INVALID_CID
reason.

This is affecting L2CAP/LE/CFC/BV-23-C

If receive data lenght exceeds what was defined in first packet
disconnect with peer.

This is affecting L2CAP/LE/CFC/BV-28-C

…NEWT_VAL_BLE_LL_RFMGMT_ENABLE_TIME is not defined).

When `MYNEWT_VAL_BLE_LL_RFMGMT_ENABLE_TIME` is not defined, the existing code always returns 0 as the "tick at which RF will be fully enabled".  However, this causes problems.  For example, in `ble_ll_adv_sm_start()` (ble_ll_adv.c:2743) the calculation of `delta` overflows when the system timer is between 0x80000000 and 0xFFFFFFFF -- causing an incorrect, huge adjustment to be made to the scheduled time, ultimately stopping the advertisements from being sent.

Let's use instance number as sid also, this makes it easier to find
those instances in the air.

Also fix instance numbers in comments.

'own_addr_type' and 'scan_filt_policy' are the same for both PHYs so no
need to keep them separately for each scanp. Also we already had
own_addr_type so usage of this parameter was somewhat inconsistent.

This change moves handling of scanning aux PDUs to separate unit and
thus simplifies code in ble_ll_scan. Basically, once ADV_EXT_IND is
scanned by main scansm, scanning aux PDUs is running as a separate
LL state and is handled by separate code.

Handling on aux PDUs was also refactored a bit, more importantly we
no longer need ref/unref for aux_data which caused lots of issues in
the past - aux_data is always only allocated in ISR context when
ADV_EXT_IND with AuxPtr is received and then can be freed only in
LL context if no subsequent scan is scheduled.

In addition, some changes were done to filtering routines so that now
filtering and address resolution is done only once for each scanned
ext advertising event, i.e. either on ADV_EXT_IND or AUX_ADV_IND.

There is still some legacy code for aux scanner left since it's used
by initiator role. This will be eventually removed once initiator is
refactored to use the same code as generic scanner.

We do not need to restrict TX time after sending LL_PHY_REQ as a master,
this only applies to slave.

This makes LL/CON/CEN/BV-53-C pass instead of being inconclusive due to
data fragmentation done by IUT between LL_PHY_REQ and LL_PHU_UPDATE_IND.

Ref: Core 5.x, Vol. 6, Part B, section 5.1.10.1

This is required for updated install script to work properly.

If adv item is removed from scheduler we should drop event instead
of just sending done event.

Sending done event instead can cause issues on extended advertising
instances if we remove aux items since it does not clear aux_active
flag. As a result, when done even is handled and we reached max_events,
HCI event will not be sent since it waits for done event for secondary
channel but that one won't cone since aux items are already removed.

Not used anymore.

Just clarify why we should return here instead of 'break'.

Not sure how this even works, but configuration flags for phys were
never set...

This is regression after eed4389.
Without this fix only SCAN_RSP are reported back to host...

Currently we initialize a lot of connsm settings prior to scheduling
1st connection event and this takes some time. However, we only need
connection interval, latency and supervision timeout to be initialized
in order to schedule event properly and send AUX_CONNECT_REQ, other
stuff can be done after tx has already started.

This is especially important on slower MCU like CMAC as with old code
it was barely possible to make tx within Tifs even on speed build.

New code saves ~15us on CMAC prior to tx so we have quite a good margin
to complete on time.

We ignore 2M values only for scanning since we do not scan on 2M when
ext conn create is pending, but there's nothing wrong in using those
parameters as fallback in case we established connection on phy that
was not in phy mask.

It looks like create_free_list() in glue.c requires word aligned
blocks which on 64-bit is 8 bytes.

Encrypted data PDU payload includes MIC, so we need to take this into
account when calculating actual payload size available for data.

This refactors all scheduling APIs (i.e. insertions to scheduler) to
use common code instead of reimplementing the same or similar flow
over and over again. The single 'ble_ll_sched_insert' call covers all
currently possible scenarios with minimal overhead so all existing
insertion APIs use it and add some more extra processing if needed.
Also it adds some flexibility via preemption callback so it's possible
to better define priorities for each item.

Since in RAM transport ACL data are passed simply as an mbuf pointer
between host and controller we can use max ACL data size to avoid data
fragmentation over HCI. This actually saves some RAM since we do not
need extra buffers for fragmented HCI ACL data.

We need to use proper user pkt header length when allocating new mbuf
for HCI ACL data fragment, otherwise leading space won't be set properly
and data may be overwritten.

See 20c4817 for reference.

Note: technically this does not make much sense since we use max HCI ACL
data size for combined build so fragmentation won't happen, but let's
fix it anyway just in case someone uses other value for whatever reason.

We should check if NRF_AAR was enabled prior to checking its result
to avoid reading some uninitialied values if resolver was not enabled.

This adds option to trace LLCP PDUs via HCI events. Each LLCP PDU is
sent in a vendor-specific HCI event which can be decoded e.g. by btmon.
Identifier and format of HCI event os the same as used by controllers
from Intel so it may be necessary to fake NimBLE's manufacturer id by
setting 'BLE_LL_MFRG_ID: 2' so btmon can decode events properly.

Scheduler item in sync sm can be initialize only once, no need to do
this on each event. Callbacks for ADV_SYNC_IND and ADV_CHAIN_IND are
pretty much the same except for wfr calculations so we'll just have
flag to indicate what is being scanned.

Compiling the hal_timer abstractions requires
nrf52_clock_hfxo_request() and _release() functions to be available.
This commit maps the appropriate RIOT functions in the NPL layer.

When trying to schedule connection events for a connection while
there are already advertising events as well as connections events
for other connections in the queue, ble_ll_sched_insert() triggers
an assertion failure. This happens, because `preemt_first` is not
reset for the case that the new event can not be scheduled. This
commit fixes this issue.

We should copy from om_data, not om_databuf.

In rare cases, tx-rx transition after rx may not be set properly and
this can result in a connection that is not established properly.

Transition type is set from ble_phy_tx which is called from sw_mac isr
and it should be set before bs_start is fired since it will setup that
transition. This is not a problem on 1st tx, but in case this happens
after rx, it may happen that bs_start is called before ble_phy_tx sets
transition type, so there will be no transition set. However, following
events will have proper transition set so they will act accordingly.
This probably can be recovered in most cases, but in case of extended
connection we will not receive AUX_CONNECT_RSP and will keep "waiting"
for it, so the connection will not be set properly before 1st conn
event and that results in an assert.

The fix is to block bs_ctrl interrupts on tx-rx transition to make sure
bs_start will not happen until ble_phy_tx sets transition correctly.
Similar flow is already used for 1st tx, i.e. bs_ctrl interrupts are
disabled by ble_phy_set_start_time and enabled again in ble_phy_tx.
Obviously, we also have to enable interrupts in ble_phy_disable in case
flow is interrupted somewhere in the middle.

AdvA was resolved only if corresponding flag is set. It's possible to
have rpa_index>0 and not resolved AdvA in case AdvA was an identity
address but it was added to rl.

This moves initiator state handling to generic scanner and removes
existing spearate ll_initiating state from LL and associated code.
By using generic code we no longer need to worry about maintaining two
separate instances of similar code since e.g. privacy and filtering
is done via the same code path. Also we no longer need old aux scanner
code so all remaining parts of that code can be removed.

This saves ~3K of flash (optimized build with all features enabled)
and also some RAM (mostly depending on pool size used by old aux
scanner).

This fixes handling of parameters used for conn init.

Firstly, we only need conn init params when intiating new connection so
we can have single, global instance of that params - no need to store
them in conns. This saves 72 bytes of RAM per connsm.

Secondly, we do not need to store all parameters from HCI command since
some of them are only used to initialize scanner and those can be used
immediately. We only need to store connection parameters for ext conn
create.

This also allows to share more code between legacy and ext conn create
code paths.

This is never accessed so looks like we do not need it (anymore)...

Turns out we already have one, so let's use it in new code.

As per CORE v5.3, Vol 3, Part C 10.7.1 NRPA should also rotate, same
as RPA is doing right now. For time beeing let's implement this in
tester application, before it's implemented in host.

This affects GAP/BROB/BCST/BV-04-C

Max scan window and interval is different for ext scan, we should allow
proper value to be used.

Also change func name to have proper prefix and define values to hex
values, as defined Core spec.

Use common prefix ble_ll_scan_hci for all HCI commands handlers in
ble_ll_scan.

Make sure we use 'running' and 'done' properly. This did not matter so
far since return value from sched_cb is not used anywhere, but this is
going to change.

When sched_q head changed we only should stop sched timer to make sure
it does not fire after we leave critical section and we can restart it
then without need for additional locking.

We do not need to change rfmgmt because in case new sched_q head is
later then previous one, rfmgmt will fire too early and we'll either
disable it immediately on restart or keep it enabled for upcoming item,
depending on timing.

For short aux offsets we can to usecs to ticks conversion using only
32-bit arithmetics without integer division. This is much faster than
generic routine, especially on M0 (e.g. CMAC) which does not have hw
support for integer division. The faster calculation is even more
accurate than generic one since it's never off by 1 tick.

This is a temporary solution until we have more generic timer routines
that do the same kind of optimizations.

This replaces sched_item_cb debug GPIO with sched_item that is set to
high state for the entire duration of sched item active time, i.e. from
sched run to LL standby. Note that sched_item_cb debugging is not that
useful since it's almost the same as sched_run, so we better replace
it instead of keeping both to avoid syscfg clutter.

No need to read more bytes and discard bits, we have helper that reads
exactly 24 bits :)

We should not free mbuf in BLE_GAP_EVENT_NOTIFY_RX since it's freed by
host after returning from event callback.

We do not really want to process aux PDUs when using legacy scanning.

If AUX_ADV_IND is ignored due to address mismatch in initiator it
should be marked as ignored, otherwise LL will assert since it assumes
that while initiating any valid PDU is either AUX_CONNECT_RSP or it
was an AUX_ADV_IND with AUX_CONNECT_REQ sent. In our case it will be
an AUX_ADV_IND without AUX_CONNECT_REQ sent...

Make sure we only try to setup LE Coded in scanner if both ext adv
(i.e. also ext scan) and LE Coded PHY are enabled.

If rx on aux scan is aborted, we need to set LL back to standby.

We cannot just initialize callout prior to restarting since this will
wipe it out and thus break callouts queue if it was already added there.
Instead, initialize once on module init.

This reverts commit c185dd6.

ble_ll_pdu_max_tx_octets_get() returns number of bytes that can be
added between LL header and CRC so the complete PDU is no longer than
maxTxTime allowed. However, if link is encrypted there will be also
MIC added after the payload so effectively we need to stript that extra
4 bytes from allowed payload length.

This adds BLE_LL_PUBLIC_DEV_ADDR which allows to conveniently set
public device address as 48-bit number. It has priority over existing
BLE_PUBLIC_DEV_ADDR which allows to do the same but in a very nasty
way via code injection so is not very intuitive to use.

ble_gattc_notify_custom() will trigger a GAP event so we cannot use it
inside GAP event handler as this will create infinite loop.

If the SRC field of the received message is a unicast
address of an element of the Low Power node, then the
message shall not be stored in the Friend Queue.

Otherwise, lpn will discard this message, eventually
it breaks friendship.

this is port of 5b11c053efcb6eec351bb275020fdac9ed6592d9

The mesh settings.c module is a giant piece of code responsible for
storing the mesh stack configuration. Such approach makes it difficult
to control the data to be stored, breaks the stack modules'
encapsulation by forcing them to reveal the internal kitchen, which
leads to unpleasant issues such as #19799.

This commit moves the responsibility of storing the configuration
to corresponding modules while keeping control of the moment of storing
the configuration and of starting the stack after the settingss loading
is completed.

This doesn't introduce any abstraction between the mesh settings.c and
other modules as it will add more complexity and overhead than necessary
for the actual task.

This is a port of 561a8e4f0e9ff43d878f382de4d1052e025febec

pass cid instead of CID_NVAL in parameters of mod_member_list_get

This is port of 3ff1eb618fd50ecb4328d0f832471caaec7be3ee

pass cid instead of CID_NVAL in parameters of mod_member_list_get

This is port of 942979b252a46602213656107d6b5b6a5e98615c

After #31176, the network would get stored immediately in
bt_mesh_net_create, causing the address and devicekey to get stored as
their zero-initialized version, as they're only being set in the
bt_mesh_comp_provision call, which fires after.

This is port of a281d10cff8d0e626fcc31897649f4312c794a4e

Sets the sequence number when re-encrypting messages from the friend to
the lpn.

This is port of 512444d863f0e4de69ea600dda37b11f032e9707

Include virtual label's pending_store function in the LABEL_COUNT > 0
compile guard to avoid including dead iteration code in the compilation.

This is port of 7039675df13c74e74fb76d4f41cfc7e949c209ad

If CONFIG_BT_MESH_SEQ_STORE_RATE is 1, the check in store_seq can be
reduced to a simple if (false), and the modulo code does not need to be
included in the build.

This is port of aef354c6bc3264de9f2a38b8c56ff5253b35912a

Updated k_work API to new behaviour reflected in `glue`.

This is port of:
81b9ba3a9b2dd4d5bd3f0966eac9f8f6dad983e6
17831b045f5869b0e57e26caa0441f263d1a5ae6
6a097caa22c769855aba552b50371bafe05ee6b4
5506727bde18bb9afcf4f1b969cd2cc09d7e65f8

To prevent the transport layer from accepting duplicate or out of order
segmented messages, add an RPL-like check for the SeqAuth of the
segmented messages when their context is allocated. This prevents
duplicate receives of the same segmented messages in the case where a
single source address sends two segmented messages in parallel (to two
different addresses):

Previously, when receiving two segmented messages, the first message
would go through to the access layer, then the second. Then, if the
transport layer received any repeated segments for the first message, it
would fail to identify the SeqAuth as old, as all its segments were of
new sequence numbers, and the "already complete SDU" check would only
look at the second message. Thus, the segmented message got processed
again and passed to the access layer, even though it was a duplicate.

To solve this, we need a mechanism like RPL, but only for the segmented
messages' SeqAuth. We cannot re-use the actual RPL mechanism, as it
can't support the scenario provoked by the "blocking tx" mechanism in
transport. This mechanism allocates the SeqAuth when the message is
first passed to the transport layer. The ongoing message that caused the
block would keep sending segments with higher sequence numbers than
the blocked message got, which will cause the blocked message to fail
the RPL check.

This patch adds a parallel SeqAuth mechanism to the RPL module, which
only deals with the SeqAuth of the segmented messages. This list gets
checked when the segmented message is first allocated, in the same
manner as the general RPL mechanism. The storage gets hooked into the
RPL mechanism, by adding a separate seg field to each RPL entry.

This is port of 4fbd0cb0ca6bead0354f54808da3224302d98c28

The Health Fast Period Divisor is stored within
the model publish parameters on the access layer.
The opposite part for divisor restoring has been missed.

This is port of 73e1c6a77d71f8b51746946f78f0b3525101e1c0

Instead of silently closing the link we should send a Link Close message
three times before resetting provisioning state.

From Mesh Profile Specification v1.0.1.:
```
5.3.1.4.3 Link Close message

The Link Close message is used to close a link.
```

```
5.3.2 Link Establishment procedure

The device shall start the link timer, set to 60 seconds, when the link
is open. When the link timer expires, then the device shall close the
link.
```

```
5.3.3 Generic Provisioning behavior

If the sender does not receive a Transaction Acknowledgment message
within 30 seconds after sending the first message in a transaction,
the sender shall cancel the transaction, cancel the provisioning
process and close the link.
```

From Mesh Profile Test Specification p6:
```
MESH/PVNR/PBADV/BV-01-C

Test Procedure:
[...]
6. The IUT is induced to send a Link Close message with the Reason field
set to 0x02 to terminate the link. The message is sent at least three
times to ensure the message is received by the Lower Tester.
```

This is port of 497d9df96acde1d28f7cd83c786e496e8ea0db67

The first byte of the composition data status message is the returned
page index, not the status of the request. This is now reflected in the
API.

This is port of 9259b199bba0ae982632c36069a472b197627521

Adds a parsing mechanism for Composition data page 0 in the Config
Client API, and uses it in the shell module to parse the incoming
composition data.

This is port of b84fee5190cd72e9d31fa820aaa5d8684ad4a11c

The implementation of blocking calls is common for all the client
models.

This change reduces the code duplication by introducing new API that
helps to manage acknowledged messages.

This is port of a94c7e3a23fc1225aec9f13c1e37cc2853f70c82 and
c5e4011e29b878fc1771876fc30db0ddcc084829