michaelh/zephyr
1
0
Fork 0
Code Releases Activity

Bluetooth: Controller: Fix alignment issues from new integer types

Browse source 
The switch from C99 integer types to u16_t, etc. caused misalignment
in structs and function definitions with multi-line parameter lists.

Change-Id: I1448b159ab1afe50ff88b7a6bd1b254c44858d4c
Signed-off-by: Carles Cufi <carles.cufi@nordicsemi.no>
This commit is contained in:
Carles Cufi 2017-04-21 13:18:52 +02:00 • committed by Anas Nashif
commit a6e157b61a
17 changed files with 362 additions and 422 deletions
Download patch file Download diff file Expand all files Collapse all files

8
subsys/bluetooth/controller/hal/ccm.h
View file

@ -9,11 +9,11 @@
#define _CCM_H_ #define _CCM_H_
struct ccm { struct ccm {
u8_t key[16]; u8_t key[16];
u64_t counter; u64_t counter;
u8_t direction:1; u8_t direction:1;
u8_t resv1:7; u8_t resv1:7;
u8_t iv[8]; u8_t iv[8];
} __packed; } __packed;
#endif /* _CCM_H_ */ #endif /* _CCM_H_ */

24
subsys/bluetooth/controller/hal/ecb.h
View file

@ -8,28 +8,24 @@
#ifndef _ECB_H_ #ifndef _ECB_H_
#define _ECB_H_ #define _ECB_H_
typedef void (*ecb_fp) (u32_t status, u8_t *cipher_be, typedef void (*ecb_fp) (u32_t status, u8_t *cipher_be, void *context);
void *context);
struct ecb { struct ecb {
u8_t in_key_be[16]; u8_t in_key_be[16];
u8_t in_clear_text_be[16]; u8_t in_clear_text_be[16];
u8_t out_cipher_text_be[16]; u8_t out_cipher_text_be[16];
/* if not null reverse copy into in_key_be */ /* if not null reverse copy into in_key_be */
u8_t *in_key_le; u8_t *in_key_le;
/* if not null reverse copy into in_clear_text_be */ /* if not null reverse copy into in_clear_text_be */
u8_t *in_clear_text_le; u8_t *in_clear_text_le;
ecb_fp fp_ecb; ecb_fp fp_ecb;
void *context; void *context;
}; };
void ecb_encrypt_be(u8_t const *const key_be, void ecb_encrypt_be(u8_t const *const key_be, u8_t const *const clear_text_be,
u8_t const *const clear_text_be,
u8_t * const cipher_text_be); u8_t * const cipher_text_be);
void ecb_encrypt(u8_t const *const key_le, void ecb_encrypt(u8_t const *const key_le, u8_t const *const clear_text_le,
u8_t const *const clear_text_le, u8_t * const cipher_text_le, u8_t * const cipher_text_be);
u8_t * const cipher_text_le,
u8_t * const cipher_text_be);
u32_t ecb_encrypt_nonblocking(struct ecb *ecb); u32_t ecb_encrypt_nonblocking(struct ecb *ecb);
void isr_ecb(void *param); void isr_ecb(void *param);

22
subsys/bluetooth/controller/hal/nrf5/ecb.c
View file

