Bluetooth: Controller: Version 5.0 and PDU type rename

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

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);

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

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);
}

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];