michaelh/zephyr
1
0
Fork 0
Code Releases Activity

Bluetooth: Controller: Version 5.0 and PDU type rename

Browse source 
Report as Bluetooth 5.0 compliant controller as there are
no mandatory features.

Rename PDU types as per the changes in Bluetooth 5.0
Specification.

Change-id: I1363e054eafd37c2bdca0f69b2638c7edb785787
Signed-off-by: Vinayak Chettimada <vinayak.kariappa.chettimada@nordicsemi.no>
This commit is contained in:
Vinayak Chettimada 2017-03-09 22:54:02 +01:00 • committed by Johan Hedberg
commit e3d00bf338
4 changed files with 144 additions and 116 deletions
Download patch file Download diff file Expand all files Collapse all files

171
subsys/bluetooth/controller/ll/ctrl.c
View file

@ -610,8 +610,8 @@ static inline uint32_t isr_rx_adv(uint8_t devmatch_ok, uint8_t irkmatch_ok,
data[_radio.advertiser.scan_data.first][0]);
return 0;
} else if ((pdu_adv->type == PDU_ADV_TYPE_CONNECT_REQ) &&
(pdu_adv->len == sizeof(struct pdu_adv_payload_connect_req)) &&
} else if ((pdu_adv->type == PDU_ADV_TYPE_CONNECT_IND) &&
(pdu_adv->len == sizeof(struct pdu_adv_payload_connect_ind)) &&
(((_radio.advertiser.filter_policy & 0x02) == 0) ||
(devmatch_ok) || (irkmatch_ok)) &&
(1 /** @todo own addr match check */) &&
@ -640,29 +640,29 @@ static inline uint32_t isr_rx_adv(uint8_t devmatch_ok, uint8_t irkmatch_ok,
conn->handle = mem_index_get(conn, _radio.conn_pool,
CONNECTION_T_SIZE);
memcpy(&conn->crc_init[0],
&pdu_adv->payload.connect_req.lldata.crc_init[0],
&pdu_adv->payload.connect_ind.lldata.crc_init[0],
3);
memcpy(&conn->access_addr[0],
&pdu_adv->payload.connect_req.lldata.access_addr[0],
&pdu_adv->payload.connect_ind.lldata.access_addr[0],
4);
memcpy(&conn->data_channel_map[0],
&pdu_adv->payload.connect_req.lldata.channel_map[0],
&pdu_adv->payload.connect_ind.lldata.channel_map[0],
sizeof(conn->data_channel_map));
conn->data_channel_count =
util_ones_count_get(&conn->data_channel_map[0],
sizeof(conn->data_channel_map));
conn->data_channel_hop =
pdu_adv->payload.connect_req.lldata.hop;
pdu_adv->payload.connect_ind.lldata.hop;
conn->conn_interval =
pdu_adv->payload.connect_req.lldata.interval;
pdu_adv->payload.connect_ind.lldata.interval;
conn_interval_us =
pdu_adv->payload.connect_req.lldata.interval * 1250;
pdu_adv->payload.connect_ind.lldata.interval * 1250;
conn->latency =
pdu_adv->payload.connect_req.lldata.latency;
pdu_adv->payload.connect_ind.lldata.latency;
memcpy((void *)&conn->role.slave.force, &conn->access_addr[0],
sizeof(conn->role.slave.force));
conn->supervision_reload =
RADIO_CONN_EVENTS((pdu_adv->payload.connect_req.lldata.timeout
RADIO_CONN_EVENTS((pdu_adv->payload.connect_ind.lldata.timeout
* 10 * 1000), conn_interval_us);
conn->procedure_reload = RADIO_CONN_EVENTS((40 * 1000 * 1000),
conn_interval_us);
@ -692,27 +692,27 @@ static inline uint32_t isr_rx_adv(uint8_t devmatch_ok, uint8_t irkmatch_ok,
radio_le_conn_cmplt->role = 0x01;
radio_le_conn_cmplt->peer_addr_type = pdu_adv->tx_addr;
memcpy(&radio_le_conn_cmplt->peer_addr[0],
&pdu_adv->payload.connect_req.init_addr[0],
&pdu_adv->payload.connect_ind.init_addr[0],
BDADDR_SIZE);
radio_le_conn_cmplt->own_addr_type = pdu_adv->rx_addr;
memcpy(&radio_le_conn_cmplt->own_addr[0],
&pdu_adv->payload.connect_req.adv_addr[0], BDADDR_SIZE);
&pdu_adv->payload.connect_ind.adv_addr[0], BDADDR_SIZE);
radio_le_conn_cmplt->peer_irk_index = irkmatch_id;
radio_le_conn_cmplt->interval =
pdu_adv->payload.connect_req.lldata.interval;
pdu_adv->payload.connect_ind.lldata.interval;
radio_le_conn_cmplt->latency =
pdu_adv->payload.connect_req.lldata.latency;
pdu_adv->payload.connect_ind.lldata.latency;
radio_le_conn_cmplt->timeout =
pdu_adv->payload.connect_req.lldata.timeout;
pdu_adv->payload.connect_ind.lldata.timeout;
radio_le_conn_cmplt->mca =
pdu_adv->payload.connect_req.lldata.sca;
pdu_adv->payload.connect_ind.lldata.sca;
/* enqueue connection complete structure into queue */
rx_fc_lock(conn->handle);
packet_rx_enqueue();
/* calculate the window widening */
conn->role.slave.sca = pdu_adv->payload.connect_req.lldata.sca;
conn->role.slave.sca = pdu_adv->payload.connect_ind.lldata.sca;
conn->role.slave.window_widening_periodic_us =
(((gc_lookup_ppm[_radio.sca] +
gc_lookup_ppm[conn->role.slave.sca]) *
@ -720,7 +720,7 @@ static inline uint32_t isr_rx_adv(uint8_t devmatch_ok, uint8_t irkmatch_ok,
conn->role.slave.window_widening_max_us =
(conn_interval_us >> 1) - 150;
conn->role.slave.window_size_event_us =
pdu_adv->payload.connect_req.lldata.win_size * 1250;
pdu_adv->payload.connect_ind.lldata.win_size * 1250;
conn->role.slave.window_size_prepare_us = 0;
/* calculate slave slot */
@ -769,7 +769,7 @@ static inline uint32_t isr_rx_adv(uint8_t devmatch_ok, uint8_t irkmatch_ok,
+ conn->handle, (_radio.ticks_anchor - ticks_slot_offset),
TICKER_US_TO_TICKS(radio_tmr_end_get() -
RADIO_TX_CHAIN_DELAY_US + (((uint64_t) pdu_adv->
payload.connect_req.lldata.win_offset + 1) * 1250) -
payload.connect_ind.lldata.win_offset + 1) * 1250) -
RADIO_RX_READY_DELAY_US - (RADIO_TICKER_JITTER_US << 1)),
TICKER_US_TO_TICKS(conn_interval_us),
TICKER_REMAINDER(conn_interval_us), TICKER_NULL_LAZY,
@ -812,14 +812,15 @@ static inline uint32_t isr_rx_obs(uint8_t irkmatch_id, uint8_t rssi_ready)
(/* allow directed adv packets addressed to this device */
((_radio.observer.init_addr_type == pdu_adv_rx->rx_addr) &&
(memcmp(&_radio.observer.init_addr[0],
&pdu_adv_rx->payload.direct_ind.init_addr[0],
&pdu_adv_rx->payload.direct_ind.tgt_addr[0],
BDADDR_SIZE) == 0)) ||
/* allow directed adv packets where initiator address
* is resolvable private address
*/
(((_radio.observer.filter_policy & 0x02) != 0) &&
(pdu_adv_rx->rx_addr != 0) &&
((pdu_adv_rx->payload.direct_ind.init_addr[5] & 0xc0) == 0x40))))) &&
((pdu_adv_rx->payload.direct_ind.tgt_addr[5] & 0xc0) ==
0x40))))) &&
((radio_tmr_end_get() + 502) <
TICKER_TICKS_TO_US(_radio.observer.hdr.ticks_slot))) {
struct connection *conn;
@ -840,19 +841,19 @@ static inline uint32_t isr_rx_obs(uint8_t irkmatch_id, uint8_t rssi_ready)
/* Tx the connect request packet */
pdu_adv_tx = (struct pdu_adv *)radio_pkt_scratch_get();
pdu_adv_tx->type = PDU_ADV_TYPE_CONNECT_REQ;
pdu_adv_tx->type = PDU_ADV_TYPE_CONNECT_IND;
pdu_adv_tx->tx_addr = _radio.observer.init_addr_type;
pdu_adv_tx->rx_addr = pdu_adv_rx->tx_addr;
pdu_adv_tx->len = sizeof(struct pdu_adv_payload_connect_req);
memcpy(&pdu_adv_tx->payload.connect_req.init_addr[0],
pdu_adv_tx->len = sizeof(struct pdu_adv_payload_connect_ind);
memcpy(&pdu_adv_tx->payload.connect_ind.init_addr[0],
&_radio.observer.init_addr[0], BDADDR_SIZE);
memcpy(&pdu_adv_tx->payload.connect_req.adv_addr[0],
memcpy(&pdu_adv_tx->payload.connect_ind.adv_addr[0],
&pdu_adv_rx->payload.adv_ind.addr[0], BDADDR_SIZE);
memcpy(&pdu_adv_tx->payload.connect_req.lldata.
memcpy(&pdu_adv_tx->payload.connect_ind.lldata.
access_addr[0], &conn->access_addr[0], 4);
memcpy(&pdu_adv_tx->payload.connect_req.lldata.crc_init[0],
memcpy(&pdu_adv_tx->payload.connect_ind.lldata.crc_init[0],
&conn->crc_init[0], 3);
pdu_adv_tx->payload.connect_req.lldata. win_size = 1;
pdu_adv_tx->payload.connect_ind.lldata. win_size = 1;
conn_interval_us =
(uint32_t)_radio.observer.conn_interval * 1250;
@ -860,7 +861,7 @@ static inline uint32_t isr_rx_obs(uint8_t irkmatch_id, uint8_t rssi_ready)
conn_space_us = radio_tmr_end_get() -
RADIO_TX_CHAIN_DELAY_US + 502 + 1250 -
RADIO_TX_READY_DELAY_US;
pdu_adv_tx->payload.connect_req.lldata.win_offset = 0;
pdu_adv_tx->payload.connect_ind.lldata.win_offset = 0;
} else {
conn_space_us = _radio.observer. win_offset_us;
while ((conn_space_us & ((uint32_t)1 << 31)) ||
@ -870,24 +871,24 @@ static inline uint32_t isr_rx_obs(uint8_t irkmatch_id, uint8_t rssi_ready)
RADIO_TX_READY_DELAY_US))) {
conn_space_us += conn_interval_us;
}
pdu_adv_tx->payload.connect_req.lldata. win_offset =
pdu_adv_tx->payload.connect_ind.lldata. win_offset =
(conn_space_us - radio_tmr_end_get() +
RADIO_TX_CHAIN_DELAY_US - 502 - 1250 +
RADIO_TX_READY_DELAY_US) / 1250;
}
pdu_adv_tx->payload.connect_req.lldata.interval =
pdu_adv_tx->payload.connect_ind.lldata.interval =
_radio.observer.conn_interval;
pdu_adv_tx->payload.connect_req.lldata.latency =
pdu_adv_tx->payload.connect_ind.lldata.latency =
_radio.observer.conn_latency;
pdu_adv_tx->payload.connect_req.lldata.timeout =
pdu_adv_tx->payload.connect_ind.lldata.timeout =
_radio.observer.conn_timeout;
memcpy(&pdu_adv_tx->payload.connect_req.lldata.channel_map[0],
memcpy(&pdu_adv_tx->payload.connect_ind.lldata.channel_map[0],
&conn->data_channel_map[0],
sizeof(pdu_adv_tx->payload.connect_req.lldata.channel_map));
pdu_adv_tx->payload.connect_req.lldata.hop =
sizeof(pdu_adv_tx->payload.connect_ind.lldata.channel_map));
pdu_adv_tx->payload.connect_ind.lldata.hop =
conn->data_channel_hop;
pdu_adv_tx->payload.connect_req.lldata.sca = _radio.sca;
pdu_adv_tx->payload.connect_ind.lldata.sca = _radio.sca;
radio_switch_complete_and_disable();
@ -921,18 +922,18 @@ static inline uint32_t isr_rx_obs(uint8_t irkmatch_id, uint8_t rssi_ready)
radio_le_conn_cmplt->role = 0x00;
radio_le_conn_cmplt->peer_addr_type = pdu_adv_tx->rx_addr;
memcpy(&radio_le_conn_cmplt->peer_addr[0],
&pdu_adv_tx->payload. connect_req.adv_addr[0],
&pdu_adv_tx->payload.connect_ind.adv_addr[0],
BDADDR_SIZE);
radio_le_conn_cmplt->own_addr_type = pdu_adv_tx->tx_addr;
memcpy(&radio_le_conn_cmplt->own_addr[0],
&pdu_adv_tx->payload. connect_req.init_addr[0],
&pdu_adv_tx->payload.connect_ind.init_addr[0],
BDADDR_SIZE);
radio_le_conn_cmplt->peer_irk_index = irkmatch_id;
radio_le_conn_cmplt->interval = _radio.observer.conn_interval;
radio_le_conn_cmplt->latency = _radio.observer. conn_latency;
radio_le_conn_cmplt->timeout = _radio.observer.conn_timeout;
radio_le_conn_cmplt->mca =
pdu_adv_tx->payload.connect_req.lldata.sca;
pdu_adv_tx->payload.connect_ind.lldata.sca;
/* enqueue connection complete structure into queue */
rx_fc_lock(conn->handle);
@ -1031,17 +1032,17 @@ static inline uint32_t isr_rx_obs(uint8_t irkmatch_id, uint8_t rssi_ready)
(/* allow directed adv packets addressed to this device */
((_radio.observer.init_addr_type == pdu_adv_rx->rx_addr) &&
(memcmp(&_radio.observer.init_addr[0],
&pdu_adv_rx->payload.direct_ind.init_addr[0],
&pdu_adv_rx->payload.direct_ind.tgt_addr[0],
BDADDR_SIZE) == 0)) ||
/* allow directed adv packets where initiator address
* is resolvable private address
*/
(((_radio.observer.filter_policy & 0x02) != 0) &&
(pdu_adv_rx->rx_addr != 0) &&
((pdu_adv_rx->payload.direct_ind.init_addr[5] & 0xc0) == 0x40)))) ||
((pdu_adv_rx->payload.direct_ind.tgt_addr[5] & 0xc0) == 0x40)))) ||
(pdu_adv_rx->type == PDU_ADV_TYPE_NONCONN_IND) ||
(pdu_adv_rx->type == PDU_ADV_TYPE_SCAN_IND) ||
((pdu_adv_rx->type == PDU_ADV_TYPE_SCAN_RESP) &&
((pdu_adv_rx->type == PDU_ADV_TYPE_SCAN_RSP) &&
(_radio.observer.scan_state != 0))) &&
(pdu_adv_rx->len != 0) && (!_radio.observer.conn)) {
/* save the RSSI value */
@ -1402,7 +1403,7 @@ isr_rx_conn_pkt_ctrl(struct radio_pdu_node_rx *radio_pdu_node_rx,
pdu_data_rx = (struct pdu_data *)radio_pdu_node_rx->pdu_data;
switch (pdu_data_rx->payload.llctrl.opcode) {
case PDU_DATA_LLCTRL_TYPE_CONN_UPDATE_REQ:
case PDU_DATA_LLCTRL_TYPE_CONN_UPDATE_IND:
if (conn_update(_radio.conn_curr, pdu_data_rx) == 0) {
/* conn param req procedure, if any, is complete */
_radio.conn_curr->procedure_expire = 0;
@ -1411,7 +1412,7 @@ isr_rx_conn_pkt_ctrl(struct radio_pdu_node_rx *radio_pdu_node_rx,
}
break;
case PDU_DATA_LLCTRL_TYPE_CHANNEL_MAP_REQ:
case PDU_DATA_LLCTRL_TYPE_CHANNEL_MAP_IND:
if (channel_map_update(_radio.conn_curr, pdu_data_rx)) {
_radio.conn_curr->llcp_terminate.reason_peer = 0x28;
}
@ -1734,10 +1735,10 @@ isr_rx_conn_pkt_ctrl(struct radio_pdu_node_rx *radio_pdu_node_rx,
break;
case PDU_DATA_LLCTRL_TYPE_CONN_PARAM_RSP:
/* @todo send conn_update req */
/* TODO: send conn_update ind */
break;
case PDU_DATA_LLCTRL_TYPE_REJECT_IND_EXT:
case PDU_DATA_LLCTRL_TYPE_REJECT_EXT_IND:
if (_radio.conn_curr->llcp_req != _radio.conn_curr->llcp_ack) {
isr_rx_conn_pkt_ctrl_rej(radio_pdu_node_rx, rx_enqueue);
@ -3703,16 +3704,16 @@ static void mayfly_sched_win_offset_select(void *params)
pdu_ctrl_tx = (struct pdu_data *)
((uint8_t *)conn->llcp.connection_update.pdu_win_offset -
offsetof(struct pdu_data,
payload.llctrl.ctrldata.conn_update_req.win_offset));
payload.llctrl.ctrldata.conn_update_ind.win_offset));
pdu_ctrl_tx->ll_id = PDU_DATA_LLID_CTRL;
pdu_ctrl_tx->len =
offsetof(struct pdu_data_llctrl, ctrldata) +
sizeof(struct pdu_data_llctrl_reject_ind_ext);
sizeof(struct pdu_data_llctrl_reject_ext_ind);
pdu_ctrl_tx->payload.llctrl.opcode =
PDU_DATA_LLCTRL_TYPE_REJECT_IND_EXT;
pdu_ctrl_tx->payload.llctrl.ctrldata.reject_ind_ext.
PDU_DATA_LLCTRL_TYPE_REJECT_EXT_IND;
pdu_ctrl_tx->payload.llctrl.ctrldata.reject_ext_ind.
reject_opcode = PDU_DATA_LLCTRL_TYPE_CONN_PARAM_REQ;
pdu_ctrl_tx->payload.llctrl.ctrldata.reject_ind_ext.
pdu_ctrl_tx->payload.llctrl.ctrldata.reject_ext_ind.
error_code = 0x20; /* Unsupported parameter value */
}
}
@ -4437,20 +4438,20 @@ event_conn_update_st_init(struct connection *conn,
/* place the conn update req packet as next in tx queue */
pdu_ctrl_tx->ll_id = PDU_DATA_LLID_CTRL;
pdu_ctrl_tx->len = offsetof(struct pdu_data_llctrl, ctrldata) +
sizeof(struct pdu_data_llctrl_conn_update_req);
sizeof(struct pdu_data_llctrl_conn_update_ind);
pdu_ctrl_tx->payload.llctrl.opcode =
PDU_DATA_LLCTRL_TYPE_CONN_UPDATE_REQ;
pdu_ctrl_tx->payload.llctrl.ctrldata.conn_update_req.win_size =
PDU_DATA_LLCTRL_TYPE_CONN_UPDATE_IND;
pdu_ctrl_tx->payload.llctrl.ctrldata.conn_update_ind.win_size =
conn->llcp.connection_update.win_size;
pdu_ctrl_tx->payload.llctrl.ctrldata.conn_update_req.
pdu_ctrl_tx->payload.llctrl.ctrldata.conn_update_ind.
win_offset = conn->llcp.connection_update.win_offset_us / 1250;
pdu_ctrl_tx->payload.llctrl.ctrldata.conn_update_req.interval =
pdu_ctrl_tx->payload.llctrl.ctrldata.conn_update_ind.interval =
conn->llcp.connection_update.interval;
pdu_ctrl_tx->payload.llctrl.ctrldata.conn_update_req.latency =
pdu_ctrl_tx->payload.llctrl.ctrldata.conn_update_ind.latency =
conn->llcp.connection_update.latency;
pdu_ctrl_tx->payload.llctrl.ctrldata.conn_update_req.timeout =
pdu_ctrl_tx->payload.llctrl.ctrldata.conn_update_ind.timeout =
conn->llcp.connection_update.timeout;
pdu_ctrl_tx->payload.llctrl.ctrldata.conn_update_req.instant =
pdu_ctrl_tx->payload.llctrl.ctrldata.conn_update_ind.instant =
conn->llcp.connection_update.instant;
#if SCHED_ADVANCED
@ -4475,7 +4476,7 @@ event_conn_update_st_init(struct connection *conn,
}
conn->llcp.connection_update.pdu_win_offset = (uint16_t *)
&pdu_ctrl_tx->payload.llctrl.ctrldata.conn_update_req.win_offset;
&pdu_ctrl_tx->payload.llctrl.ctrldata.conn_update_ind.win_offset;
mayfly_sched_offset->fp = fp_mayfly_select_or_use;
mayfly_sched_offset->param = (void *)conn;
@ -4940,15 +4941,15 @@ static inline void event_ch_map_prep(struct connection *conn,
pdu_ctrl_tx->ll_id = PDU_DATA_LLID_CTRL;
pdu_ctrl_tx->len = offsetof(struct pdu_data_llctrl,
ctrldata) +
sizeof(struct pdu_data_llctrl_channel_map_req);
sizeof(struct pdu_data_llctrl_channel_map_ind);
pdu_ctrl_tx->payload.llctrl.opcode =
PDU_DATA_LLCTRL_TYPE_CHANNEL_MAP_REQ;
PDU_DATA_LLCTRL_TYPE_CHANNEL_MAP_IND;
memcpy(&pdu_ctrl_tx->payload.llctrl.
ctrldata.channel_map_req.chm[0],
ctrldata.channel_map_ind.chm[0],
&conn->llcp.channel_map.chm[0],
sizeof(pdu_ctrl_tx->payload.
llctrl.ctrldata.channel_map_req.chm));
pdu_ctrl_tx->payload.llctrl.ctrldata.channel_map_req.instant =
llctrl.ctrldata.channel_map_ind.chm));
pdu_ctrl_tx->payload.llctrl.ctrldata.channel_map_ind.instant =
conn->llcp.channel_map.instant;
ctrl_tx_enqueue(conn, node_tx);
@ -5924,28 +5925,28 @@ static void prepare_pdu_data_tx(struct connection *conn,
PDU_DATA_LLCTRL_TYPE_TERMINATE_IND) &&
(_pdu_data_tx->payload.llctrl.opcode != PDU_DATA_LLCTRL_TYPE_START_ENC_RSP) &&
(_pdu_data_tx->payload.llctrl.opcode != PDU_DATA_LLCTRL_TYPE_REJECT_IND) &&
(_pdu_data_tx->payload.llctrl.opcode != PDU_DATA_LLCTRL_TYPE_REJECT_IND_EXT)) ||
(_pdu_data_tx->payload.llctrl.opcode != PDU_DATA_LLCTRL_TYPE_REJECT_EXT_IND)) ||
((conn->refresh != 0) &&
(_pdu_data_tx->payload.llctrl.opcode != PDU_DATA_LLCTRL_TYPE_TERMINATE_IND) &&
(_pdu_data_tx->payload.llctrl.opcode != PDU_DATA_LLCTRL_TYPE_PAUSE_ENC_RSP) &&
(_pdu_data_tx->payload.llctrl.opcode != PDU_DATA_LLCTRL_TYPE_ENC_REQ) &&
(_pdu_data_tx->payload.llctrl.opcode != PDU_DATA_LLCTRL_TYPE_START_ENC_RSP) &&
(_pdu_data_tx->payload.llctrl.opcode != PDU_DATA_LLCTRL_TYPE_REJECT_IND) &&
(_pdu_data_tx->payload.llctrl.opcode != PDU_DATA_LLCTRL_TYPE_REJECT_IND_EXT)))) ||
(_pdu_data_tx->payload.llctrl.opcode != PDU_DATA_LLCTRL_TYPE_REJECT_EXT_IND)))) ||
((conn->role.slave.role != 0) &&
(((conn->refresh == 0) &&
(_pdu_data_tx->payload.llctrl.opcode != PDU_DATA_LLCTRL_TYPE_TERMINATE_IND) &&
(_pdu_data_tx->payload.llctrl.opcode != PDU_DATA_LLCTRL_TYPE_START_ENC_REQ) &&
(_pdu_data_tx->payload.llctrl.opcode != PDU_DATA_LLCTRL_TYPE_START_ENC_RSP) &&
(_pdu_data_tx->payload.llctrl.opcode != PDU_DATA_LLCTRL_TYPE_REJECT_IND) &&
(_pdu_data_tx->payload.llctrl.opcode != PDU_DATA_LLCTRL_TYPE_REJECT_IND_EXT)) ||
(_pdu_data_tx->payload.llctrl.opcode != PDU_DATA_LLCTRL_TYPE_REJECT_EXT_IND)) ||
((conn->refresh != 0) &&
(_pdu_data_tx->payload.llctrl.opcode != PDU_DATA_LLCTRL_TYPE_TERMINATE_IND) &&
(_pdu_data_tx->payload.llctrl.opcode != PDU_DATA_LLCTRL_TYPE_ENC_RSP) &&
(_pdu_data_tx->payload.llctrl.opcode != PDU_DATA_LLCTRL_TYPE_START_ENC_REQ) &&
(_pdu_data_tx->payload.llctrl.opcode != PDU_DATA_LLCTRL_TYPE_START_ENC_RSP) &&
(_pdu_data_tx->payload.llctrl.opcode != PDU_DATA_LLCTRL_TYPE_REJECT_IND) &&
(_pdu_data_tx->payload.llctrl.opcode != PDU_DATA_LLCTRL_TYPE_REJECT_IND_EXT))))))) {
(_pdu_data_tx->payload.llctrl.opcode != PDU_DATA_LLCTRL_TYPE_REJECT_EXT_IND))))))) {
_pdu_data_tx = empty_tx_enqueue(conn);
} else {
uint16_t max_tx_octets;
@ -5982,7 +5983,7 @@ static void prepare_pdu_data_tx(struct connection *conn,
}
}
_pdu_data_tx->rfu0 = 0;
_pdu_data_tx->rfu = 0;
_pdu_data_tx->resv = 0;
*pdu_data_tx = _pdu_data_tx;
@ -6407,7 +6408,7 @@ static void terminate_ind_rx_enqueue(struct connection *conn, uint8_t reason)
static uint32_t conn_update(struct connection *conn,
struct pdu_data *pdu_data_rx)
{
if (((pdu_data_rx->payload.llctrl.ctrldata.conn_update_req.instant -
if (((pdu_data_rx->payload.llctrl.ctrldata.conn_update_ind.instant -
conn->event_counter) & 0xFFFF) > 0x7FFF) {
return 1;
}
@ -6427,18 +6428,18 @@ static uint32_t conn_update(struct connection *conn,
}
conn->llcp.connection_update.win_size =
pdu_data_rx->payload.llctrl.ctrldata.conn_update_req.win_size;
pdu_data_rx->payload.llctrl.ctrldata.conn_update_ind.win_size;
conn->llcp.connection_update.win_offset_us =
pdu_data_rx->payload.llctrl.ctrldata.conn_update_req.win_offset *
pdu_data_rx->payload.llctrl.ctrldata.conn_update_ind.win_offset *
1250;
conn->llcp.connection_update.interval =
pdu_data_rx->payload.llctrl.ctrldata.conn_update_req.interval;
pdu_data_rx->payload.llctrl.ctrldata.conn_update_ind.interval;
conn->llcp.connection_update.latency =
pdu_data_rx->payload.llctrl.ctrldata.conn_update_req.latency;
pdu_data_rx->payload.llctrl.ctrldata.conn_update_ind.latency;
conn->llcp.connection_update.timeout =
pdu_data_rx->payload.llctrl.ctrldata.conn_update_req.timeout;
pdu_data_rx->payload.llctrl.ctrldata.conn_update_ind.timeout;
conn->llcp.connection_update.instant =
pdu_data_rx->payload.llctrl.ctrldata.conn_update_req.instant;
pdu_data_rx->payload.llctrl.ctrldata.conn_update_ind.instant;
conn->llcp.connection_update.state = LLCP_CONN_STATE_INPROG;
conn->llcp.connection_update.is_internal = 0;
@ -6488,7 +6489,7 @@ static uint32_t conn_update_req(struct connection *conn)
static uint32_t channel_map_update(struct connection *conn,
struct pdu_data *pdu_data_rx)
{
if (((pdu_data_rx->payload.llctrl.ctrldata.channel_map_req.instant -
if (((pdu_data_rx->payload.llctrl.ctrldata.channel_map_ind.instant -
conn->event_counter) & 0xffff) > 0x7fff) {
return 1;
}
@ -6496,10 +6497,10 @@ static uint32_t channel_map_update(struct connection *conn,
LL_ASSERT(conn->llcp_req == conn->llcp_ack);
memcpy(&conn->llcp.channel_map.chm[0],
&pdu_data_rx->payload.llctrl.ctrldata.channel_map_req.chm[0],
&pdu_data_rx->payload.llctrl.ctrldata.channel_map_ind.chm[0],
sizeof(conn->llcp.channel_map.chm));
conn->llcp.channel_map.instant =
pdu_data_rx->payload.llctrl.ctrldata.channel_map_req.instant;
pdu_data_rx->payload.llctrl.ctrldata.channel_map_ind.instant;
conn->llcp.channel_map.initiate = 0;
conn->llcp_type = LLCP_CHANNEL_MAP;
@ -6705,12 +6706,12 @@ static void reject_ind_ext_send(struct connection *conn,
pdu_ctrl_tx = (struct pdu_data *)node_tx->pdu_data;
pdu_ctrl_tx->ll_id = PDU_DATA_LLID_CTRL;
pdu_ctrl_tx->len = offsetof(struct pdu_data_llctrl, ctrldata) +
sizeof(struct pdu_data_llctrl_reject_ind_ext);
sizeof(struct pdu_data_llctrl_reject_ext_ind);
pdu_ctrl_tx->payload.llctrl.opcode =
PDU_DATA_LLCTRL_TYPE_REJECT_IND_EXT;
pdu_ctrl_tx->payload.llctrl.ctrldata.reject_ind_ext.reject_opcode =
PDU_DATA_LLCTRL_TYPE_REJECT_EXT_IND;
pdu_ctrl_tx->payload.llctrl.ctrldata.reject_ext_ind.reject_opcode =
reject_opcode;
pdu_ctrl_tx->payload.llctrl.ctrldata.reject_ind_ext.error_code =
pdu_ctrl_tx->payload.llctrl.ctrldata.reject_ext_ind.error_code =
error_code;
ctrl_tx_enqueue(conn, node_tx);

2
subsys/bluetooth/controller/ll/ctrl.h
View file

@ -86,7 +86,7 @@
/*****************************************************************************
* Controller Interface Defines
****************************************************************************/
#define RADIO_BLE_VERSION_NUMBER 0x08
#define RADIO_BLE_VERSION_NUMBER BT_HCI_VERSION_5_0
#if defined(CONFIG_BLUETOOTH_CONTROLLER_COMPANY_ID)
#define RADIO_BLE_COMPANY_ID CONFIG_BLUETOOTH_CONTROLLER_COMPANY_ID
#else

28
subsys/bluetooth/controller/ll/ll.c
View file

@ -93,28 +93,34 @@ void ll_adv_params_set(uint16_t interval, uint8_t adv_type,
radio_adv_data = radio_adv_data_get();
pdu = (struct pdu_adv *)&radio_adv_data->data[radio_adv_data->last][0];
pdu->type = _ll_adv_params.adv_type;
pdu->rfu = 0;
pdu->ch_sel = 0;
pdu->tx_addr = _ll_adv_params.tx_addr;
if (adv_type == PDU_ADV_TYPE_DIRECT_IND) {
_ll_adv_params.rx_addr = direct_addr_type;
memcpy(&_ll_adv_params.direct_addr[0], direct_addr,
BDADDR_SIZE);
memcpy(&pdu->payload.direct_ind.init_addr[0],
memcpy(&pdu->payload.direct_ind.tgt_addr[0],
direct_addr, BDADDR_SIZE);
pdu->len = sizeof(struct pdu_adv_payload_direct_ind);
} else if (pdu->len == 0) {
pdu->len = BDADDR_SIZE;
}
pdu->rx_addr = _ll_adv_params.rx_addr;
pdu->resv = 0;
/* update the current scan data */
radio_adv_data = radio_scan_data_get();
pdu = (struct pdu_adv *)&radio_adv_data->data[radio_adv_data->last][0];
pdu->type = PDU_ADV_TYPE_SCAN_RESP;
pdu->type = PDU_ADV_TYPE_SCAN_RSP;
pdu->rfu = 0;
pdu->ch_sel = 0;
pdu->tx_addr = _ll_adv_params.tx_addr;
pdu->rx_addr = 0;
if (pdu->len == 0) {
pdu->len = BDADDR_SIZE;
}
pdu->resv = 0;
}
void ll_adv_data_set(uint8_t len, uint8_t const *const data)
@ -139,18 +145,21 @@ void ll_adv_data_set(uint8_t len, uint8_t const *const data)
/* update adv pdu fields. */
pdu = (struct pdu_adv *)&radio_adv_data->data[last][0];
pdu->type = _ll_adv_params.adv_type;
pdu->rfu = 0;
pdu->ch_sel = 0;
pdu->tx_addr = _ll_adv_params.tx_addr;
pdu->rx_addr = _ll_adv_params.rx_addr;
memcpy(&pdu->payload.adv_ind.addr[0],
&_ll_adv_params.adv_addr[0], BDADDR_SIZE);
if (_ll_adv_params.adv_type == PDU_ADV_TYPE_DIRECT_IND) {
memcpy(&pdu->payload.direct_ind.init_addr[0],
memcpy(&pdu->payload.direct_ind.tgt_addr[0],
&_ll_adv_params.direct_addr[0], BDADDR_SIZE);
pdu->len = sizeof(struct pdu_adv_payload_direct_ind);
} else {
memcpy(&pdu->payload.adv_ind.data[0], data, len);
pdu->len = BDADDR_SIZE + len;
}
pdu->resv = 0;
/* commit the update so controller picks it. */
radio_adv_data->last = last;
@ -175,13 +184,16 @@ void ll_scan_data_set(uint8_t len, uint8_t const *const data)
/* update scan pdu fields. */
pdu = (struct pdu_adv *)&radio_scan_data->data[last][0];
pdu->type = PDU_ADV_TYPE_SCAN_RESP;
pdu->type = PDU_ADV_TYPE_SCAN_RSP;
pdu->rfu = 0;
pdu->ch_sel = 0;
pdu->tx_addr = _ll_adv_params.tx_addr;
pdu->rx_addr = 0;
pdu->len = BDADDR_SIZE + len;
memcpy(&pdu->payload.scan_resp.addr[0],
memcpy(&pdu->payload.scan_rsp.addr[0],
&_ll_adv_params.adv_addr[0], BDADDR_SIZE);
memcpy(&pdu->payload.scan_resp.data[0], data, len);
memcpy(&pdu->payload.scan_rsp.data[0], data, len);
pdu->resv = 0;
/* commit the update so controller picks it. */
radio_scan_data->last = last;
@ -216,14 +228,14 @@ uint32_t ll_adv_enable(uint8_t enable)
&_ll_context.rnd_addr[0], BDADDR_SIZE);
memcpy(&pdu_adv->payload.adv_ind.addr[0],
&_ll_context.rnd_addr[0], BDADDR_SIZE);
memcpy(&pdu_scan->payload.scan_resp.addr[0],
memcpy(&pdu_scan->payload.scan_rsp.addr[0],
&_ll_context.rnd_addr[0], BDADDR_SIZE);
} else {
memcpy(&_ll_adv_params.adv_addr[0],
&_ll_context.pub_addr[0], BDADDR_SIZE);
memcpy(&pdu_adv->payload.adv_ind.addr[0],
&_ll_context.pub_addr[0], BDADDR_SIZE);
memcpy(&pdu_scan->payload.scan_resp.addr[0],
memcpy(&pdu_scan->payload.scan_rsp.addr[0],
&_ll_context.pub_addr[0], BDADDR_SIZE);
}

59
subsys/bluetooth/controller/ll/pdu.h
View file

@ -17,10 +17,10 @@ struct pdu_adv_payload_adv_ind {
struct pdu_adv_payload_direct_ind {
uint8_t adv_addr[BDADDR_SIZE];
uint8_t init_addr[BDADDR_SIZE];
uint8_t tgt_addr[BDADDR_SIZE];
} __packed;
struct pdu_adv_payload_scan_resp {
struct pdu_adv_payload_scan_rsp {
uint8_t addr[BDADDR_SIZE];
uint8_t data[31];
} __packed;
@ -30,7 +30,7 @@ struct pdu_adv_payload_scan_req {
uint8_t adv_addr[BDADDR_SIZE];
} __packed;
struct pdu_adv_payload_connect_req {
struct pdu_adv_payload_connect_ind {
uint8_t init_addr[BDADDR_SIZE];
uint8_t adv_addr[BDADDR_SIZE];
struct {
@ -52,25 +52,36 @@ enum pdu_adv_type {
PDU_ADV_TYPE_DIRECT_IND = 0x01,
PDU_ADV_TYPE_NONCONN_IND = 0x02,
PDU_ADV_TYPE_SCAN_REQ = 0x03,
PDU_ADV_TYPE_SCAN_RESP = 0x04,
PDU_ADV_TYPE_CONNECT_REQ = 0x05,
PDU_ADV_TYPE_AUX_SCAN_REQ = PDU_ADV_TYPE_SCAN_REQ,
PDU_ADV_TYPE_SCAN_RSP = 0x04,
PDU_ADV_TYPE_CONNECT_IND = 0x05,
PDU_ADV_TYPE_AUX_CONNECT_REQ = PDU_ADV_TYPE_CONNECT_IND,
PDU_ADV_TYPE_SCAN_IND = 0x06,
PDU_ADV_TYPE_EXT_IND = 0x07,
PDU_ADV_TYPE_AUX_ADV_IND = PDU_ADV_TYPE_EXT_IND,
PDU_ADV_TYPE_AUX_SCAN_RSP = PDU_ADV_TYPE_EXT_IND,
PDU_ADV_TYPE_AUX_SYNC_IND = PDU_ADV_TYPE_EXT_IND,
PDU_ADV_TYPE_AUX_CHAIN_IND = PDU_ADV_TYPE_EXT_IND,
PDU_ADV_TYPE_AUX_CONNECT_RSP = 0x08,
} __packed;
struct pdu_adv {
uint8_t type:4;
uint8_t rfu0:2;
uint8_t rfu:1;
uint8_t ch_sel:1;
uint8_t tx_addr:1;
uint8_t rx_addr:1;
uint8_t len:6;
uint8_t rfu1:2;
uint8_t nrf_radio_s1;
uint8_t len:8;
uint8_t resv:8; /* TODO: remove nRF specific code */
union {
struct pdu_adv_payload_adv_ind adv_ind;
struct pdu_adv_payload_direct_ind direct_ind;
struct pdu_adv_payload_scan_req scan_req;
struct pdu_adv_payload_scan_resp scan_resp;
struct pdu_adv_payload_connect_req connect_req;
struct pdu_adv_payload_scan_rsp scan_rsp;
struct pdu_adv_payload_connect_ind connect_ind;
} __packed payload;
} __packed;
@ -82,8 +93,8 @@ enum pdu_data_llid {
};
enum pdu_data_llctrl_type {
PDU_DATA_LLCTRL_TYPE_CONN_UPDATE_REQ = 0x00,
PDU_DATA_LLCTRL_TYPE_CHANNEL_MAP_REQ = 0x01,
PDU_DATA_LLCTRL_TYPE_CONN_UPDATE_IND = 0x00,
PDU_DATA_LLCTRL_TYPE_CHANNEL_MAP_IND = 0x01,
PDU_DATA_LLCTRL_TYPE_TERMINATE_IND = 0x02,
PDU_DATA_LLCTRL_TYPE_ENC_REQ = 0x03,
PDU_DATA_LLCTRL_TYPE_ENC_RSP = 0x04,
@ -99,14 +110,18 @@ enum pdu_data_llctrl_type {
PDU_DATA_LLCTRL_TYPE_SLAVE_FEATURE_REQ = 0x0E,
PDU_DATA_LLCTRL_TYPE_CONN_PARAM_REQ = 0x0F,
PDU_DATA_LLCTRL_TYPE_CONN_PARAM_RSP = 0x10,
PDU_DATA_LLCTRL_TYPE_REJECT_IND_EXT = 0x11,
PDU_DATA_LLCTRL_TYPE_REJECT_EXT_IND = 0x11,
PDU_DATA_LLCTRL_TYPE_PING_REQ = 0x12,
PDU_DATA_LLCTRL_TYPE_PING_RSP = 0x13,
PDU_DATA_LLCTRL_TYPE_LENGTH_REQ = 0x14,
PDU_DATA_LLCTRL_TYPE_LENGTH_RSP = 0x15,
PDU_DATA_LLCTRL_TYPE_PHY_REQ = 0x16,
PDU_DATA_LLCTRL_TYPE_PHY_RSP = 0x17,
PDU_DATA_LLCTRL_TYPE_PHY_UPDATE_IND = 0x18,
PDU_DATA_LLCTRL_TYPE_MIN_USED_CHNLS_IND = 0x19,
};
struct pdu_data_llctrl_conn_update_req {
struct pdu_data_llctrl_conn_update_ind {
uint8_t win_size;
uint16_t win_offset;
uint16_t interval;
@ -115,7 +130,7 @@ struct pdu_data_llctrl_conn_update_req {
uint16_t instant;
} __packed;
struct pdu_data_llctrl_channel_map_req {
struct pdu_data_llctrl_channel_map_ind {
uint8_t chm[5];
uint16_t instant;
} __packed;
@ -188,7 +203,7 @@ struct pdu_data_llctrl_conn_param_rsp {
uint16_t offset5;
} __packed;
struct pdu_data_llctrl_reject_ind_ext {
struct pdu_data_llctrl_reject_ext_ind {
uint8_t reject_opcode;
uint8_t error_code;
} __packed;
@ -203,8 +218,8 @@ struct pdu_data_llctrl_length_req_rsp {
struct pdu_data_llctrl {
uint8_t opcode;
union {
struct pdu_data_llctrl_conn_update_req conn_update_req;
struct pdu_data_llctrl_channel_map_req channel_map_req;
struct pdu_data_llctrl_conn_update_ind conn_update_ind;
struct pdu_data_llctrl_channel_map_ind channel_map_ind;
struct pdu_data_llctrl_terminate_ind terminate_ind;
struct pdu_data_llctrl_enc_req enc_req;
struct pdu_data_llctrl_enc_rsp enc_rsp;
@ -216,7 +231,7 @@ struct pdu_data_llctrl {
struct pdu_data_llctrl_feature_req slave_feature_req;
struct pdu_data_llctrl_conn_param_req conn_param_req;
struct pdu_data_llctrl_conn_param_rsp conn_param_rsp;
struct pdu_data_llctrl_reject_ind_ext reject_ind_ext;
struct pdu_data_llctrl_reject_ext_ind reject_ext_ind;
struct pdu_data_llctrl_length_req_rsp length_req;
struct pdu_data_llctrl_length_req_rsp length_rsp;
} __packed ctrldata;
@ -238,11 +253,11 @@ struct pdu_data {
uint8_t nesn:1;
uint8_t sn:1;
uint8_t md:1;
uint8_t rfu0:3;
uint8_t rfu:3;
uint8_t len:8;
uint8_t resv:8;
uint8_t resv:8; /* TODO: remove nRF specific code */
union {
uint8_t lldata[1];