@ -40,8 +40,7 @@ static void do_ecb(struct ecb_param *ecb)
NRF_ECB->ECBDATAPTR = 0; NRF_ECB->ECBDATAPTR = 0;
} }
void ecb_encrypt_be(u8_t const *const key_be, void ecb_encrypt_be(u8_t const *const key_be, u8_t const *const clear_text_be,
u8_t const *const clear_text_be,
u8_t * const cipher_text_be) u8_t * const cipher_text_be)
{ {
struct ecb_param ecb; struct ecb_param ecb;
@ -54,10 +53,8 @@ void ecb_encrypt_be(u8_t const *const key_be,
memcpy(cipher_text_be, &ecb.cipher_text[0], sizeof(ecb.cipher_text)); memcpy(cipher_text_be, &ecb.cipher_text[0], sizeof(ecb.cipher_text));
} }
void ecb_encrypt(u8_t const *const key_le, void ecb_encrypt(u8_t const *const key_le, u8_t const *const clear_text_le,
u8_t const *const clear_text_le, u8_t * const cipher_text_le, u8_t * const cipher_text_be)
u8_t * const cipher_text_le,
u8_t * const cipher_text_be)
{ {
struct ecb_param ecb; struct ecb_param ecb;
@ -144,7 +141,7 @@ void isr_ecb(void *param)
struct ecb_ut_context { struct ecb_ut_context {
u32_t volatile done; u32_t volatile done;
u32_t status; u32_t status;
u8_t cipher_text[16]; u8_t cipher_text[16];
}; };
static void ecb_cb(u32_t status, u8_t *cipher_be, void *context) static void ecb_cb(u32_t status, u8_t *cipher_be, void *context)
@ -162,12 +159,11 @@ static void ecb_cb(u32_t status, u8_t *cipher_be, void *context)
u32_t ecb_ut(void) u32_t ecb_ut(void)
{ {
u8_t key[16] = { u8_t key[16] = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0x00, 0x99, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55 };
0x11, 0x22, 0x33, 0x44, 0x55 }; u8_t clear_text[16] = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
u8_t clear_text[16] = { 0x88, 0x99, 0x00, 0x11, 0x22, 0x33, 0x44,
0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0x00, 0x55 };
0x11, 0x22, 0x33, 0x44, 0x55 };
u8_t cipher_text[16]; u8_t cipher_text[16];
u32_t status = 0; u32_t status = 0;
struct ecb ecb; struct ecb ecb;

5
subsys/bluetooth/controller/hal/nrf5/radio.c
View file

@ -261,9 +261,8 @@ u32_t radio_rssi_is_ready(void)
return NRF_RADIO->EVENTS_RSSIEND; return NRF_RADIO->EVENTS_RSSIEND;
} }
void radio_filter_configure(u8_t bitmask_enable, void radio_filter_configure(u8_t bitmask_enable, u8_t bitmask_addr_type,
u8_t bitmask_addr_type, u8_t *bdaddr)
u8_t *bdaddr)
{ {
u8_t index; u8_t index;

5
subsys/bluetooth/controller/hal/radio.h
View file

@ -59,9 +59,8 @@ u32_t radio_rssi_get(void);
void radio_rssi_status_reset(void); void radio_rssi_status_reset(void);
u32_t radio_rssi_is_ready(void); u32_t radio_rssi_is_ready(void);
void radio_filter_configure(u8_t bitmask_enable, void radio_filter_configure(u8_t bitmask_enable, u8_t bitmask_addr_type,
u8_t bitmask_addr_type, u8_t *bdaddr);
u8_t *bdaddr);
void radio_filter_disable(void); void radio_filter_disable(void);
void radio_filter_status_reset(void); void radio_filter_status_reset(void);
u32_t radio_filter_has_match(void); u32_t radio_filter_has_match(void);

8
subsys/bluetooth/controller/hci/hci.c
View file

@ -38,8 +38,8 @@ static u16_t _opcode;
#if CONFIG_BLUETOOTH_CONTROLLER_DUP_FILTER_LEN > 0 #if CONFIG_BLUETOOTH_CONTROLLER_DUP_FILTER_LEN > 0
/* Scan duplicate filter */ /* Scan duplicate filter */
struct dup { struct dup {
u8_t mask; u8_t mask;
bt_addr_le_t addr; bt_addr_le_t addr;
}; };
static struct dup dup_filter[CONFIG_BLUETOOTH_CONTROLLER_DUP_FILTER_LEN]; static struct dup dup_filter[CONFIG_BLUETOOTH_CONTROLLER_DUP_FILTER_LEN];
static s32_t dup_count; static s32_t dup_count;
@ -1003,7 +1003,7 @@ static void le_advertising_report(struct pdu_data *pdu_data, u8_t *b,
struct net_buf *buf) struct net_buf *buf)
{ {
const u8_t c_adv_type[] = { 0x00, 0x01, 0x03, 0xff, 0x04, const u8_t c_adv_type[] = { 0x00, 0x01, 0x03, 0xff, 0x04,
0xff, 0x02 }; 0xff, 0x02 };
struct bt_hci_ev_le_advertising_report *sep; struct bt_hci_ev_le_advertising_report *sep;
struct pdu_adv *adv = (struct pdu_adv *)pdu_data; struct pdu_adv *adv = (struct pdu_adv *)pdu_data;
struct bt_hci_ev_le_advertising_info *adv_info; struct bt_hci_ev_le_advertising_info *adv_info;
@ -1275,7 +1275,7 @@ static void encode_control(struct radio_pdu_node_rx *node_rx,
} }
static void le_ltk_request(struct pdu_data *pdu_data, u16_t handle, static void le_ltk_request(struct pdu_data *pdu_data, u16_t handle,
struct net_buf *buf) struct net_buf *buf)
{ {
struct bt_hci_evt_le_ltk_request *sep; struct bt_hci_evt_le_ltk_request *sep;

18
subsys/bluetooth/controller/include/ll.h
View file

@ -29,20 +29,20 @@ u32_t ll_filter_remove(u8_t addr_type, u8_t *addr);
void ll_irk_clear(void); void ll_irk_clear(void);
u32_t ll_irk_add(u8_t *irk); u32_t ll_irk_add(u8_t *irk);
u32_t ll_create_connection(u16_t scan_interval, u16_t scan_window, u32_t ll_create_connection(u16_t scan_interval, u16_t scan_window,
u8_t filter_policy, u8_t peer_addr_type, u8_t filter_policy, u8_t peer_addr_type,
u8_t *p_peer_addr, u8_t own_addr_type, u8_t *p_peer_addr, u8_t own_addr_type,
u16_t interval, u16_t latency, u16_t interval, u16_t latency,
u16_t timeout); u16_t timeout);
u32_t ll_connect_disable(void); u32_t ll_connect_disable(void);
u32_t ll_conn_update(u16_t handle, u8_t cmd, u8_t status, u32_t ll_conn_update(u16_t handle, u8_t cmd, u8_t status,
u16_t interval, u16_t latency, u16_t interval, u16_t latency,
u16_t timeout); u16_t timeout);
u32_t ll_chm_update(u8_t *chm); u32_t ll_chm_update(u8_t *chm);
u32_t ll_chm_get(u16_t handle, u8_t *chm); u32_t ll_chm_get(u16_t handle, u8_t *chm);
u32_t ll_enc_req_send(u16_t handle, u8_t *rand, u8_t *ediv, u32_t ll_enc_req_send(u16_t handle, u8_t *rand, u8_t *ediv,
u8_t *ltk); u8_t *ltk);
u32_t ll_start_enc_req_send(u16_t handle, u8_t err_code, u32_t ll_start_enc_req_send(u16_t handle, u8_t err_code,
u8_t const *const ltk); u8_t const *const ltk);
u32_t ll_feature_req_send(u16_t handle); u32_t ll_feature_req_send(u16_t handle);
u32_t ll_version_ind_send(u16_t handle); u32_t ll_version_ind_send(u16_t handle);
u32_t ll_terminate_ind_send(u16_t handle, u8_t reason); u32_t ll_terminate_ind_send(u16_t handle, u8_t reason);
@ -52,7 +52,7 @@ u32_t ll_length_req_send(u16_t handle, u16_t tx_octets);
void ll_length_default_get(u16_t *max_tx_octets, u16_t *max_tx_time); void ll_length_default_get(u16_t *max_tx_octets, u16_t *max_tx_time);
u32_t ll_length_default_set(u16_t max_tx_octets, u16_t max_tx_time); u32_t ll_length_default_set(u16_t max_tx_octets, u16_t max_tx_time);
void ll_length_max_get(u16_t *max_tx_octets, u16_t *max_tx_time, void ll_length_max_get(u16_t *max_tx_octets, u16_t *max_tx_time,
u16_t *max_rx_octets, u16_t *max_rx_time); u16_t *max_rx_octets, u16_t *max_rx_time);
#endif /* CONFIG_BLUETOOTH_CONTROLLER_DATA_LENGTH */ #endif /* CONFIG_BLUETOOTH_CONTROLLER_DATA_LENGTH */
#endif /* _LL_H_ */ #endif /* _LL_H_ */

259
subsys/bluetooth/controller/ll_sw/ctrl.c
View file

@ -97,20 +97,20 @@ struct advertiser {
struct observer { struct observer {
struct shdr hdr; struct shdr hdr;
u8_t scan_type:1; u8_t scan_type:1;
u8_t scan_state:1; u8_t scan_state:1;
u8_t scan_chan:2; u8_t scan_chan:2;
u8_t filter_policy:2; u8_t filter_policy:2;
u8_t adv_addr_type:1; u8_t adv_addr_type:1;
u8_t init_addr_type:1; u8_t init_addr_type:1;
u8_t adv_addr[BDADDR_SIZE]; u8_t adv_addr[BDADDR_SIZE];
u8_t init_addr[BDADDR_SIZE]; u8_t init_addr[BDADDR_SIZE];
u32_t ticks_window; u32_t ticks_window;
u8_t filter_enable_bitmask; u8_t filter_enable_bitmask;
u8_t filter_addr_type_bitmask; u8_t filter_addr_type_bitmask;
u8_t filter_bdaddr[8][BDADDR_SIZE]; u8_t filter_bdaddr[8][BDADDR_SIZE];
u16_t conn_interval; u16_t conn_interval;
u16_t conn_latency; u16_t conn_latency;
@ -127,34 +127,34 @@ static struct {
u32_t ticks_anchor; u32_t ticks_anchor;
u32_t remainder_anchor; u32_t remainder_anchor;
u8_t volatile ticker_id_prepare; u8_t volatile ticker_id_prepare;
u8_t volatile ticker_id_event; u8_t volatile ticker_id_event;
u8_t volatile ticker_id_stop; u8_t volatile ticker_id_stop;
enum role volatile role; enum role volatile role;
enum state state; enum state state;
u8_t filter_enable_bitmask; u8_t filter_enable_bitmask;
u8_t filter_addr_type_bitmask; u8_t filter_addr_type_bitmask;
u8_t filter_bdaddr[8][BDADDR_SIZE]; u8_t filter_bdaddr[8][BDADDR_SIZE];
u8_t nirk; u8_t nirk;
u8_t irk[RADIO_IRK_COUNT_MAX][16]; u8_t irk[RADIO_IRK_COUNT_MAX][16];
struct advertiser advertiser; struct advertiser advertiser;
struct observer observer; struct observer observer;
void *conn_pool; void *conn_pool;
void *conn_free; void *conn_free;
u8_t connection_count; u8_t connection_count;
struct connection *conn_curr; struct connection *conn_curr;
u8_t packet_counter; u8_t packet_counter;
u8_t crc_expire; u8_t crc_expire;
u8_t data_chan_map[5]; u8_t data_chan_map[5];
u8_t data_chan_count; u8_t data_chan_count;
u8_t sca; u8_t sca;
#if defined(CONFIG_BLUETOOTH_CONTROLLER_DATA_LENGTH) #if defined(CONFIG_BLUETOOTH_CONTROLLER_DATA_LENGTH)
/* DLE global settings */ /* DLE global settings */
@ -166,46 +166,46 @@ static struct {
* Rx-es. * Rx-es.
*/ */
/* Advertiser, Observer, and Connections Rx data pool */ /* Advertiser, Observer, and Connections Rx data pool */
void *pkt_rx_data_pool; void *pkt_rx_data_pool;
void *pkt_rx_data_free; void *pkt_rx_data_free;
u16_t packet_data_octets_max; u16_t packet_data_octets_max;
u16_t packet_rx_data_pool_size; u16_t packet_rx_data_pool_size;
u16_t packet_rx_data_size; u16_t packet_rx_data_size;
u8_t packet_rx_data_count; u8_t packet_rx_data_count;
/* Free queue Rx data buffers */ /* Free queue Rx data buffers */
struct radio_pdu_node_rx **packet_rx; struct radio_pdu_node_rx **packet_rx;
u8_t packet_rx_count; u8_t packet_rx_count;
u8_t volatile packet_rx_last; u8_t volatile packet_rx_last;
u8_t packet_rx_acquire; u8_t packet_rx_acquire;
/* Controller to Host event-cum-data queue */ /* Controller to Host event-cum-data queue */
void *link_rx_pool; void *link_rx_pool;
void *link_rx_free; void *link_rx_free;
void *link_rx_head; void *link_rx_head;
void *volatile link_rx_tail; void *volatile link_rx_tail;
u8_t link_rx_data_quota; u8_t link_rx_data_quota;
/* Connections common Tx ctrl and data pool */ /* Connections common Tx ctrl and data pool */
void *pkt_tx_ctrl_pool; void *pkt_tx_ctrl_pool;
void *pkt_tx_ctrl_free; void *pkt_tx_ctrl_free;
void *pkt_tx_data_pool; void *pkt_tx_data_pool;
void *pkt_tx_data_free; void *pkt_tx_data_free;
u16_t packet_tx_data_size; u16_t packet_tx_data_size;
/* Host to Controller Tx, and Controller to Host Num complete queue */ /* Host to Controller Tx, and Controller to Host Num complete queue */
struct pdu_data_q_tx *pkt_tx; struct pdu_data_q_tx *pkt_tx;
struct pdu_data_q_tx *pkt_release; struct pdu_data_q_tx *pkt_release;
u8_t packet_tx_count; u8_t packet_tx_count;
u8_t volatile packet_tx_first; u8_t volatile packet_tx_first;
u8_t packet_tx_last; u8_t packet_tx_last;
u8_t packet_release_first; u8_t packet_release_first;
u8_t volatile packet_release_last; u8_t volatile packet_release_last;
u16_t fc_handle[TRIPLE_BUFFER_SIZE]; u16_t fc_handle[TRIPLE_BUFFER_SIZE];
u8_t volatile fc_req; u8_t volatile fc_req;
u8_t fc_ack; u8_t fc_ack;
u8_t fc_ena; u8_t fc_ena;
u32_t ticks_active_to_start; u32_t ticks_active_to_start;
@ -229,24 +229,22 @@ static void chan_sel_2_ut(void);
#endif /* CONFIG_BLUETOOTH_CONTROLLER_CHAN_SEL_2 */ #endif /* CONFIG_BLUETOOTH_CONTROLLER_CHAN_SEL_2 */
static void adv_setup(void); static void adv_setup(void);
static void event_adv(u32_t ticks_at_expire, u32_t remainder, static void event_adv(u32_t ticks_at_expire, u32_t remainder, u16_t lazy,
u16_t lazy, void *context); void *context);
static void event_obs(u32_t ticks_at_expire, u32_t remainder, static void event_obs(u32_t ticks_at_expire, u32_t remainder, u16_t lazy,
u16_t lazy, void *context); void *context);
static void event_slave_prepare(u32_t ticks_at_expire, static void event_slave_prepare(u32_t ticks_at_expire, u32_t remainder,
u32_t remainder, u16_t lazy, u16_t lazy, void *context);
void *context); static void event_slave(u32_t ticks_at_expire, u32_t remainder, u16_t lazy,
static void event_slave(u32_t ticks_at_expire, u32_t remainder, void *context);
u16_t lazy, void *context); static void event_master_prepare(u32_t ticks_at_expire, u32_t remainder,
static void event_master_prepare(u32_t ticks_at_expire, u16_t lazy, void *context);
u32_t remainder, u16_t lazy, static void event_master(u32_t ticks_at_expire, u32_t remainder, u16_t lazy,
void *context); void *context);
static void event_master(u32_t ticks_at_expire, u32_t remainder,
u16_t lazy, void *context);
static void rx_packet_set(struct connection *conn, static void rx_packet_set(struct connection *conn,
struct pdu_data *pdu_data_rx); struct pdu_data *pdu_data_rx);
static void tx_packet_set(struct connection *conn, static void tx_packet_set(struct connection *conn,
struct pdu_data *pdu_data_tx); struct pdu_data *pdu_data_tx);
static void prepare_pdu_data_tx(struct connection *conn, static void prepare_pdu_data_tx(struct connection *conn,
struct pdu_data **pdu_data_tx); struct pdu_data **pdu_data_tx);
static void packet_rx_allocate(u8_t max); static void packet_rx_allocate(u8_t max);
@ -264,12 +262,11 @@ static void ctrl_tx_enqueue(struct connection *conn,
static void pdu_node_tx_release(u16_t handle, static void pdu_node_tx_release(u16_t handle,
struct radio_pdu_node_tx *node_tx); struct radio_pdu_node_tx *node_tx);
static void connection_release(struct connection *conn); static void connection_release(struct connection *conn);
static u32_t conn_update(struct connection *conn, static u32_t conn_update(struct connection *conn, struct pdu_data *pdu_data_rx);
struct pdu_data *pdu_data_rx);
static u32_t is_peer_compatible(struct connection *conn); static u32_t is_peer_compatible(struct connection *conn);
static u32_t conn_update_req(struct connection *conn); static u32_t conn_update_req(struct connection *conn);
static u32_t chan_map_update(struct connection *conn, static u32_t chan_map_update(struct connection *conn,
struct pdu_data *pdu_data_rx); struct pdu_data *pdu_data_rx);
static void enc_req_reused_send(struct connection *conn, static void enc_req_reused_send(struct connection *conn,
struct radio_pdu_node_tx *node_tx); struct radio_pdu_node_tx *node_tx);
static void terminate_ind_rx_enqueue(struct connection *conn, u8_t reason); static void terminate_ind_rx_enqueue(struct connection *conn, u8_t reason);
@ -285,28 +282,25 @@ static void version_ind_send(struct connection *conn);
static void ping_resp_send(struct connection *conn); static void ping_resp_send(struct connection *conn);
#endif /* CONFIG_BLUETOOTH_CONTROLLER_LE_PING */ #endif /* CONFIG_BLUETOOTH_CONTROLLER_LE_PING */
static void reject_ind_ext_send(struct connection *conn, static void reject_ind_ext_send(struct connection *conn, u8_t reject_opcode,
u8_t reject_opcode,
u8_t error_code); u8_t error_code);
#if defined(CONFIG_BLUETOOTH_CONTROLLER_DATA_LENGTH) #if defined(CONFIG_BLUETOOTH_CONTROLLER_DATA_LENGTH)
static void length_resp_send(struct connection *conn, static void length_resp_send(struct connection *conn, u16_t eff_rx_octets,
u16_t eff_rx_octets, u16_t eff_tx_octets);
u16_t eff_tx_octets);
#endif /* CONFIG_BLUETOOTH_CONTROLLER_DATA_LENGTH */ #endif /* CONFIG_BLUETOOTH_CONTROLLER_DATA_LENGTH */
static u32_t role_disable(u8_t ticker_id_primary, static u32_t role_disable(u8_t ticker_id_primary, u8_t ticker_id_stop);
u8_t ticker_id_stop);
static void rx_fc_lock(u16_t handle); static void rx_fc_lock(u16_t handle);
/***************************************************************************** /*****************************************************************************
*RADIO *RADIO
****************************************************************************/ ****************************************************************************/
u32_t radio_init(void *hf_clock, u8_t sca, u8_t connection_count_max, u32_t radio_init(void *hf_clock, u8_t sca, u8_t connection_count_max,
u8_t rx_count_max, u8_t tx_count_max, u8_t rx_count_max, u8_t tx_count_max,
u16_t packet_data_octets_max, u16_t packet_data_octets_max,
u16_t packet_tx_data_size, u8_t *mem_radio, u16_t packet_tx_data_size, u8_t *mem_radio,
u16_t mem_size) u16_t mem_size)
{ {
u32_t retcode; u32_t retcode;
u8_t *mem_radio_end; u8_t *mem_radio_end;
@ -583,7 +577,7 @@ static inline void isr_radio_state_tx(void)
} }
static inline u32_t isr_rx_adv(u8_t devmatch_ok, u8_t irkmatch_ok, static inline u32_t isr_rx_adv(u8_t devmatch_ok, u8_t irkmatch_ok,
u8_t irkmatch_id, u8_t rssi_ready) u8_t irkmatch_id, u8_t rssi_ready)
{ {
struct pdu_adv *pdu_adv, *_pdu_adv; struct pdu_adv *pdu_adv, *_pdu_adv;
struct radio_pdu_node_rx *radio_pdu_node_rx; struct radio_pdu_node_rx *radio_pdu_node_rx;
@ -1173,7 +1167,7 @@ static inline u32_t isr_rx_obs(u8_t irkmatch_id, u8_t rssi_ready)
} }
static inline u8_t isr_rx_conn_pkt_ack(struct pdu_data *pdu_data_tx, static inline u8_t isr_rx_conn_pkt_ack(struct pdu_data *pdu_data_tx,
struct radio_pdu_node_tx **node_tx) struct radio_pdu_node_tx **node_tx)
{ {
u8_t terminate = 0; u8_t terminate = 0;
@ -1394,7 +1388,7 @@ isr_rx_conn_pkt_ctrl_rej(struct radio_pdu_node_rx *radio_pdu_node_rx,
#if defined(CONFIG_BLUETOOTH_CONTROLLER_DATA_LENGTH) #if defined(CONFIG_BLUETOOTH_CONTROLLER_DATA_LENGTH)
static inline u8_t isr_rx_conn_pkt_ctrl_dle(struct pdu_data *pdu_data_rx, static inline u8_t isr_rx_conn_pkt_ctrl_dle(struct pdu_data *pdu_data_rx,
u8_t *rx_enqueue) u8_t *rx_enqueue)
{ {
u16_t eff_rx_octets; u16_t eff_rx_octets;
u16_t eff_tx_octets; u16_t eff_tx_octets;
@ -2433,8 +2427,7 @@ static inline u32_t isr_close_adv(void)
radio_filter_disable(); radio_filter_disable();
pdu_adv = pdu_adv = (struct pdu_adv *)
(struct pdu_adv *)
&_radio.advertiser.adv_data.data[_radio.advertiser.adv_data.first][0]; &_radio.advertiser.adv_data.data[_radio.advertiser.adv_data.first][0];
if ((_radio.state == STATE_CLOSE) && if ((_radio.state == STATE_CLOSE) &&
(pdu_adv->type != PDU_ADV_TYPE_DIRECT_IND)) { (pdu_adv->type != PDU_ADV_TYPE_DIRECT_IND)) {
@ -3101,7 +3094,7 @@ static void mayfly_xtal_start(void *params)
} }
static void event_xtal(u32_t ticks_at_expire, u32_t remainder, static void event_xtal(u32_t ticks_at_expire, u32_t remainder,
u16_t lazy, void *context) u16_t lazy, void *context)
{ {
static void *s_link[2]; static void *s_link[2];
static struct mayfly s_mfy_xtal_start = {0, 0, s_link, NULL, static struct mayfly s_mfy_xtal_start = {0, 0, s_link, NULL,
@ -3210,9 +3203,8 @@ static void prepare_normal(u32_t status, void *op_context)
} }
} }
static void prepare_normal_set(struct shdr *hdr, static void prepare_normal_set(struct shdr *hdr, u8_t ticker_user_id,
u8_t ticker_user_id, u8_t ticker_id)
u8_t ticker_id)
{ {
if (hdr->ticks_xtal_to_start & ((u32_t)1 << 31)) { if (hdr->ticks_xtal_to_start & ((u32_t)1 << 31)) {
u32_t ticker_status; u32_t ticker_status;
@ -3237,7 +3229,7 @@ static void prepare_normal_set(struct shdr *hdr,
#if (RADIO_TICKER_PREEMPT_PART_US <= RADIO_TICKER_PREEMPT_PART_MIN_US) #if (RADIO_TICKER_PREEMPT_PART_US <= RADIO_TICKER_PREEMPT_PART_MIN_US)
static u32_t preempt_calc(struct shdr *hdr, u8_t ticker_id, static u32_t preempt_calc(struct shdr *hdr, u8_t ticker_id,
u32_t ticks_at_expire) u32_t ticks_at_expire)
{ {
u32_t diff = u32_t diff =
ticker_ticks_diff_get(ticker_ticks_now_get(), ticks_at_expire); ticker_ticks_diff_get(ticker_ticks_now_get(), ticks_at_expire);
@ -3581,11 +3573,11 @@ static void mayfly_sched_win_offset_use(void *params)
} }
static void sched_free_win_offset_calc(struct connection *conn_curr, static void sched_free_win_offset_calc(struct connection *conn_curr,
u8_t is_select, u8_t is_select,
u32_t *ticks_to_offset_next, u32_t *ticks_to_offset_next,
u16_t conn_interval, u16_t conn_interval,
u8_t *offset_max, u8_t *offset_max,
u8_t *win_offset) u8_t *win_offset)
{ {
u32_t ticks_prepare_reduced = 0; u32_t ticks_prepare_reduced = 0;
u32_t ticks_anchor; u32_t ticks_anchor;
@ -4082,9 +4074,8 @@ static u8_t chan_sel_remap(u8_t *chan_map, u8_t chan_index)
return chan_next; return chan_next;
} }
static u8_t chan_sel_1(u8_t *chan_use, u8_t hop, static u8_t chan_sel_1(u8_t *chan_use, u8_t hop, u16_t latency, u8_t *chan_map,
u16_t latency, u8_t *chan_map, u8_t chan_count)
u8_t chan_count)
{ {
u8_t chan_next; u8_t chan_next;
@ -4147,8 +4138,8 @@ static u16_t chan_prn(u16_t counter, u16_t chan_id)
return prn_e; return prn_e;
} }
static u8_t chan_sel_2(u16_t counter, u16_t chan_id, static u8_t chan_sel_2(u16_t counter, u16_t chan_id, u8_t *chan_map,
u8_t *chan_map, u8_t chan_count) u8_t chan_count)
{ {
u8_t chan_next; u8_t chan_next;
u16_t prn_e; u16_t prn_e;
@ -4443,8 +4434,8 @@ static void event_adv(u32_t ticks_at_expire, u32_t remainder,
DEBUG_RADIO_START_A(0); DEBUG_RADIO_START_A(0);
} }
void event_adv_stop(u32_t ticks_at_expire, u32_t remainder, void event_adv_stop(u32_t ticks_at_expire, u32_t remainder, u16_t lazy,
u16_t lazy, void *context) void *context)
{ {
u32_t ticker_status; u32_t ticker_status;
struct radio_pdu_node_rx *radio_pdu_node_rx; struct radio_pdu_node_rx *radio_pdu_node_rx;
@ -4553,8 +4544,8 @@ static void event_obs_prepare(u32_t ticks_at_expire, u32_t remainder,
DEBUG_RADIO_PREPARE_O(0); DEBUG_RADIO_PREPARE_O(0);
} }
static void event_obs(u32_t ticks_at_expire, u32_t remainder, static void event_obs(u32_t ticks_at_expire, u32_t remainder, u16_t lazy,
u16_t lazy, void *context) void *context)
{ {
u32_t ticker_status; u32_t ticker_status;
@ -4836,8 +4827,8 @@ static inline void event_conn_update_st_rsp(struct connection *conn,
} }
static inline u32_t event_conn_update_prep(struct connection *conn, static inline u32_t event_conn_update_prep(struct connection *conn,
u16_t event_counter, u16_t event_counter,
u32_t ticks_at_expire) u32_t ticks_at_expire)
{ {
struct connection *conn_upd; struct connection *conn_upd;
u16_t instant_latency; u16_t instant_latency;
@ -5843,8 +5834,8 @@ static void event_slave_prepare(u32_t ticks_at_expire, u32_t remainder,
DEBUG_RADIO_PREPARE_S(0); DEBUG_RADIO_PREPARE_S(0);
} }
static void event_slave(u32_t ticks_at_expire, u32_t remainder, static void event_slave(u32_t ticks_at_expire, u32_t remainder, u16_t lazy,
u16_t lazy, void *context) void *context)
{ {
u8_t data_chan_use = 0; u8_t data_chan_use = 0;
struct connection *conn; struct connection *conn;
@ -5973,8 +5964,8 @@ static void event_master_prepare(u32_t ticks_at_expire, u32_t remainder,
DEBUG_RADIO_PREPARE_M(0); DEBUG_RADIO_PREPARE_M(0);
} }
static void event_master(u32_t ticks_at_expire, u32_t remainder, static void event_master(u32_t ticks_at_expire, u32_t remainder, u16_t lazy,
u16_t lazy, void *context) void *context)
{ {
u8_t data_chan_use = 0; u8_t data_chan_use = 0;
struct pdu_data *pdu_data_tx; struct pdu_data *pdu_data_tx;
@ -6132,8 +6123,7 @@ static void rx_packet_set(struct connection *conn, struct pdu_data *pdu_data_rx)
} }
} }
static void tx_packet_set(struct connection *conn, static void tx_packet_set(struct connection *conn, struct pdu_data *pdu_data_tx)
struct pdu_data *pdu_data_tx)
{ {
u8_t phy; u8_t phy;
u16_t max_tx_octets; u16_t max_tx_octets;
@ -6658,8 +6648,7 @@ static void terminate_ind_rx_enqueue(struct connection *conn, u8_t reason)
packet_rx_callback(); packet_rx_callback();
} }
static u32_t conn_update(struct connection *conn, static u32_t conn_update(struct connection *conn, struct pdu_data *pdu_data_rx)
struct pdu_data *pdu_data_rx)
{ {
if (((pdu_data_rx->payload.llctrl.ctrldata.conn_update_ind.instant - if (((pdu_data_rx->payload.llctrl.ctrldata.conn_update_ind.instant -
conn->event_counter) & 0xFFFF) > 0x7FFF) { conn->event_counter) & 0xFFFF) > 0x7FFF) {
@ -6740,7 +6729,7 @@ static u32_t conn_update_req(struct connection *conn)
} }
static u32_t chan_map_update(struct connection *conn, static u32_t chan_map_update(struct connection *conn,
struct pdu_data *pdu_data_rx) struct pdu_data *pdu_data_rx)
{ {
if (((pdu_data_rx->payload.llctrl.ctrldata.chan_map_ind.instant - if (((pdu_data_rx->payload.llctrl.ctrldata.chan_map_ind.instant -
conn->event_counter) & 0xffff) > 0x7fff) { conn->event_counter) & 0xffff) > 0x7fff) {
@ -7236,8 +7225,7 @@ static inline void role_active_disable(u8_t ticker_id_stop,
} }
} }
static u32_t role_disable(u8_t ticker_id_primary, static u32_t role_disable(u8_t ticker_id_primary, u8_t ticker_id_stop)
u8_t ticker_id_stop)
{ {
u32_t volatile ret_cb = TICKER_STATUS_BUSY; u32_t volatile ret_cb = TICKER_STATUS_BUSY;
u32_t ticks_active_to_start = 0; u32_t ticks_active_to_start = 0;
@ -7324,8 +7312,7 @@ role_disable_cleanup:
return ret_cb; return ret_cb;
} }
u32_t radio_adv_enable(u16_t interval, u8_t chl_map, u32_t radio_adv_enable(u16_t interval, u8_t chl_map, u8_t filter_policy)
u8_t filter_policy)
{ {
u32_t volatile ret_cb = TICKER_STATUS_BUSY; u32_t volatile ret_cb = TICKER_STATUS_BUSY;
u32_t ticks_slot_offset; u32_t ticks_slot_offset;
@ -7543,9 +7530,8 @@ u32_t radio_adv_disable(void)
return status; return status;
} }
u32_t radio_scan_enable(u8_t scan_type, u8_t init_addr_type, u32_t radio_scan_enable(u8_t scan_type, u8_t init_addr_type, u8_t *init_addr,
u8_t *init_addr, u16_t interval, u16_t interval, u16_t window, u8_t filter_policy)
u16_t window, u8_t filter_policy)
{ {
u32_t volatile ret_cb = TICKER_STATUS_BUSY; u32_t volatile ret_cb = TICKER_STATUS_BUSY;
u32_t ticks_slot_offset; u32_t ticks_slot_offset;
@ -7652,9 +7638,8 @@ u32_t radio_scan_disable(void)
return status; return status;
} }
u32_t radio_connect_enable(u8_t adv_addr_type, u8_t *adv_addr, u32_t radio_connect_enable(u8_t adv_addr_type, u8_t *adv_addr, u16_t interval,
u16_t interval, u16_t latency, u16_t latency, u16_t timeout)
u16_t timeout)
{ {
void *link; void *link;
struct connection *conn; struct connection *conn;
@ -7791,9 +7776,8 @@ u32_t ll_connect_disable(void)
return status; return status;
} }
u32_t ll_conn_update(u16_t handle, u8_t cmd, u8_t status, u32_t ll_conn_update(u16_t handle, u8_t cmd, u8_t status, u16_t interval,
u16_t interval, u16_t latency, u16_t latency, u16_t timeout)
u16_t timeout)
{ {
struct connection *conn; struct connection *conn;
@ -7878,8 +7862,7 @@ u32_t ll_chm_get(u16_t handle, u8_t *chm)
return 0; return 0;
} }
u32_t ll_enc_req_send(u16_t handle, u8_t *rand, u8_t *ediv, u32_t ll_enc_req_send(u16_t handle, u8_t *rand, u8_t *ediv, u8_t *ltk)
u8_t *ltk)
{ {
struct connection *conn; struct connection *conn;
struct radio_pdu_node_tx *node_tx; struct radio_pdu_node_tx *node_tx;
@ -7954,7 +7937,7 @@ u32_t ll_enc_req_send(u16_t handle, u8_t *rand, u8_t *ediv,
} }
u32_t ll_start_enc_req_send(u16_t handle, u8_t error_code, u32_t ll_start_enc_req_send(u16_t handle, u8_t error_code,
u8_t const *const ltk) u8_t const *const ltk)
{ {
struct connection *conn; struct connection *conn;
@ -8148,8 +8131,7 @@ static u8_t tx_cmplt_get(u16_t *handle, u8_t *first, u8_t last)
return cmplt; return cmplt;
} }
u8_t radio_rx_get(struct radio_pdu_node_rx **radio_pdu_node_rx, u8_t radio_rx_get(struct radio_pdu_node_rx **radio_pdu_node_rx, u16_t *handle)
u16_t *handle)
{ {
u8_t cmplt; u8_t cmplt;
@ -8316,8 +8298,7 @@ static void rx_fc_lock(u16_t handle)
} }
} }
u8_t do_radio_rx_fc_set(u16_t handle, u8_t req, u8_t do_radio_rx_fc_set(u16_t handle, u8_t req, u8_t ack)
u8_t ack)
{ {
if (req == ack) { if (req == ack) {
if (_radio.link_rx_head == _radio.link_rx_tail) { if (_radio.link_rx_head == _radio.link_rx_tail) {
@ -8397,8 +8378,7 @@ void radio_tx_mem_release(struct radio_pdu_node_tx *node_tx)
mem_release(node_tx, &_radio.pkt_tx_data_free); mem_release(node_tx, &_radio.pkt_tx_data_free);
} }
static void ticker_op_latency_cancelled(u32_t ticker_status, static void ticker_op_latency_cancelled(u32_t ticker_status, void *params)
void *params)
{ {
struct connection *conn; struct connection *conn;
@ -8408,8 +8388,7 @@ static void ticker_op_latency_cancelled(u32_t ticker_status,
conn->role.slave.latency_cancel = 0; conn->role.slave.latency_cancel = 0;
} }
u32_t radio_tx_mem_enqueue(u16_t handle, u32_t radio_tx_mem_enqueue(u16_t handle, struct radio_pdu_node_tx *node_tx)
struct radio_pdu_node_tx *node_tx)
{ {
u8_t last; u8_t last;
struct connection *conn; struct connection *conn;

42
subsys/bluetooth/controller/ll_sw/ctrl.h
View file

@ -224,21 +224,21 @@ enum radio_pdu_node_rx_type {
}; };
struct radio_le_conn_cmplt { struct radio_le_conn_cmplt {
u8_t status; u8_t status;
u8_t role; u8_t role;
u8_t peer_addr_type; u8_t peer_addr_type;
u8_t peer_addr[BDADDR_SIZE]; u8_t peer_addr[BDADDR_SIZE];
u8_t own_addr_type; u8_t own_addr_type;
u8_t own_addr[BDADDR_SIZE]; u8_t own_addr[BDADDR_SIZE];
u8_t peer_irk_index; u8_t peer_irk_index;
u16_t interval; u16_t interval;
u16_t latency; u16_t latency;
u16_t timeout; u16_t timeout;
u8_t mca; u8_t mca;
} __packed; } __packed;
struct radio_le_conn_update_cmplt { struct radio_le_conn_update_cmplt {
u8_t status; u8_t status;
u16_t interval; u16_t interval;
u16_t latency; u16_t latency;
u16_t timeout; u16_t timeout;
@ -261,7 +261,7 @@ struct radio_pdu_node_rx_hdr {
struct radio_pdu_node_rx { struct radio_pdu_node_rx {
struct radio_pdu_node_rx_hdr hdr; struct radio_pdu_node_rx_hdr hdr;
u8_t pdu_data[1]; u8_t pdu_data[1];
}; };
/***************************************************************************** /*****************************************************************************
@ -269,27 +269,27 @@ struct radio_pdu_node_rx {
****************************************************************************/ ****************************************************************************/
/* Downstream */ /* Downstream */
u32_t radio_init(void *hf_clock, u8_t sca, u8_t connection_count_max, u32_t radio_init(void *hf_clock, u8_t sca, u8_t connection_count_max,
u8_t rx_count_max, u8_t tx_count_max, u8_t rx_count_max, u8_t tx_count_max,
u16_t packet_data_octets_max, u16_t packet_data_octets_max,
u16_t packet_tx_data_size, u8_t *mem_radio, u16_t packet_tx_data_size, u8_t *mem_radio,
u16_t mem_size); u16_t mem_size);
void radio_ticks_active_to_start_set(u32_t ticks_active_to_start); void radio_ticks_active_to_start_set(u32_t ticks_active_to_start);
struct radio_adv_data *radio_adv_data_get(void); struct radio_adv_data *radio_adv_data_get(void);
struct radio_adv_data *radio_scan_data_get(void); struct radio_adv_data *radio_scan_data_get(void);
u32_t radio_adv_enable(u16_t interval, u8_t chl_map, u32_t radio_adv_enable(u16_t interval, u8_t chl_map,
u8_t filter_policy); u8_t filter_policy);
u32_t radio_adv_disable(void); u32_t radio_adv_disable(void);
u32_t radio_scan_enable(u8_t scan_type, u8_t init_addr_type, u32_t radio_scan_enable(u8_t scan_type, u8_t init_addr_type,
u8_t *init_addr, u16_t interval, u8_t *init_addr, u16_t interval,
u16_t window, u8_t filter_policy); u16_t window, u8_t filter_policy);
u32_t radio_scan_disable(void); u32_t radio_scan_disable(void);
u32_t radio_connect_enable(u8_t adv_addr_type, u8_t *adv_addr, u32_t radio_connect_enable(u8_t adv_addr_type, u8_t *adv_addr,
u16_t interval, u16_t latency, u16_t interval, u16_t latency,
u16_t timeout); u16_t timeout);
/* Upstream */ /* Upstream */
u8_t radio_rx_get(struct radio_pdu_node_rx **radio_pdu_node_rx, u8_t radio_rx_get(struct radio_pdu_node_rx **radio_pdu_node_rx,
u16_t *handle); u16_t *handle);
void radio_rx_dequeue(void); void radio_rx_dequeue(void);
void radio_rx_mem_release(struct radio_pdu_node_rx **radio_pdu_node_rx); void radio_rx_mem_release(struct radio_pdu_node_rx **radio_pdu_node_rx);
u8_t radio_rx_fc_set(u16_t handle, u8_t fc); u8_t radio_rx_fc_set(u16_t handle, u8_t fc);
@ -297,7 +297,7 @@ u8_t radio_rx_fc_get(u16_t *handle);
struct radio_pdu_node_tx *radio_tx_mem_acquire(void); struct radio_pdu_node_tx *radio_tx_mem_acquire(void);
void radio_tx_mem_release(struct radio_pdu_node_tx *pdu_data_node_tx); void radio_tx_mem_release(struct radio_pdu_node_tx *pdu_data_node_tx);
u32_t radio_tx_mem_enqueue(u16_t handle, u32_t radio_tx_mem_enqueue(u16_t handle,
struct radio_pdu_node_tx *pdu_data_node_tx); struct radio_pdu_node_tx *pdu_data_node_tx);
/* Callbacks */ /* Callbacks */
extern void radio_active_callback(u8_t active); extern void radio_active_callback(u8_t active);
extern void radio_event_callback(void); extern void radio_event_callback(void);

98
subsys/bluetooth/controller/ll_sw/ctrl_internal.h
View file

@ -30,13 +30,13 @@ struct shdr {
struct connection { struct connection {
struct shdr hdr; struct shdr hdr;
u8_t access_addr[4]; u8_t access_addr[4];
u8_t crc_init[3]; u8_t crc_init[3];
u8_t data_chan_map[5]; u8_t data_chan_map[5];
u8_t data_chan_count:6; u8_t data_chan_count:6;
u8_t data_chan_sel:1; u8_t data_chan_sel:1;
u8_t rfu:1; u8_t rfu:1;
union { union {
struct { struct {
@ -74,13 +74,13 @@ struct connection {
union { union {
struct { struct {
u8_t role:1; u8_t role:1;
u8_t connect_expire; u8_t connect_expire;
} master; } master;
struct { struct {
u8_t role:1; u8_t role:1;
u8_t sca:3; u8_t sca:3;
u8_t latency_cancel:1; u8_t latency_cancel:1;
u32_t window_widening_periodic_us; u32_t window_widening_periodic_us;
u32_t window_widening_max_us; u32_t window_widening_max_us;
u32_t window_widening_prepare_us; u32_t window_widening_prepare_us;
@ -92,15 +92,15 @@ struct connection {
} slave; } slave;
} role; } role;
u8_t llcp_req; u8_t llcp_req;
u8_t llcp_ack; u8_t llcp_ack;
enum llcp llcp_type; enum llcp llcp_type;
union { union {
struct { struct {
u16_t interval; u16_t interval;
u16_t latency; u16_t latency;
u16_t timeout; u16_t timeout;
u8_t preferred_periodicity; u8_t preferred_periodicity;
u16_t instant; u16_t instant;
u16_t offset0; u16_t offset0;
u16_t offset1; u16_t offset1;
@ -112,8 +112,8 @@ struct connection {
u32_t ticks_to_offset_next; u32_t ticks_to_offset_next;
u32_t win_offset_us; u32_t win_offset_us;
u16_t *pdu_win_offset; u16_t *pdu_win_offset;
u8_t win_size; u8_t win_size;
u8_t state:3; u8_t state:3;
#define LLCP_CONN_STATE_INPROG 0 /* master + slave proc in progress #define LLCP_CONN_STATE_INPROG 0 /* master + slave proc in progress
* until instant * until instant
*/ */
@ -124,37 +124,37 @@ struct connection {
#define LLCP_CONN_STATE_RSP_WAIT 5 /* master rsp or slave conn_update #define LLCP_CONN_STATE_RSP_WAIT 5 /* master rsp or slave conn_update
* or rej * or rej
*/ */
u8_t is_internal:2; u8_t is_internal:2;
} connection_update; } connection_update;
struct { struct {
u8_t initiate; u8_t initiate;
u8_t chm[5]; u8_t chm[5];
u16_t instant; u16_t instant;
} chan_map; } chan_map;
struct { struct {
u8_t error_code; u8_t error_code;
u8_t rand[8]; u8_t rand[8];
u8_t ediv[2]; u8_t ediv[2];
u8_t ltk[16]; u8_t ltk[16];
u8_t skd[16]; u8_t skd[16];
} encryption; } encryption;
} llcp; } llcp;
u32_t llcp_features; u32_t llcp_features;
struct { struct {
u8_t tx:1; u8_t tx:1;
u8_t rx:1; u8_t rx:1;
u8_t version_number; u8_t version_number;
u16_t company_id; u16_t company_id;
u16_t sub_version_number; u16_t sub_version_number;
} llcp_version; } llcp_version;
struct { struct {
u8_t req; u8_t req;
u8_t ack; u8_t ack;
u8_t reason_own; u8_t reason_own;
u8_t reason_peer; u8_t reason_peer;
struct { struct {
struct radio_pdu_node_rx_hdr hdr; struct radio_pdu_node_rx_hdr hdr;
u8_t reason; u8_t reason;
@ -163,9 +163,9 @@ struct connection {
#if defined(CONFIG_BLUETOOTH_CONTROLLER_DATA_LENGTH) #if defined(CONFIG_BLUETOOTH_CONTROLLER_DATA_LENGTH)
struct { struct {
u8_t req; u8_t req;
u8_t ack; u8_t ack;
u8_t state:2; u8_t state:2;
#define LLCP_LENGTH_STATE_REQ 0 #define LLCP_LENGTH_STATE_REQ 0
#define LLCP_LENGTH_STATE_ACK_WAIT 1 #define LLCP_LENGTH_STATE_ACK_WAIT 1
#define LLCP_LENGTH_STATE_RSP_WAIT 2 #define LLCP_LENGTH_STATE_RSP_WAIT 2
@ -175,14 +175,14 @@ struct connection {
} llcp_length; } llcp_length;
#endif /* CONFIG_BLUETOOTH_CONTROLLER_DATA_LENGTH */ #endif /* CONFIG_BLUETOOTH_CONTROLLER_DATA_LENGTH */
u8_t sn:1; u8_t sn:1;
u8_t nesn:1; u8_t nesn:1;
u8_t pause_rx:1; u8_t pause_rx:1;
u8_t pause_tx:1; u8_t pause_tx:1;
u8_t enc_rx:1; u8_t enc_rx:1;
u8_t enc_tx:1; u8_t enc_tx:1;
u8_t refresh:1; u8_t refresh:1;
u8_t empty:1; u8_t empty:1;
struct ccm ccm_rx; struct ccm ccm_rx;
struct ccm ccm_tx; struct ccm ccm_tx;
@ -191,19 +191,19 @@ struct connection {
struct radio_pdu_node_tx *pkt_tx_ctrl; struct radio_pdu_node_tx *pkt_tx_ctrl;
struct radio_pdu_node_tx *pkt_tx_data; struct radio_pdu_node_tx *pkt_tx_data;
struct radio_pdu_node_tx *pkt_tx_last; struct radio_pdu_node_tx *pkt_tx_last;
u8_t packet_tx_head_len; u8_t packet_tx_head_len;
u8_t packet_tx_head_offset; u8_t packet_tx_head_offset;
#if defined(CONFIG_BLUETOOTH_CONTROLLER_CONN_RSSI) #if defined(CONFIG_BLUETOOTH_CONTROLLER_CONN_RSSI)
u8_t rssi_latest; u8_t rssi_latest;
u8_t rssi_reported; u8_t rssi_reported;
u8_t rssi_sample_count; u8_t rssi_sample_count;
#endif /* CONFIG_BLUETOOTH_CONTROLLER_CONN_RSSI */ #endif /* CONFIG_BLUETOOTH_CONTROLLER_CONN_RSSI */
}; };
#define CONNECTION_T_SIZE MROUND(sizeof(struct connection)) #define CONNECTION_T_SIZE MROUND(sizeof(struct connection))
struct pdu_data_q_tx { struct pdu_data_q_tx {
u16_t handle; u16_t handle;
struct radio_pdu_node_tx *node_tx; struct radio_pdu_node_tx *node_tx;
}; };

70
subsys/bluetooth/controller/ll_sw/ll.c
View file

@ -54,21 +54,21 @@ static struct {
static struct { static struct {
u16_t interval; u16_t interval;
u8_t adv_type:4; u8_t adv_type:4;
u8_t tx_addr:1; u8_t tx_addr:1;
u8_t rx_addr:1; u8_t rx_addr:1;
u8_t filter_policy:2; u8_t filter_policy:2;
u8_t chl_map:3; u8_t chl_map:3;
u8_t adv_addr[BDADDR_SIZE]; u8_t adv_addr[BDADDR_SIZE];
u8_t direct_addr[BDADDR_SIZE]; u8_t direct_addr[BDADDR_SIZE];
} _ll_adv_params; } _ll_adv_params;
static struct { static struct {
u16_t interval; u16_t interval;
u16_t window; u16_t window;
u8_t scan_type:1; u8_t scan_type:1;
u8_t tx_addr:1; u8_t tx_addr:1;
u8_t filter_policy:1; u8_t filter_policy:1;
} _ll_scan_params; } _ll_scan_params;
void mayfly_enable_cb(u8_t caller_id, u8_t callee_id, u8_t enable) void mayfly_enable_cb(u8_t caller_id, u8_t callee_id, u8_t enable)
@ -405,8 +405,8 @@ void ll_scan_data_set(u8_t len, u8_t const *const data)
pdu->tx_addr = _ll_adv_params.tx_addr; pdu->tx_addr = _ll_adv_params.tx_addr;
pdu->rx_addr = 0; pdu->rx_addr = 0;
pdu->len = BDADDR_SIZE + len; pdu->len = BDADDR_SIZE + len;
memcpy(&pdu->payload.scan_rsp.addr[0], memcpy(&pdu->payload.scan_rsp.addr[0], &_ll_adv_params.adv_addr[0],
&_ll_adv_params.adv_addr[0], BDADDR_SIZE); BDADDR_SIZE);
memcpy(&pdu->payload.scan_rsp.data[0], data, len); memcpy(&pdu->payload.scan_rsp.data[0], data, len);
pdu->resv = 0; pdu->resv = 0;
@ -440,23 +440,23 @@ u32_t ll_adv_enable(u8_t enable)
[radio_scan_data->last][0]; [radio_scan_data->last][0];
if (_ll_adv_params.tx_addr) { if (_ll_adv_params.tx_addr) {
memcpy(&_ll_adv_params.adv_addr[0], memcpy(&_ll_adv_params.adv_addr[0],
&_ll_context.rnd_addr[0], BDADDR_SIZE); &_ll_context.rnd_addr[0], BDADDR_SIZE);
memcpy(&pdu_adv->payload.adv_ind.addr[0], memcpy(&pdu_adv->payload.adv_ind.addr[0],
&_ll_context.rnd_addr[0], BDADDR_SIZE); &_ll_context.rnd_addr[0], BDADDR_SIZE);
memcpy(&pdu_scan->payload.scan_rsp.addr[0], memcpy(&pdu_scan->payload.scan_rsp.addr[0],
&_ll_context.rnd_addr[0], BDADDR_SIZE); &_ll_context.rnd_addr[0], BDADDR_SIZE);
} else { } else {
memcpy(&_ll_adv_params.adv_addr[0], memcpy(&_ll_adv_params.adv_addr[0],
&_ll_context.pub_addr[0], BDADDR_SIZE); &_ll_context.pub_addr[0], BDADDR_SIZE);
memcpy(&pdu_adv->payload.adv_ind.addr[0], memcpy(&pdu_adv->payload.adv_ind.addr[0],
&_ll_context.pub_addr[0], BDADDR_SIZE); &_ll_context.pub_addr[0], BDADDR_SIZE);
memcpy(&pdu_scan->payload.scan_rsp.addr[0], memcpy(&pdu_scan->payload.scan_rsp.addr[0],
&_ll_context.pub_addr[0], BDADDR_SIZE); &_ll_context.pub_addr[0], BDADDR_SIZE);
} }
status = radio_adv_enable(_ll_adv_params.interval, status = radio_adv_enable(_ll_adv_params.interval,
_ll_adv_params.chl_map, _ll_adv_params.chl_map,
_ll_adv_params.filter_policy); _ll_adv_params.filter_policy);
} else { } else {
status = radio_adv_disable(); status = radio_adv_disable();
} }
@ -480,13 +480,13 @@ u32_t ll_scan_enable(u8_t enable)
if (enable) { if (enable) {
status = radio_scan_enable(_ll_scan_params.scan_type, status = radio_scan_enable(_ll_scan_params.scan_type,
_ll_scan_params.tx_addr, _ll_scan_params.tx_addr,
(_ll_scan_params.tx_addr) ? (_ll_scan_params.tx_addr) ?
&_ll_context.rnd_addr[0] : &_ll_context.rnd_addr[0] :
&_ll_context.pub_addr[0], &_ll_context.pub_addr[0],
_ll_scan_params.interval, _ll_scan_params.interval,
_ll_scan_params.window, _ll_scan_params.window,
_ll_scan_params.filter_policy); _ll_scan_params.filter_policy);
} else { } else {
status = radio_scan_disable(); status = radio_scan_disable();
} }
@ -495,22 +495,22 @@ u32_t ll_scan_enable(u8_t enable)
} }
u32_t ll_create_connection(u16_t scan_interval, u16_t scan_window, u32_t ll_create_connection(u16_t scan_interval, u16_t scan_window,
u8_t filter_policy, u8_t peer_addr_type, u8_t filter_policy, u8_t peer_addr_type,
u8_t *peer_addr, u8_t own_addr_type, u8_t *peer_addr, u8_t own_addr_type,
u16_t interval, u16_t latency, u16_t interval, u16_t latency,
u16_t timeout) u16_t timeout)
{ {
u32_t status; u32_t status;
status = radio_connect_enable(peer_addr_type, peer_addr, interval, status = radio_connect_enable(peer_addr_type, peer_addr, interval,
latency, timeout); latency, timeout);
if (status) { if (status) {
return status; return status;
} }
return radio_scan_enable(0, own_addr_type, (own_addr_type) ? return radio_scan_enable(0, own_addr_type, (own_addr_type) ?
&_ll_context.rnd_addr[0] : &_ll_context.rnd_addr[0] :
&_ll_context.pub_addr[0], &_ll_context.pub_addr[0],
scan_interval, scan_window, filter_policy); scan_interval, scan_window, filter_policy);
} }

26
subsys/bluetooth/controller/ll_sw/pdu.h
View file

@ -39,16 +39,16 @@ struct pdu_adv_payload_connect_ind {
u8_t init_addr[BDADDR_SIZE]; u8_t init_addr[BDADDR_SIZE];
u8_t adv_addr[BDADDR_SIZE]; u8_t adv_addr[BDADDR_SIZE];
struct { struct {
u8_t access_addr[4]; u8_t access_addr[4];
u8_t crc_init[3]; u8_t crc_init[3];
u8_t win_size; u8_t win_size;
u16_t win_offset; u16_t win_offset;
u16_t interval; u16_t interval;
u16_t latency; u16_t latency;
u16_t timeout; u16_t timeout;
u8_t chan_map[5]; u8_t chan_map[5];
u8_t hop:5; u8_t hop:5;
u8_t sca:3; u8_t sca:3;
} __packed lldata; } __packed lldata;
} __packed; } __packed;
@ -127,7 +127,7 @@ enum pdu_data_llctrl_type {
}; };
struct pdu_data_llctrl_conn_update_ind { struct pdu_data_llctrl_conn_update_ind {
u8_t win_size; u8_t win_size;
u16_t win_offset; u16_t win_offset;
u16_t interval; u16_t interval;
u16_t latency; u16_t latency;
@ -136,7 +136,7 @@ struct pdu_data_llctrl_conn_update_ind {
} __packed; } __packed;
struct pdu_data_llctrl_chan_map_ind { struct pdu_data_llctrl_chan_map_ind {
u8_t chm[5]; u8_t chm[5];
u16_t instant; u16_t instant;
} __packed; } __packed;
@ -169,7 +169,7 @@ struct pdu_data_llctrl_feature_rsp {
} __packed; } __packed;
struct pdu_data_llctrl_version_ind { struct pdu_data_llctrl_version_ind {
u8_t version_number; u8_t version_number;
u16_t company_id; u16_t company_id;
u16_t sub_version_number; u16_t sub_version_number;
} __packed; } __packed;
@ -183,7 +183,7 @@ struct pdu_data_llctrl_conn_param_req {
u16_t interval_max; u16_t interval_max;
u16_t latency; u16_t latency;
u16_t timeout; u16_t timeout;
u8_t preferred_periodicity; u8_t preferred_periodicity;
u16_t reference_conn_event_count; u16_t reference_conn_event_count;
u16_t offset0; u16_t offset0;
u16_t offset1; u16_t offset1;
@ -198,7 +198,7 @@ struct pdu_data_llctrl_conn_param_rsp {
u16_t interval_max; u16_t interval_max;
u16_t latency; u16_t latency;
u16_t timeout; u16_t timeout;
u8_t preferred_periodicity; u8_t preferred_periodicity;
u16_t reference_conn_event_count; u16_t reference_conn_event_count;
u16_t offset0; u16_t offset0;
u16_t offset1; u16_t offset1;
@ -226,8 +226,8 @@ struct pdu_data_llctrl_phy_req_rsp {
} __packed; } __packed;
struct pdu_data_llctrl_phy_update_ind { struct pdu_data_llctrl_phy_update_ind {
u8_t m_to_s_phy; u8_t m_to_s_phy;
u8_t s_to_m_phy; u8_t s_to_m_phy;
u16_t instant; u16_t instant;
} __packed; } __packed;

132
subsys/bluetooth/controller/ticker/ticker.c
View file

@ -29,15 +29,15 @@
* Types * Types
****************************************************************************/ ****************************************************************************/
struct ticker_node { struct ticker_node {
u8_t next; u8_t next;
u8_t req; u8_t req;
u8_t ack; u8_t ack;
u8_t force; u8_t force;
u32_t ticks_periodic; u32_t ticks_periodic;
u32_t ticks_to_expire; u32_t ticks_to_expire;
ticker_timeout_func timeout_func; ticker_timeout_func timeout_func;
void *context; void *context;
u16_t ticks_to_expire_minus; u16_t ticks_to_expire_minus;
u16_t ticks_slot; u16_t ticks_slot;
@ -64,7 +64,7 @@ struct ticker_user_op_start {
u16_t lazy; u16_t lazy;
u16_t ticks_slot; u16_t ticks_slot;
ticker_timeout_func fp_timeout_func; ticker_timeout_func fp_timeout_func;
void *context; void *context;
}; };
struct ticker_user_op_update { struct ticker_user_op_update {
@ -73,11 +73,11 @@ struct ticker_user_op_update {
u16_t ticks_slot_plus; u16_t ticks_slot_plus;
u16_t ticks_slot_minus; u16_t ticks_slot_minus;
u16_t lazy; u16_t lazy;
u8_t force; u8_t force;
}; };
struct ticker_user_op_slot_get { struct ticker_user_op_slot_get {
u8_t *ticker_id; u8_t *ticker_id;
u32_t *ticks_current; u32_t *ticks_current;
u32_t *ticks_to_expire; u32_t *ticks_to_expire;
}; };
@ -92,7 +92,7 @@ struct ticker_user_op {
} params; } params;
u32_t status; u32_t status;
ticker_op_func fp_op_func; ticker_op_func fp_op_func;
void *op_context; void *op_context;
}; };
struct ticker_user { struct ticker_user {
@ -106,20 +106,20 @@ struct ticker_user {
struct ticker_instance { struct ticker_instance {
struct ticker_node *node; struct ticker_node *node;
struct ticker_user *user; struct ticker_user *user;
u8_t count_node; u8_t count_node;
u8_t count_user; u8_t count_user;
u8_t ticks_elapsed_first; u8_t ticks_elapsed_first;
u8_t ticks_elapsed_last; u8_t ticks_elapsed_last;
u32_t ticks_elapsed[DOUBLE_BUFFER_SIZE]; u32_t ticks_elapsed[DOUBLE_BUFFER_SIZE];
u32_t ticks_current; u32_t ticks_current;
u8_t ticker_id_head; u8_t ticker_id_head;
u8_t ticker_id_slot_previous; u8_t ticker_id_slot_previous;
u16_t ticks_slot_previous; u16_t ticks_slot_previous;
u8_t job_guard; u8_t job_guard;
u8_t worker_trigger; u8_t worker_trigger;
u8_t (*fp_caller_id_get)(u8_t user_id); u8_t (*fp_caller_id_get)(u8_t user_id);
void (*fp_sched)(u8_t caller_id, u8_t callee_id, u8_t chain); void (*fp_sched)(u8_t caller_id, u8_t callee_id, u8_t chain);
void (*fp_cmp_set)(u32_t value); void (*fp_cmp_set)(u32_t value);
}; };
/***************************************************************************** /*****************************************************************************
@ -130,9 +130,8 @@ static struct ticker_instance _instance[2];
/***************************************************************************** /*****************************************************************************
* Static Functions * Static Functions
****************************************************************************/ ****************************************************************************/
static u8_t ticker_by_slot_get(struct ticker_node *node, static u8_t ticker_by_slot_get(struct ticker_node *node, u8_t ticker_id_head,
u8_t ticker_id_head, u32_t ticks_slot)
u32_t ticks_slot)
{ {
while (ticker_id_head != TICKER_NULL) { while (ticker_id_head != TICKER_NULL) {
struct ticker_node *ticker; struct ticker_node *ticker;
@ -157,9 +156,8 @@ static u8_t ticker_by_slot_get(struct ticker_node *node,
} }
static void ticker_by_next_slot_get(struct ticker_instance *instance, static void ticker_by_next_slot_get(struct ticker_instance *instance,
u8_t *ticker_id_head, u8_t *ticker_id_head, u32_t *ticks_current,
u32_t *ticks_current, u32_t *ticks_to_expire)
u32_t *ticks_to_expire)
{ {
struct ticker_node *node; struct ticker_node *node;
u8_t _ticker_id_head; u8_t _ticker_id_head;
@ -195,8 +193,7 @@ static void ticker_by_next_slot_get(struct ticker_instance *instance,
*ticks_to_expire = _ticks_to_expire; *ticks_to_expire = _ticks_to_expire;
} }
static u8_t ticker_enqueue(struct ticker_instance *instance, static u8_t ticker_enqueue(struct ticker_instance *instance, u8_t id)
u8_t id)
{ {
struct ticker_node *node; struct ticker_node *node;
struct ticker_node *ticker_new; struct ticker_node *ticker_new;
@ -269,8 +266,7 @@ static u8_t ticker_enqueue(struct ticker_instance *instance,
return id; return id;
} }
static u32_t ticker_dequeue(struct ticker_instance *instance, static u32_t ticker_dequeue(struct ticker_instance *instance, u8_t id)
u8_t id)
{ {
struct ticker_node *ticker_current; struct ticker_node *ticker_current;
struct ticker_node *node; struct ticker_node *node;
@ -418,8 +414,7 @@ static inline void ticker_worker(struct ticker_instance *instance)
} }
static void prepare_ticks_to_expire(struct ticker_node *ticker, static void prepare_ticks_to_expire(struct ticker_node *ticker,
u32_t ticks_current, u32_t ticks_current, u32_t ticks_at_start)
u32_t ticks_at_start)
{ {
u32_t ticks_to_expire = ticker->ticks_to_expire; u32_t ticks_to_expire = ticker->ticks_to_expire;
u16_t ticks_to_expire_minus = ticker->ticks_to_expire_minus; u16_t ticks_to_expire_minus = ticker->ticks_to_expire_minus;
@ -481,10 +476,10 @@ static u8_t ticker_remainder_decrement(struct ticker_node *ticker)
} }
static inline void ticker_job_node_update(struct ticker_node *ticker, static inline void ticker_job_node_update(struct ticker_node *ticker,
struct ticker_user_op *user_op, struct ticker_user_op *user_op,
u32_t ticks_current, u32_t ticks_current,
u32_t ticks_elapsed, u32_t ticks_elapsed,
u8_t *insert_head) u8_t *insert_head)
{ {
u32_t ticks_now; u32_t ticks_now;
u32_t ticks_to_expire = ticker->ticks_to_expire; u32_t ticks_to_expire = ticker->ticks_to_expire;
@ -545,10 +540,9 @@ static inline void ticker_job_node_update(struct ticker_node *ticker,
*insert_head = user_op->id; *insert_head = user_op->id;
} }
static inline u8_t ticker_job_list_manage( static inline u8_t ticker_job_list_manage(struct ticker_instance *instance,
struct ticker_instance *instance, u32_t ticks_elapsed,
u32_t ticks_elapsed, u8_t *insert_head)
u8_t *insert_head)
{ {
u8_t pending; u8_t pending;
struct ticker_node *node; struct ticker_node *node;
@ -778,9 +772,8 @@ static inline void ticker_job_worker_bottom_half(
} }
} }
static inline void ticker_job_list_insert( static inline void ticker_job_list_insert(struct ticker_instance *instance,
struct ticker_instance *instance, u8_t insert_head)
u8_t insert_head)
{ {
struct ticker_node *node; struct ticker_node *node;
struct ticker_user *users; struct ticker_user *users;
@ -936,8 +929,7 @@ static inline void ticker_job_list_insert(
} }
} }
static inline void ticker_job_list_inquire( static inline void ticker_job_list_inquire(struct ticker_instance *instance)
struct ticker_instance *instance)
{ {
struct ticker_user *users; struct ticker_user *users;
u8_t count_user; u8_t count_user;
@ -1002,9 +994,8 @@ static inline void ticker_job_list_inquire(
} }
} }
static inline void ticker_job_compare_update( static inline void ticker_job_compare_update(struct ticker_instance *instance,
struct ticker_instance *instance, u8_t ticker_id_old_head)
u8_t ticker_id_old_head)
{ {
struct ticker_node *ticker; struct ticker_node *ticker;
struct ticker_node *node; struct ticker_node *node;
@ -1218,8 +1209,7 @@ static u8_t ticker_instance1_caller_id_get(u8_t user_id)
return 0; return 0;
} }
static void ticker_instance0_sched(u8_t caller_id, u8_t callee_id, static void ticker_instance0_sched(u8_t caller_id, u8_t callee_id, u8_t chain)
u8_t chain)
{ {
/* return value not checked as we allow multiple calls to schedule /* return value not checked as we allow multiple calls to schedule
* before being actually needing the work to complete before new * before being actually needing the work to complete before new
@ -1345,8 +1335,7 @@ static void ticker_instance0_sched(u8_t caller_id, u8_t callee_id,
} }
} }
static void ticker_instance1_sched(u8_t caller_id, u8_t callee_id, static void ticker_instance1_sched(u8_t caller_id, u8_t callee_id, u8_t chain)
u8_t chain)
{ {
/* return value not checked as we allow multiple calls to schedule /* return value not checked as we allow multiple calls to schedule
* before being actually needing the work to complete before new * before being actually needing the work to complete before new
@ -1486,8 +1475,7 @@ static void ticker_instance1_cmp_set(u32_t value)
* Public Interface * Public Interface
****************************************************************************/ ****************************************************************************/
u32_t ticker_init(u8_t instance_index, u8_t count_node, void *node, u32_t ticker_init(u8_t instance_index, u8_t count_node, void *node,
u8_t count_user, void *user, u8_t count_op, u8_t count_user, void *user, u8_t count_op, void *user_op)
void *user_op)
{ {
struct ticker_instance *instance = &_instance[instance_index]; struct ticker_instance *instance = &_instance[instance_index];
struct ticker_user *users; struct ticker_user *users;
@ -1559,13 +1547,11 @@ void ticker_trigger(u8_t instance_index)
DEBUG_TICKER_ISR(0); DEBUG_TICKER_ISR(0);
} }
u32_t ticker_start(u8_t instance_index, u8_t user_id, u32_t ticker_start(u8_t instance_index, u8_t user_id, u8_t _ticker_id,
u8_t _ticker_id, u32_t ticks_anchor, u32_t ticks_anchor, u32_t ticks_first, u32_t ticks_periodic,
u32_t ticks_first, u32_t ticks_periodic, u32_t remainder_periodic, u16_t lazy, u16_t ticks_slot,
u32_t remainder_periodic, u16_t lazy, ticker_timeout_func ticker_timeout_func, void *context,
u16_t ticks_slot, ticker_op_func fp_op_func, void *op_context)
ticker_timeout_func ticker_timeout_func, void *context,
ticker_op_func fp_op_func, void *op_context)
{ {
u8_t last; u8_t last;
struct ticker_instance *instance = &_instance[instance_index]; struct ticker_instance *instance = &_instance[instance_index];
@ -1605,11 +1591,10 @@ u32_t ticker_start(u8_t instance_index, u8_t user_id,
return user_op->status; return user_op->status;
} }
u32_t ticker_update(u8_t instance_index, u8_t user_id, u32_t ticker_update(u8_t instance_index, u8_t user_id, u8_t _ticker_id,
u8_t _ticker_id, u16_t ticks_drift_plus, u16_t ticks_drift_plus, u16_t ticks_drift_minus,
u16_t ticks_drift_minus, u16_t ticks_slot_plus, u16_t ticks_slot_plus, u16_t ticks_slot_minus, u16_t lazy,
u16_t ticks_slot_minus, u16_t lazy, u8_t force, u8_t force, ticker_op_func fp_op_func, void *op_context)
ticker_op_func fp_op_func, void *op_context)
{ {
struct ticker_instance *instance = &_instance[instance_index]; struct ticker_instance *instance = &_instance[instance_index];
u8_t last; u8_t last;
@ -1647,9 +1632,8 @@ u32_t ticker_update(u8_t instance_index, u8_t user_id,
return user_op->status; return user_op->status;
} }
u32_t ticker_stop(u8_t instance_index, u8_t user_id, u32_t ticker_stop(u8_t instance_index, u8_t user_id, u8_t _ticker_id,
u8_t _ticker_id, ticker_op_func fp_op_func, ticker_op_func fp_op_func, void *op_context)
void *op_context)
{ {
struct ticker_instance *instance = &_instance[instance_index]; struct ticker_instance *instance = &_instance[instance_index];
u8_t last; u8_t last;
@ -1681,11 +1665,9 @@ u32_t ticker_stop(u8_t instance_index, u8_t user_id,
return user_op->status; return user_op->status;
} }
u32_t ticker_next_slot_get(u8_t instance_index, u8_t user_id, u32_t ticker_next_slot_get(u8_t instance_index, u8_t user_id, u8_t *_ticker_id,
u8_t *_ticker_id, u32_t *ticks_current, u32_t *ticks_to_expire,
u32_t *ticks_current, ticker_op_func fp_op_func, void *op_context)
u32_t *ticks_to_expire,
ticker_op_func fp_op_func, void *op_context)
{ {
struct ticker_instance *instance = &_instance[instance_index]; struct ticker_instance *instance = &_instance[instance_index];
u8_t last; u8_t last;
@ -1721,7 +1703,7 @@ u32_t ticker_next_slot_get(u8_t instance_index, u8_t user_id,
} }
u32_t ticker_job_idle_get(u8_t instance_index, u8_t user_id, u32_t ticker_job_idle_get(u8_t instance_index, u8_t user_id,
ticker_op_func fp_op_func, void *op_context) ticker_op_func fp_op_func, void *op_context)
{ {
struct ticker_instance *instance = &_instance[instance_index]; struct ticker_instance *instance = &_instance[instance_index];
u8_t last; u8_t last;

43
subsys/bluetooth/controller/ticker/ticker.h
View file

@ -76,9 +76,8 @@
/** \brief Timer timeout function type. /** \brief Timer timeout function type.
*/ */
typedef void (*ticker_timeout_func) (u32_t ticks_at_expire, typedef void (*ticker_timeout_func) (u32_t ticks_at_expire, u32_t remainder,
u32_t remainder, u16_t lazy, u16_t lazy, void *context);
void *context);
/** \brief Timer operation complete function type. /** \brief Timer operation complete function type.
*/ */
@ -96,31 +95,25 @@ typedef void (*ticker_op_func) (u32_t status, void *op_context);
* \param[in] user_op * \param[in] user_op
*/ */
u32_t ticker_init(u8_t instance_index, u8_t count_node, void *node, u32_t ticker_init(u8_t instance_index, u8_t count_node, void *node,
u8_t count_user, void *user, u8_t count_op, u8_t count_user, void *user, u8_t count_op, void *user_op);
void *user_op);
void ticker_trigger(u8_t instance_index); void ticker_trigger(u8_t instance_index);
u32_t ticker_start(u8_t instance_index, u8_t user_id, u32_t ticker_start(u8_t instance_index, u8_t user_id, u8_t ticker_id,
u8_t ticker_id, u32_t ticks_anchor, u32_t ticks_anchor, u32_t ticks_first, u32_t ticks_periodic,
u32_t ticks_first, u32_t ticks_periodic, u32_t remainder_periodic, u16_t lazy, u16_t ticks_slot,
u32_t remainder_periodic, u16_t lazy, ticker_timeout_func ticker_timeout_func, void *context,
u16_t ticks_slot, ticker_op_func fp_op_func, void *op_context);
ticker_timeout_func ticker_timeout_func, void *context, u32_t ticker_update(u8_t instance_index, u8_t user_id, u8_t ticker_id,
ticker_op_func fp_op_func, void *op_context); u16_t ticks_drift_plus, u16_t ticks_drift_minus,
u32_t ticker_update(u8_t instance_index, u8_t user_id, u16_t ticks_slot_plus, u16_t ticks_slot_minus, u16_t lazy,
u8_t ticker_id, u16_t ticks_drift_plus, u8_t force, ticker_op_func fp_op_func, void *op_context);
u16_t ticks_drift_minus, u16_t ticks_slot_plus, u32_t ticker_stop(u8_t instance_index, u8_t user_id, u8_t ticker_id,
u16_t ticks_slot_minus, u16_t lazy, u8_t force, ticker_op_func fp_op_func, void *op_context);
ticker_op_func fp_op_func, void *op_context);
u32_t ticker_stop(u8_t instance_index, u8_t user_id,
u8_t ticker_id, ticker_op_func fp_op_func,
void *op_context);
u32_t ticker_next_slot_get(u8_t instance_index, u8_t user_id, u32_t ticker_next_slot_get(u8_t instance_index, u8_t user_id,
u8_t *ticker_id_head, u8_t *ticker_id_head, u32_t *ticks_current,
u32_t *ticks_current, u32_t *ticks_to_expire,
u32_t *ticks_to_expire, ticker_op_func fp_op_func, void *op_context);
ticker_op_func fp_op_func, void *op_context);
u32_t ticker_job_idle_get(u8_t instance_index, u8_t user_id, u32_t ticker_job_idle_get(u8_t instance_index, u8_t user_id,
ticker_op_func fp_op_func, void *op_context); ticker_op_func fp_op_func, void *op_context);
void ticker_job_sched(u8_t instance_index, u8_t user_id); void ticker_job_sched(u8_t instance_index, u8_t user_id);
u32_t ticker_ticks_now_get(void); u32_t ticker_ticks_now_get(void);
u32_t ticker_ticks_diff_get(u32_t ticks_now, u32_t ticks_old); u32_t ticker_ticks_diff_get(u32_t ticks_now, u32_t ticks_old);

5
subsys/bluetooth/controller/util/mayfly.h
View file

@ -26,11 +26,10 @@ struct mayfly {
void mayfly_init(void); void mayfly_init(void);
void mayfly_enable(u8_t caller_id, u8_t callee_id, u8_t enable); void mayfly_enable(u8_t caller_id, u8_t callee_id, u8_t enable);
u32_t mayfly_enqueue(u8_t caller_id, u8_t callee_id, u8_t chain, u32_t mayfly_enqueue(u8_t caller_id, u8_t callee_id, u8_t chain,
struct mayfly *m); struct mayfly *m);
void mayfly_run(u8_t callee_id); void mayfly_run(u8_t callee_id);
extern void mayfly_enable_cb(u8_t caller_id, u8_t callee_id, extern void mayfly_enable_cb(u8_t caller_id, u8_t callee_id, u8_t enable);
u8_t enable);
extern u32_t mayfly_is_enabled(u8_t caller_id, u8_t callee_id); extern u32_t mayfly_is_enabled(u8_t caller_id, u8_t callee_id);
extern u32_t mayfly_prio_is_equal(u8_t caller_id, u8_t callee_id); extern u32_t mayfly_prio_is_equal(u8_t caller_id, u8_t callee_id);
extern void mayfly_pend(u8_t caller_id, u8_t callee_id); extern void mayfly_pend(u8_t caller_id, u8_t callee_id);

16
subsys/bluetooth/controller/util/mem.c
View file

@ -20,8 +20,7 @@ void mem_init(void *mem_pool, u16_t mem_size, u16_t mem_count,
/* Store free mem_count after the list's next pointer at an aligned /* Store free mem_count after the list's next pointer at an aligned
* memory location to ensure atomic read/write (in ARM for now). * memory location to ensure atomic read/write (in ARM for now).
*/ */
*((u16_t *)MROUND((u8_t *)mem_pool + sizeof(mem_pool))) = *((u16_t *)MROUND((u8_t *)mem_pool + sizeof(mem_pool))) = mem_count;
mem_count;
/* Initialize next pointers to form a free list, /* Initialize next pointers to form a free list,
* next pointer is stored in the first 32-bit of each block * next pointer is stored in the first 32-bit of each block
@ -32,9 +31,9 @@ void mem_init(void *mem_pool, u16_t mem_size, u16_t mem_count,
u32_t next; u32_t next;
next = (u32_t)((u8_t *) mem_pool + next = (u32_t)((u8_t *) mem_pool +
(mem_size * (mem_count + 1))); (mem_size * (mem_count + 1)));
memcpy(((u8_t *)mem_pool + (mem_size * mem_count)), memcpy(((u8_t *)mem_pool + (mem_size * mem_count)),
(void *)&next, sizeof(next)); (void *)&next, sizeof(next));
} }
} }
@ -47,7 +46,7 @@ void *mem_acquire(void **mem_head)
/* Get the free count from the list and decrement it */ /* Get the free count from the list and decrement it */
free_count = *((u16_t *)MROUND((u8_t *)*mem_head + free_count = *((u16_t *)MROUND((u8_t *)*mem_head +
sizeof(mem_head))); sizeof(mem_head)));
free_count--; free_count--;
mem = *mem_head; mem = *mem_head;
@ -73,7 +72,7 @@ void mem_release(void *mem, void **mem_head)
/* Get the free count from the list and increment it */ /* Get the free count from the list and increment it */
if (*mem_head) { if (*mem_head) {
free_count = *((u16_t *)MROUND((u8_t *)*mem_head + free_count = *((u16_t *)MROUND((u8_t *)*mem_head +
sizeof(mem_head))); sizeof(mem_head)));
} }
free_count++; free_count++;
@ -92,7 +91,7 @@ u16_t mem_free_count_get(void *mem_head)
/* Get the free count from the list */ /* Get the free count from the list */
if (mem_head) { if (mem_head) {
free_count = *((u16_t *)MROUND((u8_t *)mem_head + free_count = *((u16_t *)MROUND((u8_t *)mem_head +
sizeof(mem_head))); sizeof(mem_head)));
} }
return free_count; return free_count;
@ -105,8 +104,7 @@ void *mem_get(void *mem_pool, u16_t mem_size, u16_t index)
u16_t mem_index_get(void *mem, void *mem_pool, u16_t mem_size) u16_t mem_index_get(void *mem, void *mem_pool, u16_t mem_size)
{ {
return ((u16_t)((u8_t *)mem - (u8_t *)mem_pool) / return ((u16_t)((u8_t *)mem - (u8_t *)mem_pool) / mem_size);
mem_size);
} }
void mem_rcopy(u8_t *dst, u8_t const *src, u16_t len) void mem_rcopy(u8_t *dst, u8_t const *src, u16_t len)

3
subsys/bluetooth/controller/util/mem.h
View file

@ -16,8 +16,7 @@
#define MROUND(x) (((u32_t)(x)+3) & (~((u32_t)3))) #define MROUND(x) (((u32_t)(x)+3) & (~((u32_t)3)))
#endif #endif
void mem_init(void *mem_pool, u16_t mem_size, u16_t mem_count, void mem_init(void *mem_pool, u16_t mem_size, u16_t mem_count, void **mem_head);
void **mem_head);
void *mem_acquire(void **mem_head); void *mem_acquire(void **mem_head);
void mem_release(void *mem, void **mem_head); void mem_release(void *mem, void **mem_head);