| /* |
| * Copyright (c) 2020 Nordic Semiconductor ASA |
| * Copyright (c) 2020 Demant |
| * |
| * SPDX-License-Identifier: Apache-2.0 |
| */ |
| |
| #include "zephyr/types.h" |
| #include "zephyr/ztest.h" |
| |
| #include <zephyr/bluetooth/hci.h> |
| #include <zephyr/sys/byteorder.h> |
| #include <zephyr/sys/slist.h> |
| #include <zephyr/sys/util.h> |
| |
| #include "hal/ccm.h" |
| |
| #include "util/util.h" |
| #include "util/mem.h" |
| #include "util/memq.h" |
| #include "util/dbuf.h" |
| |
| #include "pdu_df.h" |
| #include "lll/pdu_vendor.h" |
| #include "pdu.h" |
| #include "ll.h" |
| #include "ll_settings.h" |
| #include "ll_feat.h" |
| |
| #include "lll.h" |
| #include "lll/lll_df_types.h" |
| #include "lll_conn_iso.h" |
| |
| #include "lll_conn.h" |
| #include "ull_tx_queue.h" |
| #include "isoal.h" |
| #include "ull_iso_types.h" |
| #include "ull_conn_types.h" |
| #include "ull_conn_iso_types.h" |
| |
| #include "ull_llcp.h" |
| |
| #include "helper_pdu.h" |
| #include "helper_features.h" |
| |
| #define PDU_MEM_EQUAL(_f, _s, _p, _t) \ |
| zassert_mem_equal(_s._f, _p->_f, sizeof(_p->_f), _t "\nCalled at %s:%d\n", file, line); |
| |
| void helper_pdu_encode_ping_req(struct pdu_data *pdu, void *param) |
| { |
| pdu->ll_id = PDU_DATA_LLID_CTRL; |
| pdu->len = offsetof(struct pdu_data_llctrl, ping_req) + |
| sizeof(struct pdu_data_llctrl_ping_req); |
| pdu->llctrl.opcode = PDU_DATA_LLCTRL_TYPE_PING_REQ; |
| } |
| |
| void helper_pdu_encode_ping_rsp(struct pdu_data *pdu, void *param) |
| { |
| pdu->ll_id = PDU_DATA_LLID_CTRL; |
| pdu->len = offsetof(struct pdu_data_llctrl, ping_rsp) + |
| sizeof(struct pdu_data_llctrl_ping_rsp); |
| pdu->llctrl.opcode = PDU_DATA_LLCTRL_TYPE_PING_RSP; |
| } |
| |
| void helper_pdu_encode_feature_req(struct pdu_data *pdu, void *param) |
| { |
| struct pdu_data_llctrl_feature_req *feature_req = param; |
| |
| pdu->ll_id = PDU_DATA_LLID_CTRL; |
| pdu->len = offsetof(struct pdu_data_llctrl, feature_req) + |
| sizeof(struct pdu_data_llctrl_feature_req); |
| pdu->llctrl.opcode = PDU_DATA_LLCTRL_TYPE_FEATURE_REQ; |
| for (int counter = 0; counter < 8; counter++) { |
| uint8_t expected_value = feature_req->features[counter]; |
| |
| pdu->llctrl.feature_req.features[counter] = expected_value; |
| } |
| } |
| void helper_pdu_encode_peripheral_feature_req(struct pdu_data *pdu, void *param) |
| { |
| struct pdu_data_llctrl_feature_req *feature_req = param; |
| |
| pdu->ll_id = PDU_DATA_LLID_CTRL; |
| pdu->len = offsetof(struct pdu_data_llctrl, feature_req) + |
| sizeof(struct pdu_data_llctrl_feature_req); |
| pdu->llctrl.opcode = PDU_DATA_LLCTRL_TYPE_PER_INIT_FEAT_XCHG; |
| |
| for (int counter = 0; counter < 8; counter++) { |
| uint8_t expected_value = feature_req->features[counter]; |
| |
| pdu->llctrl.feature_req.features[counter] = expected_value; |
| } |
| } |
| |
| void helper_pdu_encode_feature_rsp(struct pdu_data *pdu, void *param) |
| { |
| struct pdu_data_llctrl_feature_rsp *feature_rsp = param; |
| |
| pdu->ll_id = PDU_DATA_LLID_CTRL; |
| pdu->len = offsetof(struct pdu_data_llctrl, feature_rsp) + |
| sizeof(struct pdu_data_llctrl_feature_rsp); |
| pdu->llctrl.opcode = PDU_DATA_LLCTRL_TYPE_FEATURE_RSP; |
| for (int counter = 0; counter < 8; counter++) { |
| uint8_t expected_value = feature_rsp->features[counter]; |
| |
| pdu->llctrl.feature_req.features[counter] = expected_value; |
| } |
| } |
| |
| void helper_pdu_encode_min_used_chans_ind(struct pdu_data *pdu, void *param) |
| { |
| struct pdu_data_llctrl_min_used_chans_ind *p = param; |
| |
| pdu->ll_id = PDU_DATA_LLID_CTRL; |
| pdu->len = offsetof(struct pdu_data_llctrl, min_used_chans_ind) + |
| sizeof(struct pdu_data_llctrl_min_used_chans_ind); |
| pdu->llctrl.opcode = PDU_DATA_LLCTRL_TYPE_MIN_USED_CHAN_IND; |
| pdu->llctrl.min_used_chans_ind.phys = p->phys; |
| pdu->llctrl.min_used_chans_ind.min_used_chans = p->min_used_chans; |
| } |
| |
| void helper_pdu_encode_version_ind(struct pdu_data *pdu, void *param) |
| { |
| struct pdu_data_llctrl_version_ind *p = param; |
| |
| pdu->ll_id = PDU_DATA_LLID_CTRL; |
| pdu->len = offsetof(struct pdu_data_llctrl, version_ind) + |
| sizeof(struct pdu_data_llctrl_version_ind); |
| pdu->llctrl.opcode = PDU_DATA_LLCTRL_TYPE_VERSION_IND; |
| pdu->llctrl.version_ind.version_number = p->version_number; |
| pdu->llctrl.version_ind.company_id = p->company_id; |
| pdu->llctrl.version_ind.sub_version_number = p->sub_version_number; |
| } |
| |
| void helper_pdu_encode_enc_req(struct pdu_data *pdu, void *param) |
| { |
| struct pdu_data_llctrl_enc_req *p = param; |
| |
| pdu->ll_id = PDU_DATA_LLID_CTRL; |
| pdu->len = |
| offsetof(struct pdu_data_llctrl, enc_req) + sizeof(struct pdu_data_llctrl_enc_req); |
| pdu->llctrl.opcode = PDU_DATA_LLCTRL_TYPE_ENC_REQ; |
| memcpy(pdu->llctrl.enc_req.rand, p->rand, sizeof(pdu->llctrl.enc_req.rand)); |
| memcpy(pdu->llctrl.enc_req.ediv, p->ediv, sizeof(pdu->llctrl.enc_req.ediv)); |
| memcpy(pdu->llctrl.enc_req.skdm, p->skdm, sizeof(pdu->llctrl.enc_req.skdm)); |
| memcpy(pdu->llctrl.enc_req.ivm, p->ivm, sizeof(pdu->llctrl.enc_req.ivm)); |
| } |
| |
| void helper_pdu_encode_enc_rsp(struct pdu_data *pdu, void *param) |
| { |
| struct pdu_data_llctrl_enc_rsp *p = param; |
| |
| pdu->ll_id = PDU_DATA_LLID_CTRL; |
| pdu->len = |
| offsetof(struct pdu_data_llctrl, enc_rsp) + sizeof(struct pdu_data_llctrl_enc_rsp); |
| pdu->llctrl.opcode = PDU_DATA_LLCTRL_TYPE_ENC_RSP; |
| memcpy(pdu->llctrl.enc_rsp.skds, p->skds, sizeof(pdu->llctrl.enc_rsp.skds)); |
| memcpy(pdu->llctrl.enc_rsp.ivs, p->ivs, sizeof(pdu->llctrl.enc_rsp.ivs)); |
| } |
| |
| void helper_pdu_encode_start_enc_req(struct pdu_data *pdu, void *param) |
| { |
| pdu->ll_id = PDU_DATA_LLID_CTRL; |
| pdu->len = offsetof(struct pdu_data_llctrl, start_enc_req) + |
| sizeof(struct pdu_data_llctrl_start_enc_req); |
| pdu->llctrl.opcode = PDU_DATA_LLCTRL_TYPE_START_ENC_REQ; |
| } |
| |
| void helper_pdu_encode_start_enc_rsp(struct pdu_data *pdu, void *param) |
| { |
| pdu->ll_id = PDU_DATA_LLID_CTRL; |
| pdu->len = offsetof(struct pdu_data_llctrl, start_enc_rsp) + |
| sizeof(struct pdu_data_llctrl_start_enc_rsp); |
| pdu->llctrl.opcode = PDU_DATA_LLCTRL_TYPE_START_ENC_RSP; |
| } |
| |
| void helper_pdu_encode_pause_enc_req(struct pdu_data *pdu, void *param) |
| { |
| pdu->ll_id = PDU_DATA_LLID_CTRL; |
| pdu->len = offsetof(struct pdu_data_llctrl, pause_enc_req) + |
| sizeof(struct pdu_data_llctrl_pause_enc_req); |
| pdu->llctrl.opcode = PDU_DATA_LLCTRL_TYPE_PAUSE_ENC_REQ; |
| } |
| |
| void helper_pdu_encode_pause_enc_rsp(struct pdu_data *pdu, void *param) |
| { |
| pdu->ll_id = PDU_DATA_LLID_CTRL; |
| pdu->len = offsetof(struct pdu_data_llctrl, pause_enc_rsp) + |
| sizeof(struct pdu_data_llctrl_pause_enc_rsp); |
| pdu->llctrl.opcode = PDU_DATA_LLCTRL_TYPE_PAUSE_ENC_RSP; |
| } |
| |
| void helper_pdu_encode_reject_ext_ind(struct pdu_data *pdu, void *param) |
| { |
| struct pdu_data_llctrl_reject_ext_ind *p = param; |
| |
| pdu->ll_id = PDU_DATA_LLID_CTRL; |
| pdu->len = offsetof(struct pdu_data_llctrl, reject_ext_ind) + |
| sizeof(struct pdu_data_llctrl_reject_ext_ind); |
| pdu->llctrl.opcode = PDU_DATA_LLCTRL_TYPE_REJECT_EXT_IND; |
| pdu->llctrl.reject_ext_ind.reject_opcode = p->reject_opcode; |
| pdu->llctrl.reject_ext_ind.error_code = p->error_code; |
| } |
| |
| void helper_pdu_encode_reject_ind(struct pdu_data *pdu, void *param) |
| { |
| struct pdu_data_llctrl_reject_ind *p = param; |
| |
| pdu->ll_id = PDU_DATA_LLID_CTRL; |
| pdu->len = offsetof(struct pdu_data_llctrl, reject_ind) + |
| sizeof(struct pdu_data_llctrl_reject_ind); |
| pdu->llctrl.opcode = PDU_DATA_LLCTRL_TYPE_REJECT_IND; |
| pdu->llctrl.reject_ind.error_code = p->error_code; |
| } |
| |
| void helper_pdu_encode_phy_req(struct pdu_data *pdu, void *param) |
| { |
| struct pdu_data_llctrl_phy_req *p = param; |
| |
| pdu->ll_id = PDU_DATA_LLID_CTRL; |
| pdu->len = |
| offsetof(struct pdu_data_llctrl, phy_req) + sizeof(struct pdu_data_llctrl_phy_req); |
| pdu->llctrl.opcode = PDU_DATA_LLCTRL_TYPE_PHY_REQ; |
| pdu->llctrl.phy_req.rx_phys = p->rx_phys; |
| pdu->llctrl.phy_req.tx_phys = p->tx_phys; |
| } |
| |
| void helper_pdu_encode_phy_rsp(struct pdu_data *pdu, void *param) |
| { |
| struct pdu_data_llctrl_phy_rsp *p = param; |
| |
| pdu->ll_id = PDU_DATA_LLID_CTRL; |
| pdu->len = |
| offsetof(struct pdu_data_llctrl, phy_rsp) + sizeof(struct pdu_data_llctrl_phy_rsp); |
| pdu->llctrl.opcode = PDU_DATA_LLCTRL_TYPE_PHY_RSP; |
| pdu->llctrl.phy_rsp.rx_phys = p->rx_phys; |
| pdu->llctrl.phy_rsp.tx_phys = p->tx_phys; |
| } |
| |
| void helper_pdu_encode_phy_update_ind(struct pdu_data *pdu, void *param) |
| { |
| struct pdu_data_llctrl_phy_upd_ind *p = param; |
| |
| pdu->ll_id = PDU_DATA_LLID_CTRL; |
| pdu->len = offsetof(struct pdu_data_llctrl, phy_upd_ind) + |
| sizeof(struct pdu_data_llctrl_phy_upd_ind); |
| pdu->llctrl.opcode = PDU_DATA_LLCTRL_TYPE_PHY_UPD_IND; |
| pdu->llctrl.phy_upd_ind.instant = p->instant; |
| pdu->llctrl.phy_upd_ind.c_to_p_phy = p->c_to_p_phy; |
| pdu->llctrl.phy_upd_ind.p_to_c_phy = p->p_to_c_phy; |
| } |
| |
| void helper_pdu_encode_unknown_rsp(struct pdu_data *pdu, void *param) |
| { |
| struct pdu_data_llctrl_unknown_rsp *p = param; |
| |
| pdu->ll_id = PDU_DATA_LLID_CTRL; |
| pdu->len = offsetof(struct pdu_data_llctrl, unknown_rsp) + |
| sizeof(struct pdu_data_llctrl_unknown_rsp); |
| pdu->llctrl.opcode = PDU_DATA_LLCTRL_TYPE_UNKNOWN_RSP; |
| pdu->llctrl.unknown_rsp.type = p->type; |
| } |
| |
| void helper_pdu_encode_conn_param_req(struct pdu_data *pdu, void *param) |
| { |
| struct pdu_data_llctrl_conn_param_req *p = param; |
| |
| pdu->ll_id = PDU_DATA_LLID_CTRL; |
| pdu->len = offsetof(struct pdu_data_llctrl, conn_param_req) + |
| sizeof(struct pdu_data_llctrl_conn_param_req); |
| pdu->llctrl.opcode = PDU_DATA_LLCTRL_TYPE_CONN_PARAM_REQ; |
| |
| pdu->llctrl.conn_param_req.interval_min = sys_cpu_to_le16(p->interval_min); |
| pdu->llctrl.conn_param_req.interval_max = sys_cpu_to_le16(p->interval_max); |
| pdu->llctrl.conn_param_req.latency = sys_cpu_to_le16(p->latency); |
| pdu->llctrl.conn_param_req.timeout = sys_cpu_to_le16(p->timeout); |
| pdu->llctrl.conn_param_req.preferred_periodicity = p->preferred_periodicity; |
| pdu->llctrl.conn_param_req.reference_conn_event_count = |
| sys_cpu_to_le16(p->reference_conn_event_count); |
| pdu->llctrl.conn_param_req.offset0 = sys_cpu_to_le16(p->offset0); |
| pdu->llctrl.conn_param_req.offset1 = sys_cpu_to_le16(p->offset1); |
| pdu->llctrl.conn_param_req.offset2 = sys_cpu_to_le16(p->offset2); |
| pdu->llctrl.conn_param_req.offset3 = sys_cpu_to_le16(p->offset3); |
| pdu->llctrl.conn_param_req.offset4 = sys_cpu_to_le16(p->offset4); |
| pdu->llctrl.conn_param_req.offset5 = sys_cpu_to_le16(p->offset5); |
| } |
| |
| void helper_pdu_encode_conn_param_rsp(struct pdu_data *pdu, void *param) |
| { |
| struct pdu_data_llctrl_conn_param_rsp *p = param; |
| |
| pdu->ll_id = PDU_DATA_LLID_CTRL; |
| pdu->len = offsetof(struct pdu_data_llctrl, conn_param_rsp) + |
| sizeof(struct pdu_data_llctrl_conn_param_rsp); |
| pdu->llctrl.opcode = PDU_DATA_LLCTRL_TYPE_CONN_PARAM_RSP; |
| |
| pdu->llctrl.conn_param_rsp.interval_min = sys_cpu_to_le16(p->interval_min); |
| pdu->llctrl.conn_param_rsp.interval_max = sys_cpu_to_le16(p->interval_max); |
| pdu->llctrl.conn_param_rsp.latency = sys_cpu_to_le16(p->latency); |
| pdu->llctrl.conn_param_rsp.timeout = sys_cpu_to_le16(p->timeout); |
| pdu->llctrl.conn_param_rsp.preferred_periodicity = p->preferred_periodicity; |
| pdu->llctrl.conn_param_rsp.reference_conn_event_count = |
| sys_cpu_to_le16(p->reference_conn_event_count); |
| pdu->llctrl.conn_param_rsp.offset0 = sys_cpu_to_le16(p->offset0); |
| pdu->llctrl.conn_param_rsp.offset1 = sys_cpu_to_le16(p->offset1); |
| pdu->llctrl.conn_param_rsp.offset2 = sys_cpu_to_le16(p->offset2); |
| pdu->llctrl.conn_param_rsp.offset3 = sys_cpu_to_le16(p->offset3); |
| pdu->llctrl.conn_param_rsp.offset4 = sys_cpu_to_le16(p->offset4); |
| pdu->llctrl.conn_param_rsp.offset5 = sys_cpu_to_le16(p->offset5); |
| } |
| |
| void helper_pdu_encode_conn_update_ind(struct pdu_data *pdu, void *param) |
| { |
| struct pdu_data_llctrl_conn_update_ind *p = param; |
| |
| pdu->ll_id = PDU_DATA_LLID_CTRL; |
| pdu->len = offsetof(struct pdu_data_llctrl, conn_update_ind) + |
| sizeof(struct pdu_data_llctrl_conn_update_ind); |
| pdu->llctrl.opcode = PDU_DATA_LLCTRL_TYPE_CONN_UPDATE_IND; |
| |
| pdu->llctrl.conn_update_ind.win_size = p->win_size; |
| pdu->llctrl.conn_update_ind.win_offset = sys_cpu_to_le16(p->win_offset); |
| pdu->llctrl.conn_update_ind.interval = sys_cpu_to_le16(p->interval); |
| pdu->llctrl.conn_update_ind.latency = sys_cpu_to_le16(p->latency); |
| pdu->llctrl.conn_update_ind.timeout = sys_cpu_to_le16(p->timeout); |
| pdu->llctrl.conn_update_ind.instant = sys_cpu_to_le16(p->instant); |
| } |
| |
| void helper_pdu_encode_terminate_ind(struct pdu_data *pdu, void *param) |
| { |
| struct pdu_data_llctrl_terminate_ind *p = param; |
| |
| pdu->ll_id = PDU_DATA_LLID_CTRL; |
| pdu->len = offsetof(struct pdu_data_llctrl, terminate_ind) + |
| sizeof(struct pdu_data_llctrl_terminate_ind); |
| pdu->llctrl.opcode = PDU_DATA_LLCTRL_TYPE_TERMINATE_IND; |
| pdu->llctrl.terminate_ind.error_code = p->error_code; |
| } |
| |
| void helper_pdu_encode_channel_map_update_ind(struct pdu_data *pdu, void *param) |
| { |
| struct pdu_data_llctrl_chan_map_ind *p = param; |
| |
| pdu->ll_id = PDU_DATA_LLID_CTRL; |
| pdu->len = offsetof(struct pdu_data_llctrl, chan_map_ind) + |
| sizeof(struct pdu_data_llctrl_chan_map_ind); |
| pdu->llctrl.opcode = PDU_DATA_LLCTRL_TYPE_CHAN_MAP_IND; |
| pdu->llctrl.chan_map_ind.instant = p->instant; |
| memcpy(pdu->llctrl.chan_map_ind.chm, p->chm, sizeof(pdu->llctrl.chan_map_ind.chm)); |
| } |
| |
| void helper_pdu_encode_length_req(struct pdu_data *pdu, void *param) |
| { |
| struct pdu_data_llctrl_length_req *p = param; |
| |
| pdu->ll_id = PDU_DATA_LLID_CTRL; |
| pdu->len = offsetof(struct pdu_data_llctrl, length_req) + |
| sizeof(struct pdu_data_llctrl_length_req); |
| pdu->llctrl.opcode = PDU_DATA_LLCTRL_TYPE_LENGTH_REQ; |
| |
| pdu->llctrl.length_req.max_rx_octets = p->max_rx_octets; |
| pdu->llctrl.length_req.max_tx_octets = p->max_tx_octets; |
| pdu->llctrl.length_req.max_rx_time = p->max_rx_time; |
| pdu->llctrl.length_req.max_tx_time = p->max_tx_time; |
| } |
| |
| void helper_pdu_encode_length_rsp(struct pdu_data *pdu, void *param) |
| { |
| struct pdu_data_llctrl_length_rsp *p = param; |
| |
| pdu->ll_id = PDU_DATA_LLID_CTRL; |
| pdu->len = offsetof(struct pdu_data_llctrl, length_rsp) + |
| sizeof(struct pdu_data_llctrl_length_rsp); |
| pdu->llctrl.opcode = PDU_DATA_LLCTRL_TYPE_LENGTH_RSP; |
| |
| pdu->llctrl.length_req.max_rx_octets = p->max_rx_octets; |
| pdu->llctrl.length_req.max_tx_octets = p->max_tx_octets; |
| pdu->llctrl.length_req.max_rx_time = p->max_rx_time; |
| pdu->llctrl.length_req.max_tx_time = p->max_tx_time; |
| } |
| void helper_pdu_encode_cte_req(struct pdu_data *pdu, void *param) |
| { |
| struct pdu_data_llctrl_cte_req *p = param; |
| |
| pdu->ll_id = PDU_DATA_LLID_CTRL; |
| pdu->len = |
| offsetof(struct pdu_data_llctrl, cte_req) + sizeof(struct pdu_data_llctrl_cte_req); |
| pdu->llctrl.opcode = PDU_DATA_LLCTRL_TYPE_CTE_REQ; |
| pdu->llctrl.cte_req.min_cte_len_req = p->min_cte_len_req; |
| pdu->llctrl.cte_req.cte_type_req = p->cte_type_req; |
| } |
| |
| void helper_pdu_encode_cte_rsp(struct pdu_data *pdu, void *param) |
| { |
| pdu->ll_id = PDU_DATA_LLID_CTRL; |
| pdu->len = |
| offsetof(struct pdu_data_llctrl, cte_rsp) + sizeof(struct pdu_data_llctrl_cte_rsp); |
| pdu->llctrl.opcode = PDU_DATA_LLCTRL_TYPE_CTE_RSP; |
| } |
| |
| void helper_pdu_encode_zero(struct pdu_data *pdu, void *param) |
| { |
| pdu->ll_id = PDU_DATA_LLID_CTRL; |
| pdu->len = 0; |
| } |
| |
| void helper_node_encode_cte_rsp(struct node_rx_pdu *rx, void *param) |
| { |
| rx->hdr.rx_ftr.iq_report = (struct cte_conn_iq_report *)param; |
| } |
| |
| void helper_pdu_encode_cis_req(struct pdu_data *pdu, void *param) |
| { |
| struct pdu_data_llctrl_cis_req *p = param; |
| |
| pdu->ll_id = PDU_DATA_LLID_CTRL; |
| pdu->len = offsetof(struct pdu_data_llctrl, cis_req) + |
| sizeof(struct pdu_data_llctrl_cis_req); |
| pdu->llctrl.opcode = PDU_DATA_LLCTRL_TYPE_CIS_REQ; |
| |
| pdu->llctrl.cis_req.cig_id = p->cig_id; |
| pdu->llctrl.cis_req.cis_id = p->cis_id; |
| pdu->llctrl.cis_req.c_phy = p->c_phy; |
| pdu->llctrl.cis_req.p_phy = p->p_phy; |
| pdu->llctrl.cis_req.c_max_pdu = p->c_max_pdu; |
| pdu->llctrl.cis_req.p_max_pdu = p->p_max_pdu; |
| pdu->llctrl.cis_req.nse = p->nse; |
| pdu->llctrl.cis_req.p_bn = p->p_bn; |
| pdu->llctrl.cis_req.c_bn = p->c_bn; |
| pdu->llctrl.cis_req.c_ft = p->c_ft; |
| pdu->llctrl.cis_req.p_ft = p->p_ft; |
| pdu->llctrl.cis_req.iso_interval = p->iso_interval; |
| pdu->llctrl.cis_req.conn_event_count = p->conn_event_count; |
| memcpy(pdu->llctrl.cis_req.c_max_sdu_packed, p->c_max_sdu_packed, |
| sizeof(p->c_max_sdu_packed)); |
| memcpy(pdu->llctrl.cis_req.p_max_sdu, p->p_max_sdu, sizeof(p->p_max_sdu)); |
| memcpy(pdu->llctrl.cis_req.c_sdu_interval, p->c_sdu_interval, sizeof(p->c_sdu_interval)); |
| memcpy(pdu->llctrl.cis_req.p_sdu_interval, p->p_sdu_interval, sizeof(p->p_sdu_interval)); |
| memcpy(pdu->llctrl.cis_req.sub_interval, p->sub_interval, sizeof(p->sub_interval)); |
| memcpy(pdu->llctrl.cis_req.cis_offset_min, p->cis_offset_min, sizeof(p->cis_offset_min)); |
| memcpy(pdu->llctrl.cis_req.cis_offset_max, p->cis_offset_max, sizeof(p->cis_offset_max)); |
| } |
| |
| void helper_pdu_encode_cis_rsp(struct pdu_data *pdu, void *param) |
| { |
| struct pdu_data_llctrl_cis_rsp *p = param; |
| |
| pdu->ll_id = PDU_DATA_LLID_CTRL; |
| pdu->len = offsetof(struct pdu_data_llctrl, cis_rsp) + |
| sizeof(struct pdu_data_llctrl_cis_rsp); |
| pdu->llctrl.opcode = PDU_DATA_LLCTRL_TYPE_CIS_RSP; |
| memcpy(pdu->llctrl.cis_rsp.cis_offset_min, p->cis_offset_min, sizeof(p->cis_offset_min)); |
| memcpy(pdu->llctrl.cis_rsp.cis_offset_max, p->cis_offset_max, sizeof(p->cis_offset_max)); |
| pdu->llctrl.cis_rsp.conn_event_count = p->conn_event_count; |
| } |
| |
| void helper_pdu_encode_cis_ind(struct pdu_data *pdu, void *param) |
| { |
| struct pdu_data_llctrl_cis_ind *p = param; |
| |
| pdu->ll_id = PDU_DATA_LLID_CTRL; |
| pdu->len = offsetof(struct pdu_data_llctrl, cis_ind) + |
| sizeof(struct pdu_data_llctrl_cis_ind); |
| pdu->llctrl.opcode = PDU_DATA_LLCTRL_TYPE_CIS_IND; |
| memcpy(pdu->llctrl.cis_ind.aa, p->aa, sizeof(p->aa)); |
| memcpy(pdu->llctrl.cis_ind.cis_offset, p->cis_offset, sizeof(p->cis_offset)); |
| memcpy(pdu->llctrl.cis_ind.cig_sync_delay, p->cig_sync_delay, sizeof(p->cig_sync_delay)); |
| memcpy(pdu->llctrl.cis_ind.cis_sync_delay, p->cis_sync_delay, sizeof(p->cis_sync_delay)); |
| pdu->llctrl.cis_ind.conn_event_count = p->conn_event_count; |
| } |
| |
| void helper_pdu_encode_cis_terminate_ind(struct pdu_data *pdu, void *param) |
| { |
| struct pdu_data_llctrl_cis_terminate_ind *p = param; |
| |
| pdu->ll_id = PDU_DATA_LLID_CTRL; |
| pdu->len = offsetof(struct pdu_data_llctrl, cis_terminate_ind) + |
| sizeof(struct pdu_data_llctrl_cis_terminate_ind); |
| pdu->llctrl.opcode = PDU_DATA_LLCTRL_TYPE_CIS_TERMINATE_IND; |
| pdu->llctrl.cis_terminate_ind.cig_id = p->cig_id; |
| pdu->llctrl.cis_terminate_ind.cis_id = p->cis_id; |
| pdu->llctrl.cis_terminate_ind.error_code = p->error_code; |
| } |
| |
| void helper_pdu_encode_sca_req(struct pdu_data *pdu, void *param) |
| { |
| struct pdu_data_llctrl_clock_accuracy_req *p = param; |
| |
| pdu->ll_id = PDU_DATA_LLID_CTRL; |
| pdu->len = offsetof(struct pdu_data_llctrl, clock_accuracy_req) + |
| sizeof(struct pdu_data_llctrl_clock_accuracy_req); |
| pdu->llctrl.opcode = PDU_DATA_LLCTRL_TYPE_CLOCK_ACCURACY_REQ; |
| pdu->llctrl.clock_accuracy_req.sca = p->sca; |
| } |
| |
| void helper_pdu_encode_sca_rsp(struct pdu_data *pdu, void *param) |
| { |
| struct pdu_data_llctrl_clock_accuracy_rsp *p = param; |
| |
| pdu->ll_id = PDU_DATA_LLID_CTRL; |
| pdu->len = offsetof(struct pdu_data_llctrl, clock_accuracy_rsp) + |
| sizeof(struct pdu_data_llctrl_clock_accuracy_rsp); |
| pdu->llctrl.opcode = PDU_DATA_LLCTRL_TYPE_CLOCK_ACCURACY_RSP; |
| pdu->llctrl.clock_accuracy_rsp.sca = p->sca; |
| } |
| |
| void helper_pdu_verify_version_ind(const char *file, uint32_t line, struct pdu_data *pdu, |
| void *param) |
| { |
| struct pdu_data_llctrl_version_ind *p = param; |
| |
| zassert_equal(pdu->ll_id, PDU_DATA_LLID_CTRL, "Not a Control PDU.\nCalled at %s:%d\n", file, |
| line); |
| zassert_equal(pdu->llctrl.opcode, PDU_DATA_LLCTRL_TYPE_VERSION_IND, |
| "Not a LL_VERSION_IND.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.version_ind.version_number, p->version_number, |
| "Wrong version number.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.version_ind.company_id, p->company_id, |
| "Wrong company id.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.version_ind.sub_version_number, p->sub_version_number, |
| "Wrong sub version number.\nCalled at %s:%d\n", file, line); |
| } |
| |
| void helper_pdu_verify_ping_req(const char *file, uint32_t line, struct pdu_data *pdu, void *param) |
| { |
| zassert_equal(pdu->ll_id, PDU_DATA_LLID_CTRL, "Not a Control PDU.\nCalled at %s:%d\n", file, |
| line); |
| zassert_equal(pdu->llctrl.opcode, PDU_DATA_LLCTRL_TYPE_PING_REQ, |
| "Not a LL_PING_REQ. Called at %s:%d\n", file, line); |
| } |
| |
| void helper_pdu_verify_ping_rsp(const char *file, uint32_t line, struct pdu_data *pdu, void *param) |
| { |
| zassert_equal(pdu->ll_id, PDU_DATA_LLID_CTRL, "Not a Control PDU.\nCalled at %s:%d\n", file, |
| line); |
| zassert_equal(pdu->llctrl.opcode, PDU_DATA_LLCTRL_TYPE_PING_RSP, |
| "Not a LL_PING_RSP.\nCalled at %s:%d\n", file, line); |
| } |
| |
| void helper_pdu_verify_feature_req(const char *file, uint32_t line, struct pdu_data *pdu, |
| void *param) |
| { |
| struct pdu_data_llctrl_feature_req *feature_req = param; |
| |
| zassert_equal(pdu->ll_id, PDU_DATA_LLID_CTRL); |
| zassert_equal(pdu->llctrl.opcode, PDU_DATA_LLCTRL_TYPE_FEATURE_REQ, |
| "Wrong opcode.\nCalled at %s:%d\n", file, line); |
| |
| for (int counter = 0; counter < 8; counter++) { |
| uint8_t expected_value = feature_req->features[counter]; |
| |
| zassert_equal(pdu->llctrl.feature_req.features[counter], expected_value, |
| "Wrong feature exchange data.\nAt %s:%d\n", file, line); |
| } |
| } |
| |
| void helper_pdu_verify_peripheral_feature_req(const char *file, uint32_t line, struct pdu_data *pdu, |
| void *param) |
| { |
| struct pdu_data_llctrl_feature_req *feature_req = param; |
| |
| zassert_equal(pdu->ll_id, PDU_DATA_LLID_CTRL); |
| zassert_equal(pdu->llctrl.opcode, PDU_DATA_LLCTRL_TYPE_PER_INIT_FEAT_XCHG); |
| |
| for (int counter = 0; counter < 8; counter++) { |
| uint8_t expected_value = feature_req->features[counter]; |
| |
| zassert_equal(pdu->llctrl.feature_req.features[counter], expected_value, |
| "Wrong feature data\nCalled at %s:%d\n", file, line); |
| } |
| } |
| |
| void helper_pdu_verify_feature_rsp(const char *file, uint32_t line, struct pdu_data *pdu, |
| void *param) |
| { |
| struct pdu_data_llctrl_feature_rsp *feature_rsp = param; |
| |
| zassert_equal(pdu->ll_id, PDU_DATA_LLID_CTRL); |
| zassert_equal(pdu->llctrl.opcode, PDU_DATA_LLCTRL_TYPE_FEATURE_RSP, |
| "Response: %d Expected: %d\n", pdu->llctrl.opcode, |
| PDU_DATA_LLCTRL_TYPE_FEATURE_RSP); |
| |
| for (int counter = 0; counter < 8; counter++) { |
| uint8_t expected_value = feature_rsp->features[counter]; |
| |
| zassert_equal(pdu->llctrl.feature_rsp.features[counter], expected_value, |
| "Wrong feature data\nCalled at %s:%d\n", file, line); |
| } |
| } |
| |
| void helper_pdu_verify_min_used_chans_ind(const char *file, uint32_t line, struct pdu_data *pdu, |
| void *param) |
| { |
| struct pdu_data_llctrl_min_used_chans_ind *p = param; |
| |
| zassert_equal(pdu->ll_id, PDU_DATA_LLID_CTRL, "Not a Control PDU.\nCalled at %s:%d\n", file, |
| line); |
| zassert_equal(pdu->llctrl.opcode, PDU_DATA_LLCTRL_TYPE_MIN_USED_CHAN_IND, |
| "Not a MIN_USED_CHAN_IND.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.min_used_chans_ind.phys, p->phys, "Wrong PHY.\nCalled at %s:%d\n", |
| file, line); |
| zassert_equal(pdu->llctrl.min_used_chans_ind.min_used_chans, p->min_used_chans, |
| "Channel count\nCalled at %s:%d\n", file, line); |
| } |
| |
| void helper_pdu_verify_enc_req(const char *file, uint32_t line, struct pdu_data *pdu, void *param) |
| { |
| struct pdu_data_llctrl_enc_req *p = param; |
| |
| zassert_equal(pdu->ll_id, PDU_DATA_LLID_CTRL, "Not a Control PDU.\nCalled at %s:%d\n", file, |
| line); |
| zassert_equal(pdu->llctrl.opcode, PDU_DATA_LLCTRL_TYPE_ENC_REQ, |
| "Not a LL_ENC_REQ. Called at %s:%d\n", file, line); |
| |
| PDU_MEM_EQUAL(rand, pdu->llctrl.enc_req, p, "Rand mismatch."); |
| PDU_MEM_EQUAL(ediv, pdu->llctrl.enc_req, p, "EDIV mismatch."); |
| PDU_MEM_EQUAL(skdm, pdu->llctrl.enc_req, p, "SKDm mismatch."); |
| PDU_MEM_EQUAL(ivm, pdu->llctrl.enc_req, p, "IVm mismatch."); |
| } |
| |
| void helper_pdu_ntf_verify_enc_req(const char *file, uint32_t line, struct pdu_data *pdu, |
| void *param) |
| { |
| struct pdu_data_llctrl_enc_req *p = param; |
| |
| zassert_equal(pdu->ll_id, PDU_DATA_LLID_CTRL, "Not a Control PDU.\nCalled at %s:%d\n", file, |
| line); |
| zassert_equal(pdu->llctrl.opcode, PDU_DATA_LLCTRL_TYPE_ENC_REQ, |
| "Not a LL_ENC_REQ. Called at %s:%d\n", file, line); |
| |
| PDU_MEM_EQUAL(rand, pdu->llctrl.enc_req, p, "Rand mismatch."); |
| PDU_MEM_EQUAL(ediv, pdu->llctrl.enc_req, p, "EDIV mismatch."); |
| } |
| |
| void helper_pdu_verify_enc_rsp(const char *file, uint32_t line, struct pdu_data *pdu, void *param) |
| { |
| zassert_equal(pdu->ll_id, PDU_DATA_LLID_CTRL, "Not a Control PDU.\nCalled at %s:%d\n", file, |
| line); |
| zassert_equal(pdu->llctrl.opcode, PDU_DATA_LLCTRL_TYPE_ENC_RSP, |
| "Not a LL_ENC_RSP.\nCalled at %s:%d\n", file, line); |
| } |
| |
| void helper_pdu_verify_start_enc_req(const char *file, uint32_t line, struct pdu_data *pdu, |
| void *param) |
| { |
| zassert_equal(pdu->ll_id, PDU_DATA_LLID_CTRL, "Not a Control PDU.\nCalled at %s:%d\n", file, |
| line); |
| zassert_equal(pdu->llctrl.opcode, PDU_DATA_LLCTRL_TYPE_START_ENC_REQ, |
| "Not a LL_START_ENC_REQ.\nCalled at %s:%d\n", file, line); |
| } |
| |
| void helper_pdu_verify_start_enc_rsp(const char *file, uint32_t line, struct pdu_data *pdu, |
| void *param) |
| { |
| zassert_equal(pdu->ll_id, PDU_DATA_LLID_CTRL, "Not a Control PDU.\nCalled at %s:%d\n", file, |
| line); |
| zassert_equal(pdu->llctrl.opcode, PDU_DATA_LLCTRL_TYPE_START_ENC_RSP, |
| "Not a LL_START_ENC_RSP.\nCalled at %s:%d\n", file, line); |
| } |
| |
| void helper_pdu_verify_pause_enc_req(const char *file, uint32_t line, struct pdu_data *pdu, |
| void *param) |
| { |
| zassert_equal(pdu->ll_id, PDU_DATA_LLID_CTRL, "Not a Control PDU.\nCalled at %s:%d\n", file, |
| line); |
| zassert_equal(pdu->llctrl.opcode, PDU_DATA_LLCTRL_TYPE_PAUSE_ENC_REQ, |
| "Not a LL_PAUSE_ENC_REQ.\nCalled at %s:%d\n", file, line); |
| } |
| |
| void helper_pdu_verify_pause_enc_rsp(const char *file, uint32_t line, struct pdu_data *pdu, |
| void *param) |
| { |
| zassert_equal(pdu->ll_id, PDU_DATA_LLID_CTRL, "Not a Control PDU.\nCalled at %s:%d\n", file, |
| line); |
| zassert_equal(pdu->llctrl.opcode, PDU_DATA_LLCTRL_TYPE_PAUSE_ENC_RSP, |
| "Not a LL_PAUSE_ENC_RSP.\nCalled at %s:%d\n", file, line); |
| } |
| |
| void helper_node_verify_enc_refresh(const char *file, uint32_t line, struct node_rx_pdu *rx, |
| void *param) |
| { |
| zassert_equal(rx->hdr.type, NODE_RX_TYPE_ENC_REFRESH, |
| "Not an ENC_REFRESH node.\nCalled at %s:%d\n", file, line); |
| } |
| |
| void helper_pdu_verify_reject_ind(const char *file, uint32_t line, struct pdu_data *pdu, |
| void *param) |
| { |
| struct pdu_data_llctrl_reject_ind *p = param; |
| |
| zassert_equal(pdu->ll_id, PDU_DATA_LLID_CTRL, "Not a Control PDU.\nCalled at %s:%d\n", file, |
| line); |
| zassert_equal(pdu->len, |
| offsetof(struct pdu_data_llctrl, reject_ind) + |
| sizeof(struct pdu_data_llctrl_reject_ind), |
| "Wrong length.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.opcode, PDU_DATA_LLCTRL_TYPE_REJECT_IND, |
| "Not a LL_REJECT_IND.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.reject_ind.error_code, p->error_code, |
| "Error code mismatch.\nCalled at %s:%d\n", file, line); |
| } |
| |
| void helper_pdu_verify_reject_ext_ind(const char *file, uint32_t line, struct pdu_data *pdu, |
| void *param) |
| { |
| struct pdu_data_llctrl_reject_ext_ind *p = param; |
| |
| zassert_equal(pdu->ll_id, PDU_DATA_LLID_CTRL, "Not a Control PDU.\nCalled at %s:%d\n", file, |
| line); |
| zassert_equal(pdu->len, |
| offsetof(struct pdu_data_llctrl, reject_ext_ind) + |
| sizeof(struct pdu_data_llctrl_reject_ext_ind), |
| "Wrong length.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.opcode, PDU_DATA_LLCTRL_TYPE_REJECT_EXT_IND, |
| "Not a LL_REJECT_EXT_IND.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.reject_ext_ind.reject_opcode, p->reject_opcode, |
| "Reject opcode mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.reject_ext_ind.error_code, p->error_code, |
| "Error code mismatch.\nCalled at %s:%d\n", file, line); |
| } |
| |
| void helper_pdu_verify_phy_req(const char *file, uint32_t line, struct pdu_data *pdu, void *param) |
| { |
| struct pdu_data_llctrl_phy_req *p = param; |
| |
| zassert_equal(pdu->ll_id, PDU_DATA_LLID_CTRL, "Not a Control PDU.\nCalled at %s:%d\n", file, |
| line); |
| zassert_equal(pdu->len, |
| offsetof(struct pdu_data_llctrl, phy_req) + |
| sizeof(struct pdu_data_llctrl_phy_req), |
| "Wrong length.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.opcode, PDU_DATA_LLCTRL_TYPE_PHY_REQ, |
| "Not a LL_PHY_REQ.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.phy_req.rx_phys, p->rx_phys, |
| "rx phys mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.phy_req.tx_phys, p->tx_phys, |
| "tx phys mismatch.\nCalled at %s:%d\n", file, line); |
| } |
| |
| void helper_pdu_verify_phy_rsp(const char *file, uint32_t line, struct pdu_data *pdu, void *param) |
| { |
| struct pdu_data_llctrl_phy_rsp *p = param; |
| |
| zassert_equal(pdu->ll_id, PDU_DATA_LLID_CTRL, "Not a Control PDU.\nCalled at %s:%d\n", file, |
| line); |
| zassert_equal(pdu->len, |
| offsetof(struct pdu_data_llctrl, phy_rsp) + |
| sizeof(struct pdu_data_llctrl_phy_rsp), |
| "Wrong length.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.opcode, PDU_DATA_LLCTRL_TYPE_PHY_RSP, |
| "Not a LL_PHY_RSP.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.phy_rsp.rx_phys, p->rx_phys, |
| "rx phys mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.phy_rsp.tx_phys, p->tx_phys, |
| "tx phys mismatch.\nCalled at %s:%d\n", file, line); |
| } |
| |
| void helper_pdu_verify_phy_update_ind(const char *file, uint32_t line, struct pdu_data *pdu, |
| void *param) |
| { |
| struct pdu_data_llctrl_phy_upd_ind *p = param; |
| |
| zassert_equal(pdu->ll_id, PDU_DATA_LLID_CTRL, "Not a Control PDU.\nCalled at %s:%d\n", file, |
| line); |
| zassert_equal(pdu->len, |
| offsetof(struct pdu_data_llctrl, phy_upd_ind) + |
| sizeof(struct pdu_data_llctrl_phy_upd_ind), |
| "Wrong length.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.opcode, PDU_DATA_LLCTRL_TYPE_PHY_UPD_IND, |
| "Not a LL_PHY_UPDATE_IND.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.phy_upd_ind.instant, p->instant, |
| "instant mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.phy_upd_ind.c_to_p_phy, p->c_to_p_phy, |
| "c_to_p_phy mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.phy_upd_ind.p_to_c_phy, p->p_to_c_phy, |
| "p_to_c_phy mismatch.\nCalled at %s:%d\n", file, line); |
| } |
| |
| void helper_node_verify_phy_update(const char *file, uint32_t line, struct node_rx_pdu *rx, |
| void *param) |
| { |
| struct node_rx_pu *pdu = (struct node_rx_pu *)rx->pdu; |
| struct node_rx_pu *p = param; |
| |
| zassert_equal(rx->hdr.type, NODE_RX_TYPE_PHY_UPDATE, |
| "Not a PHY_UPDATE node.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->status, p->status, "Status mismatch.\nCalled at %s:%d\n", file, line); |
| } |
| |
| void helper_node_verify_peer_sca_update(const char *file, uint32_t line, struct node_rx_pdu *rx, |
| void *param) |
| { |
| struct node_rx_sca *pdu = (struct node_rx_sca *)rx->pdu; |
| struct node_rx_sca *p = param; |
| |
| zassert_equal(rx->hdr.type, NODE_RX_TYPE_REQ_PEER_SCA_COMPLETE, |
| "Not an SCA node.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->status, p->status, "Status mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->sca, p->sca, "SCA mismatch.\nCalled at %s:%d\n", file, line); |
| } |
| |
| void helper_pdu_verify_unknown_rsp(const char *file, uint32_t line, struct pdu_data *pdu, |
| void *param) |
| { |
| struct pdu_data_llctrl_unknown_rsp *p = param; |
| |
| zassert_equal(pdu->ll_id, PDU_DATA_LLID_CTRL, "Not a Control PDU.\nCalled at %s:%d\n", file, |
| line); |
| zassert_equal(pdu->len, |
| offsetof(struct pdu_data_llctrl, unknown_rsp) + |
| sizeof(struct pdu_data_llctrl_unknown_rsp), |
| "Wrong length.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.opcode, PDU_DATA_LLCTRL_TYPE_UNKNOWN_RSP, |
| "Not a LL_UNKNOWN_RSP.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.unknown_rsp.type, p->type, "Type mismatch.\nCalled at %s:%d\n", |
| file, line); |
| } |
| |
| void helper_pdu_verify_conn_param_req(const char *file, uint32_t line, struct pdu_data *pdu, |
| void *param) |
| { |
| struct pdu_data_llctrl_conn_param_req *p = param; |
| |
| zassert_equal(pdu->ll_id, PDU_DATA_LLID_CTRL, "Not a Control PDU.\nCalled at %s:%d\n", file, |
| line); |
| zassert_equal(pdu->len, |
| offsetof(struct pdu_data_llctrl, conn_param_req) + |
| sizeof(struct pdu_data_llctrl_conn_param_req), |
| "Wrong length.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.opcode, PDU_DATA_LLCTRL_TYPE_CONN_PARAM_REQ, |
| "Not a LL_CONNECTION_PARAM_REQ.\nCalled at %s:%d\n", file, line); |
| |
| zassert_equal(pdu->llctrl.conn_param_req.interval_min, p->interval_min, |
| "Interval_min mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.conn_param_req.interval_max, p->interval_max, |
| "Interval_max mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.conn_param_req.latency, p->latency, |
| "Latency mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.conn_param_req.timeout, p->timeout, |
| "Timeout mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.conn_param_req.preferred_periodicity, p->preferred_periodicity, |
| "Preferred_periodicity mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.conn_param_req.reference_conn_event_count, |
| p->reference_conn_event_count, |
| "Reference_conn_event_count mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.conn_param_req.offset0, p->offset0, |
| "Offset0 mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.conn_param_req.offset1, p->offset1, |
| "Offset1 mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.conn_param_req.offset2, p->offset2, |
| "Offset2 mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.conn_param_req.offset3, p->offset3, |
| "Offset3 mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.conn_param_req.offset4, p->offset4, |
| "Offset4 mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.conn_param_req.offset5, p->offset5, |
| "Offset5 mismatch.\nCalled at %s:%d\n", file, line); |
| } |
| |
| void helper_pdu_verify_conn_param_rsp(const char *file, uint32_t line, struct pdu_data *pdu, |
| void *param) |
| { |
| struct pdu_data_llctrl_conn_param_rsp *p = param; |
| |
| zassert_equal(pdu->ll_id, PDU_DATA_LLID_CTRL, "Not a Control PDU.\nCalled at %s:%d\n", file, |
| line); |
| zassert_equal(pdu->len, |
| offsetof(struct pdu_data_llctrl, conn_param_rsp) + |
| sizeof(struct pdu_data_llctrl_conn_param_rsp), |
| "Wrong length.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.opcode, PDU_DATA_LLCTRL_TYPE_CONN_PARAM_RSP, |
| "Not a LL_CONNECTION_PARAM_RSP.\nCalled at %s:%d\n", file, line); |
| |
| zassert_equal(pdu->llctrl.conn_param_rsp.interval_min, p->interval_min, |
| "Interval_min mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.conn_param_rsp.interval_max, p->interval_max, |
| "Interval_max mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.conn_param_rsp.latency, p->latency, |
| "Latency mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.conn_param_rsp.timeout, p->timeout, |
| "Timeout mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.conn_param_rsp.preferred_periodicity, p->preferred_periodicity, |
| "Preferred_periodicity mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.conn_param_rsp.reference_conn_event_count, |
| p->reference_conn_event_count, |
| "Reference_conn_event_count mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.conn_param_rsp.offset0, p->offset0, |
| "Offset0 mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.conn_param_rsp.offset1, p->offset1, |
| "Offset1 mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.conn_param_rsp.offset2, p->offset2, |
| "Offset2 mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.conn_param_rsp.offset3, p->offset3, |
| "Offset3 mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.conn_param_rsp.offset4, p->offset4, |
| "Offset4 mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.conn_param_rsp.offset5, p->offset5, |
| "Offset5 mismatch.\nCalled at %s:%d\n", file, line); |
| } |
| |
| void helper_pdu_verify_conn_update_ind(const char *file, uint32_t line, struct pdu_data *pdu, |
| void *param) |
| { |
| struct pdu_data_llctrl_conn_update_ind *p = param; |
| |
| zassert_equal(pdu->ll_id, PDU_DATA_LLID_CTRL, "Not a Control PDU.\nCalled at %s:%d\n", file, |
| line); |
| zassert_equal(pdu->len, |
| offsetof(struct pdu_data_llctrl, conn_update_ind) + |
| sizeof(struct pdu_data_llctrl_conn_update_ind), |
| "Wrong length.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.opcode, PDU_DATA_LLCTRL_TYPE_CONN_UPDATE_IND, |
| "Not a LL_CONNECTION_UPDATE_IND.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.conn_update_ind.win_size, p->win_size, |
| "Win_size mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.conn_update_ind.win_offset, p->win_offset, |
| "Win_offset mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.conn_update_ind.latency, p->latency, |
| "Latency.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.conn_update_ind.interval, p->interval, |
| "Interval mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.conn_update_ind.timeout, p->timeout, |
| "Timeout mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.conn_update_ind.instant, p->instant, |
| "Instant mismatch.\nCalled at %s:%d\n", file, line); |
| } |
| |
| void helper_node_verify_conn_update(const char *file, uint32_t line, struct node_rx_pdu *rx, |
| void *param) |
| { |
| struct node_rx_pu *pdu = (struct node_rx_pu *)rx->pdu; |
| struct node_rx_pu *p = param; |
| |
| zassert_equal(rx->hdr.type, NODE_RX_TYPE_CONN_UPDATE, |
| "Not a CONN_UPDATE node.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->status, p->status, "Status mismatch.\nCalled at %s:%d\n", file, line); |
| } |
| |
| void helper_pdu_verify_terminate_ind(const char *file, uint32_t line, struct pdu_data *pdu, |
| void *param) |
| { |
| struct pdu_data_llctrl_terminate_ind *p = param; |
| |
| zassert_equal(pdu->ll_id, PDU_DATA_LLID_CTRL, "Not a Control PDU.\nCalled at %s:%d\n", file, |
| line); |
| zassert_equal(pdu->len, |
| offsetof(struct pdu_data_llctrl, terminate_ind) + |
| sizeof(struct pdu_data_llctrl_terminate_ind), |
| "Wrong length.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.opcode, PDU_DATA_LLCTRL_TYPE_TERMINATE_IND, |
| "Not a LL_TERMINATE_IND.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.terminate_ind.error_code, p->error_code, |
| "Error code mismatch.\nCalled at %s:%d\n", file, line); |
| } |
| |
| void helper_pdu_verify_channel_map_update_ind(const char *file, uint32_t line, struct pdu_data *pdu, |
| void *param) |
| { |
| struct pdu_data_llctrl_chan_map_ind *p = param; |
| |
| zassert_equal(pdu->ll_id, PDU_DATA_LLID_CTRL, "Not a Control PDU.\nCalled at %s:%d\n", file, |
| line); |
| zassert_equal(pdu->llctrl.opcode, PDU_DATA_LLCTRL_TYPE_CHAN_MAP_IND, |
| "Not a LL_CHANNEL_MAP_UPDATE_IND.\nCalled at %s:%d ( %d %d)\n", file, line, |
| pdu->llctrl.opcode, PDU_DATA_LLCTRL_TYPE_CHAN_MAP_IND); |
| zassert_equal(pdu->len, |
| offsetof(struct pdu_data_llctrl, chan_map_ind) + |
| sizeof(struct pdu_data_llctrl_chan_map_ind), |
| "Wrong length.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.chan_map_ind.instant, p->instant, |
| "Instant mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_mem_equal(pdu->llctrl.chan_map_ind.chm, p->chm, sizeof(p->chm), |
| "Channel Map mismatch.\nCalled at %s:%d\n", file, line); |
| } |
| |
| void helper_pdu_verify_length_req(const char *file, uint32_t line, struct pdu_data *pdu, |
| void *param) |
| { |
| struct pdu_data_llctrl_length_req *p = param; |
| |
| zassert_equal(pdu->ll_id, PDU_DATA_LLID_CTRL, "Not a Control PDU.\nCalled at %s:%d\n", file, |
| line); |
| zassert_equal(pdu->len, |
| offsetof(struct pdu_data_llctrl, length_req) + |
| sizeof(struct pdu_data_llctrl_length_req), |
| "Wrong length.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.opcode, PDU_DATA_LLCTRL_TYPE_LENGTH_REQ, |
| "Not a LL_LENGTH_REQ.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.length_req.max_rx_octets, p->max_rx_octets, |
| "max_rx_octets mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.length_req.max_tx_octets, p->max_tx_octets, |
| "max_tx_octets mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.length_req.max_rx_time, p->max_rx_time, |
| "max_rx_time mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.length_req.max_tx_time, p->max_tx_time, |
| "max_tx_time mismatch.\nCalled at %s:%d\n", file, line); |
| } |
| |
| void helper_pdu_verify_length_rsp(const char *file, uint32_t line, struct pdu_data *pdu, |
| void *param) |
| { |
| struct pdu_data_llctrl_length_rsp *p = param; |
| |
| zassert_equal(pdu->ll_id, PDU_DATA_LLID_CTRL, "Not a Control PDU.\nCalled at %s:%d\n", file, |
| line); |
| zassert_equal(pdu->len, |
| offsetof(struct pdu_data_llctrl, length_rsp) + |
| sizeof(struct pdu_data_llctrl_length_rsp), |
| "Wrong length.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.opcode, PDU_DATA_LLCTRL_TYPE_LENGTH_RSP, |
| "Not a LL_LENGTH_RSP.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.length_rsp.max_rx_octets, p->max_rx_octets, |
| "max_rx_octets mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.length_rsp.max_tx_octets, p->max_tx_octets, |
| "max_tx_octets mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.length_rsp.max_rx_time, p->max_rx_time, |
| "max_rx_time mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.length_rsp.max_tx_time, p->max_tx_time, |
| "max_tx_time mismatch.\nCalled at %s:%d\n", file, line); |
| } |
| |
| void helper_pdu_verify_cte_req(const char *file, uint32_t line, struct pdu_data *pdu, void *param) |
| { |
| struct pdu_data_llctrl_cte_req *p = param; |
| |
| zassert_equal(pdu->ll_id, PDU_DATA_LLID_CTRL, "Not a Control PDU.\nCalled at %s:%d\n", file, |
| line); |
| zassert_equal(pdu->llctrl.opcode, PDU_DATA_LLCTRL_TYPE_CTE_REQ, |
| "Not a LL_CTE_REQ.\nCalled at %s:%d ( %d %d)\n", file, line, |
| pdu->llctrl.opcode, PDU_DATA_LLCTRL_TYPE_CTE_REQ); |
| zassert_equal(pdu->len, |
| offsetof(struct pdu_data_llctrl, cte_req) + |
| sizeof(struct pdu_data_llctrl_cte_req), |
| "Wrong length.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.cte_req.min_cte_len_req, p->min_cte_len_req, |
| "Minimal CTE length request mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.cte_req.cte_type_req, p->cte_type_req, |
| "CTE type request mismatch.\nCalled at %s:%d\n", file, line); |
| } |
| |
| void helper_pdu_verify_cte_rsp(const char *file, uint32_t line, struct pdu_data *pdu, void *param) |
| { |
| zassert_equal(pdu->ll_id, PDU_DATA_LLID_CTRL, "Not a Control PDU.\nCalled at %s:%d\n", file, |
| line); |
| zassert_equal(pdu->len, |
| offsetof(struct pdu_data_llctrl, cte_rsp) + |
| sizeof(struct pdu_data_llctrl_cte_rsp), |
| "Wrong length.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.opcode, PDU_DATA_LLCTRL_TYPE_CTE_RSP, |
| "Not a LL_CTE_RSP.\nCalled at %s:%d\n", file, line); |
| } |
| |
| void helper_node_verify_cte_rsp(const char *file, uint32_t line, struct node_rx_pdu *rx, |
| void *param) |
| { |
| struct cte_conn_iq_report *p_iq_report = param; |
| struct cte_conn_iq_report *rx_iq_report = rx->hdr.rx_ftr.iq_report; |
| |
| zassert_equal(rx_iq_report->cte_info.time, p_iq_report->cte_info.time, |
| "CTE Time mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(rx_iq_report->local_slot_durations, p_iq_report->local_slot_durations, |
| "Slot duration mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(rx_iq_report->packet_status, p_iq_report->packet_status, |
| "Packet status mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(rx_iq_report->rssi_ant_id, p_iq_report->rssi_ant_id, |
| "RSSI antenna id mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(rx_iq_report->sample_count, p_iq_report->sample_count, |
| "Sample count mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(memcmp(rx_iq_report->sample, p_iq_report->sample, p_iq_report->sample_count), |
| 0, "IQ samples mismatch.\nCalled at %s:%d\n", file, line); |
| } |
| |
| void helper_pdu_ntf_verify_cte_rsp(const char *file, uint32_t line, struct pdu_data *pdu, |
| void *param) |
| { |
| zassert_equal(pdu->ll_id, PDU_DATA_LLID_CTRL, "Not a Control PDU.\nCalled at %s:%d\n", file, |
| line); |
| zassert_equal(pdu->llctrl.opcode, PDU_DATA_LLCTRL_TYPE_CTE_RSP, |
| "Not a LL_CTE_RSP. Called at %s:%d\n", file, line); |
| } |
| |
| void helper_node_verify_cis_request(const char *file, uint32_t line, struct node_rx_pdu *rx, |
| void *param) |
| { |
| struct node_rx_conn_iso_req *p = (struct node_rx_conn_iso_req *)param; |
| struct node_rx_conn_iso_req *pdu = (struct node_rx_conn_iso_req *)rx->pdu; |
| |
| zassert_equal(rx->hdr.type, NODE_RX_TYPE_CIS_REQUEST, |
| "Not a CIS_REQUEST node.\nCalled at %s:%d\n", file, line); |
| zassert_equal(p->cig_id, pdu->cig_id, |
| "cig_id mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(p->cis_handle, pdu->cis_handle, |
| "cis_handle mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(p->cis_id, pdu->cis_id, |
| "cis_id mismatch.\nCalled at %s:%d\n", file, line); |
| } |
| |
| void helper_node_verify_cis_established(const char *file, uint32_t line, struct node_rx_pdu *rx, |
| void *param) |
| { |
| struct node_rx_conn_iso_estab *p = (struct node_rx_conn_iso_estab *)param; |
| struct node_rx_conn_iso_estab *pdu = (struct node_rx_conn_iso_estab *)rx->pdu; |
| |
| zassert_equal(rx->hdr.type, NODE_RX_TYPE_CIS_ESTABLISHED, |
| "Not a CIS_ESTABLISHED node.\nCalled at %s:%d\n", file, line); |
| zassert_equal(p->status, pdu->status, |
| "status mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(p->cis_handle, pdu->cis_handle, |
| "cis_handle mismatch.\nCalled at %s:%d\n", file, line); |
| } |
| |
| void helper_pdu_verify_cis_req(const char *file, uint32_t line, struct pdu_data *pdu, void *param) |
| { |
| struct pdu_data_llctrl_cis_req *p = param; |
| |
| pdu->ll_id = PDU_DATA_LLID_CTRL; |
| pdu->len = offsetof(struct pdu_data_llctrl, cis_req) + |
| sizeof(struct pdu_data_llctrl_cis_req); |
| pdu->llctrl.opcode = PDU_DATA_LLCTRL_TYPE_CIS_REQ; |
| |
| zassert_equal(pdu->llctrl.cis_req.cig_id, p->cig_id, |
| "cig_id mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.cis_req.cis_id, p->cis_id, |
| "cis_id mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.cis_req.c_phy, p->c_phy, |
| "c_phy mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.cis_req.p_phy, p->p_phy, |
| "p_phy mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.cis_req.c_max_pdu, p->c_max_pdu, |
| "c_max_pdu mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.cis_req.p_max_pdu, p->p_max_pdu, |
| "p_max_pdu mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.cis_req.nse, p->nse, |
| "nse mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.cis_req.p_bn, p->p_bn, |
| "p_bn mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.cis_req.c_bn, p->c_bn, |
| "c_bn mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.cis_req.c_ft, p->c_ft, |
| "c_ft mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.cis_req.p_ft, p->p_ft, |
| "p_ft mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.cis_req.iso_interval, p->iso_interval, |
| "iso_interval mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.cis_req.conn_event_count, p->conn_event_count, |
| "conn_event_count mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_mem_equal(pdu->llctrl.cis_req.c_max_sdu_packed, p->c_max_sdu_packed, |
| sizeof(p->c_max_sdu_packed), |
| "c_max_sdu_packed mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_mem_equal(pdu->llctrl.cis_req.p_max_sdu, p->p_max_sdu, |
| sizeof(p->p_max_sdu), |
| "p_max_sdu mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_mem_equal(pdu->llctrl.cis_req.c_sdu_interval, p->c_sdu_interval, |
| sizeof(p->c_sdu_interval), |
| "c_sdu_interval mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_mem_equal(pdu->llctrl.cis_req.p_sdu_interval, p->p_sdu_interval, |
| sizeof(p->p_sdu_interval), |
| "p_sdu_interval mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_mem_equal(pdu->llctrl.cis_req.sub_interval, p->sub_interval, |
| sizeof(p->sub_interval), |
| "sub_interval mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_mem_equal(pdu->llctrl.cis_req.cis_offset_min, p->cis_offset_min, |
| sizeof(p->cis_offset_min), |
| "cis_offset_min mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_mem_equal(pdu->llctrl.cis_req.cis_offset_max, p->cis_offset_max, |
| sizeof(p->cis_offset_max), |
| "cis_offset_max mismatch.\nCalled at %s:%d\n", file, line); |
| } |
| |
| void helper_pdu_verify_cis_rsp(const char *file, uint32_t line, struct pdu_data *pdu, void *param) |
| { |
| struct pdu_data_llctrl_cis_rsp *p = param; |
| |
| zassert_equal(pdu->ll_id, PDU_DATA_LLID_CTRL, "Not a Control PDU.\nCalled at %s:%d\n", file, |
| line); |
| zassert_equal(pdu->len, |
| offsetof(struct pdu_data_llctrl, cis_rsp) + |
| sizeof(struct pdu_data_llctrl_cis_rsp), |
| "Wrong length.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.opcode, PDU_DATA_LLCTRL_TYPE_CIS_RSP, |
| "Not a LL_CIS_RSP.\nCalled at %s:%d\n", file, line); |
| |
| zassert_mem_equal(pdu->llctrl.cis_rsp.cis_offset_min, p->cis_offset_min, |
| sizeof(p->cis_offset_min), |
| "cis_offset_min mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_mem_equal(pdu->llctrl.cis_rsp.cis_offset_max, p->cis_offset_max, |
| sizeof(p->cis_offset_max), |
| "cis_offset_max mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.cis_rsp.conn_event_count, p->conn_event_count, |
| "conn_event_count mismatch.\nCalled at %s:%d\n", file, line); |
| } |
| |
| void helper_pdu_verify_cis_ind(const char *file, uint32_t line, struct pdu_data *pdu, void *param) |
| { |
| struct pdu_data_llctrl_cis_ind *p = param; |
| |
| zassert_equal(pdu->ll_id, PDU_DATA_LLID_CTRL, "Not a Control PDU.\nCalled at %s:%d\n", file, |
| line); |
| zassert_equal(pdu->len, |
| offsetof(struct pdu_data_llctrl, cis_ind) + |
| sizeof(struct pdu_data_llctrl_cis_ind), |
| "Wrong length.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.opcode, PDU_DATA_LLCTRL_TYPE_CIS_IND, |
| "Not a LL_CIS_IND.\nCalled at %s:%d\n", file, line); |
| |
| zassert_mem_equal(pdu->llctrl.cis_ind.aa, p->aa, sizeof(p->aa), |
| "aa mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_mem_equal(pdu->llctrl.cis_ind.cis_offset, p->cis_offset, sizeof(p->cis_offset), |
| "cis_offset mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_mem_equal(pdu->llctrl.cis_ind.cig_sync_delay, p->cig_sync_delay, |
| sizeof(p->cig_sync_delay), |
| "cig_sync_delay mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_mem_equal(pdu->llctrl.cis_ind.cis_sync_delay, p->cis_sync_delay, |
| sizeof(p->cis_sync_delay), |
| "cis_sync_delay mismatch.\nCalled at %s:%d\n", file, line); |
| |
| pdu->llctrl.cis_ind.conn_event_count = p->conn_event_count; |
| } |
| |
| void helper_pdu_verify_cis_terminate_ind(const char *file, uint32_t line, struct pdu_data *pdu, |
| void *param) |
| { |
| struct pdu_data_llctrl_cis_terminate_ind *p = param; |
| |
| zassert_equal(pdu->ll_id, PDU_DATA_LLID_CTRL, "Not a Control PDU.\nCalled at %s:%d\n", file, |
| line); |
| zassert_equal(pdu->len, |
| offsetof(struct pdu_data_llctrl, cis_terminate_ind) + |
| sizeof(struct pdu_data_llctrl_cis_terminate_ind), |
| "Wrong length.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.opcode, PDU_DATA_LLCTRL_TYPE_CIS_TERMINATE_IND, |
| "Not a LL_CIS_TERMINATE_IND.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.cis_terminate_ind.cig_id, p->cig_id, |
| "CIG ID mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.cis_terminate_ind.cis_id, p->cis_id, |
| "CIS ID mismatch.\nCalled at %s:%d\n", file, line); |
| zassert_equal(pdu->llctrl.cis_terminate_ind.error_code, p->error_code, |
| "Error code mismatch.\nCalled at %s:%d\n", file, line); |
| } |
| |
| void helper_pdu_verify_sca_req(const char *file, uint32_t line, struct pdu_data *pdu, void *param) |
| { |
| zassert_equal(pdu->ll_id, PDU_DATA_LLID_CTRL, "Not a Control PDU.\nCalled at %s:%d\n", file, |
| line); |
| zassert_equal(pdu->llctrl.opcode, PDU_DATA_LLCTRL_TYPE_CLOCK_ACCURACY_REQ, |
| "Not a LL_CLOCK_ACCURACY_REQ. Called at %s:%d\n", file, line); |
| } |
| |
| void helper_pdu_verify_sca_rsp(const char *file, uint32_t line, struct pdu_data *pdu, void *param) |
| { |
| zassert_equal(pdu->ll_id, PDU_DATA_LLID_CTRL, "Not a Control PDU.\nCalled at %s:%d\n", file, |
| line); |
| zassert_equal(pdu->llctrl.opcode, PDU_DATA_LLCTRL_TYPE_CLOCK_ACCURACY_RSP, |
| "Not a LL_CLOCK_ACCURACY_RSP.\nCalled at %s:%d\n", file, line); |
| } |