/*
|
* Licensed to the Apache Software Foundation (ASF) under one
|
* or more contributor license agreements. See the NOTICE file
|
* distributed with this work for additional information
|
* regarding copyright ownership. The ASF licenses this file
|
* to you under the Apache License, Version 2.0 (the
|
* "License"); you may not use this file except in compliance
|
* with the License. You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing,
|
* software distributed under the License is distributed on an
|
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
* KIND, either express or implied. See the License for the
|
* specific language governing permissions and limitations
|
* under the License.
|
*/
|
|
#include <stdint.h>
|
#include <stdlib.h>
|
#include <string.h>
|
#include <assert.h>
|
#include "nimble_syscfg.h"
|
#include "os/os.h"
|
#include "nimble/ble.h"
|
#include "nimble/hci_common.h"
|
#include "controller/ble_phy.h"
|
#include "controller/ble_hw.h"
|
#include "controller/ble_ll.h"
|
#include "controller/ble_ll_sched.h"
|
#include "controller/ble_ll_scan.h"
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV)
|
#include "controller/ble_ll_scan_aux.h"
|
#endif
|
#include "controller/ble_ll_tmr.h"
|
#include "controller/ble_ll_hci.h"
|
#include "controller/ble_ll_whitelist.h"
|
#include "controller/ble_ll_resolv.h"
|
#include "controller/ble_ll_rfmgmt.h"
|
#include "controller/ble_ll_trace.h"
|
#include "controller/ble_ll_sync.h"
|
#include "ble_ll_conn_priv.h"
|
|
#if MYNEWT_VAL(BLE_LL_ROLE_OBSERVER)
|
|
/*
|
* XXX:
|
* 1) I think I can guarantee that we dont process things out of order if
|
* I send an event when a scan request is sent. The scan_rsp_pending flag
|
* code might be made simpler.
|
*
|
* 2) Interleave sending scan requests to different advertisers? I guess I need
|
* a list of advertisers to which I sent a scan request and have yet to
|
* receive a scan response from? Implement this.
|
*/
|
|
/* Dont allow more than 255 of these entries */
|
#if MYNEWT_VAL(BLE_LL_NUM_SCAN_RSP_ADVS) > 255
|
#error "Cannot have more than 255 scan response entries!"
|
#endif
|
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_CODED_PHY)
|
#define SCAN_VALID_PHY_MASK (BLE_HCI_LE_PHY_1M_PREF_MASK | BLE_HCI_LE_PHY_CODED_PREF_MASK)
|
#else
|
#define SCAN_VALID_PHY_MASK (BLE_HCI_LE_PHY_1M_PREF_MASK)
|
#endif
|
|
struct ble_ll_scan_params {
|
uint8_t own_addr_type;
|
uint8_t scan_filt_policy;
|
struct ble_ll_scan_phy scan_phys[BLE_LL_SCAN_PHY_NUMBER];
|
};
|
|
static struct ble_ll_scan_params g_ble_ll_scan_params;
|
|
/* The scanning state machine global object */
|
static struct ble_ll_scan_sm g_ble_ll_scan_sm;
|
|
/*
|
* Structure used to store advertisers. This is used to limit sending scan
|
* requests to the same advertiser and also to filter duplicate events sent
|
* to the host.
|
*/
|
struct ble_ll_scan_advertisers
|
{
|
uint16_t sc_adv_flags;
|
uint16_t adi;
|
struct ble_dev_addr adv_addr;
|
};
|
|
#define BLE_LL_SC_ADV_F_RANDOM_ADDR (0x01)
|
#define BLE_LL_SC_ADV_F_SCAN_RSP_RXD (0x02)
|
#define BLE_LL_SC_ADV_F_DIRECT_RPT_SENT (0x04)
|
#define BLE_LL_SC_ADV_F_ADV_RPT_SENT (0x08)
|
#define BLE_LL_SC_ADV_F_SCAN_RSP_SENT (0x10)
|
|
/* Contains list of advertisers that we have heard scan responses from */
|
static uint8_t g_ble_ll_scan_num_rsp_advs;
|
struct ble_ll_scan_advertisers
|
g_ble_ll_scan_rsp_advs[MYNEWT_VAL(BLE_LL_NUM_SCAN_RSP_ADVS)];
|
|
/* Duplicates filtering data */
|
#define BLE_LL_SCAN_ENTRY_TYPE_LEGACY(addr_type) \
|
((addr_type) & 1)
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV)
|
#define BLE_LL_SCAN_ENTRY_TYPE_EXT(addr_type, has_aux, is_anon, adi) \
|
(((adi >> 8) & 0xF0) | (1 << 3) | (is_anon << 2) | (has_aux << 1) | ((addr_type) & 1))
|
#endif
|
|
#define BLE_LL_SCAN_DUP_F_ADV_REPORT_SENT (0x01)
|
#define BLE_LL_SCAN_DUP_F_DIR_ADV_REPORT_SENT (0x02)
|
#define BLE_LL_SCAN_DUP_F_SCAN_RSP_SENT (0x04)
|
|
struct ble_ll_scan_dup_entry {
|
uint8_t type; /* entry type, see BLE_LL_SCAN_ENTRY_TYPE_* */
|
uint8_t addr[6];
|
uint8_t flags; /* use BLE_LL_SCAN_DUP_F_xxx */
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV)
|
uint16_t adi;
|
#endif
|
TAILQ_ENTRY(ble_ll_scan_dup_entry) link;
|
};
|
|
static os_membuf_t g_scan_dup_mem[ OS_MEMPOOL_SIZE(
|
MYNEWT_VAL(BLE_LL_NUM_SCAN_DUP_ADVS),
|
sizeof(struct ble_ll_scan_dup_entry)) ];
|
static struct os_mempool g_scan_dup_pool;
|
static TAILQ_HEAD(ble_ll_scan_dup_list, ble_ll_scan_dup_entry) g_scan_dup_list;
|
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV)
|
static int
|
ble_ll_scan_start(struct ble_ll_scan_sm *scansm);
|
|
#endif
|
|
static inline uint32_t
|
ble_ll_scan_time_hci_to_ticks(uint16_t value)
|
{
|
return ble_ll_tmr_u2t(value * BLE_HCI_SCAN_ITVL);
|
}
|
|
/* See Vol 6 Part B Section 4.4.3.2. Active scanning backoff */
|
static void
|
ble_ll_scan_req_backoff(struct ble_ll_scan_sm *scansm, int success)
|
{
|
BLE_LL_ASSERT(scansm->backoff_count == 0);
|
BLE_LL_ASSERT(scansm->scan_rsp_pending == 0);
|
|
if (success) {
|
scansm->scan_rsp_cons_fails = 0;
|
++scansm->scan_rsp_cons_ok;
|
if (scansm->scan_rsp_cons_ok == 2) {
|
scansm->scan_rsp_cons_ok = 0;
|
if (scansm->upper_limit > 1) {
|
scansm->upper_limit >>= 1;
|
}
|
}
|
STATS_INC(ble_ll_stats, scan_req_txg);
|
} else {
|
scansm->scan_rsp_cons_ok = 0;
|
++scansm->scan_rsp_cons_fails;
|
if (scansm->scan_rsp_cons_fails == 2) {
|
scansm->scan_rsp_cons_fails = 0;
|
if (scansm->upper_limit < 256) {
|
scansm->upper_limit <<= 1;
|
}
|
}
|
STATS_INC(ble_ll_stats, scan_req_txf);
|
}
|
|
scansm->backoff_count = ble_ll_rand() & (scansm->upper_limit - 1);
|
++scansm->backoff_count;
|
BLE_LL_ASSERT(scansm->backoff_count <= 256);
|
}
|
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PRIVACY)
|
static void
|
ble_ll_scan_refresh_nrpa(struct ble_ll_scan_sm *scansm)
|
{
|
ble_npl_time_t now;
|
|
now = ble_npl_time_get();
|
if (LL_TMR_GEQ(now, scansm->scan_nrpa_timer)) {
|
/* Generate new NRPA */
|
ble_ll_rand_data_get(scansm->scan_nrpa, BLE_DEV_ADDR_LEN);
|
scansm->scan_nrpa[5] &= ~0xc0;
|
|
/* We'll use the same timeout as for RPA rotation */
|
scansm->scan_nrpa_timer = now + ble_ll_resolv_get_rpa_tmo();
|
}
|
}
|
|
uint8_t *
|
ble_ll_get_scan_nrpa(void)
|
{
|
struct ble_ll_scan_sm *scansm = &g_ble_ll_scan_sm;
|
|
ble_ll_scan_refresh_nrpa(scansm);
|
|
return scansm->scan_nrpa;
|
}
|
#endif
|
|
uint8_t
|
ble_ll_scan_get_own_addr_type(void)
|
{
|
return g_ble_ll_scan_sm.own_addr_type;
|
}
|
|
uint8_t
|
ble_ll_scan_get_filt_policy(void)
|
{
|
return g_ble_ll_scan_sm.scan_filt_policy;
|
}
|
|
uint8_t
|
ble_ll_scan_get_filt_dups(void)
|
{
|
return g_ble_ll_scan_sm.scan_filt_dups;
|
}
|
|
uint8_t
|
ble_ll_scan_backoff_kick(void)
|
{
|
struct ble_ll_scan_sm *scansm = &g_ble_ll_scan_sm;
|
|
if (scansm->backoff_count > 0) {
|
scansm->backoff_count--;
|
}
|
|
return scansm->backoff_count;
|
}
|
|
void
|
ble_ll_scan_backoff_update(int success)
|
{
|
struct ble_ll_scan_sm *scansm = &g_ble_ll_scan_sm;
|
|
ble_ll_scan_req_backoff(scansm, success);
|
}
|
|
static void
|
ble_ll_scan_req_pdu_prepare(struct ble_ll_scan_sm *scansm,
|
const uint8_t *adv_addr, uint8_t adv_addr_type,
|
int8_t rpa_index)
|
{
|
uint8_t hdr_byte;
|
struct ble_ll_scan_pdu_data *pdu_data;
|
uint8_t *scana;
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PRIVACY)
|
struct ble_ll_resolv_entry *rl;
|
uint8_t rpa[BLE_DEV_ADDR_LEN];
|
#endif
|
|
pdu_data = &scansm->pdu_data;
|
|
/* Construct first PDU header byte */
|
hdr_byte = BLE_ADV_PDU_TYPE_SCAN_REQ;
|
if (adv_addr_type) {
|
hdr_byte |= BLE_ADV_PDU_HDR_RXADD_RAND;
|
}
|
|
/* Determine ScanA */
|
if (scansm->own_addr_type & 0x01) {
|
hdr_byte |= BLE_ADV_PDU_HDR_TXADD_RAND;
|
scana = g_random_addr;
|
} else {
|
scana = g_dev_addr;
|
}
|
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PRIVACY)
|
if (scansm->own_addr_type & 0x02) {
|
if (rpa_index >= 0) {
|
rl = &g_ble_ll_resolv_list[rpa_index];
|
} else {
|
rl = NULL;
|
}
|
|
/*
|
* If device is on RL and we have local IRK, we use RPA generated using
|
* that IRK as ScanA. Otherwise we use NRPA as ScanA to prevent our
|
* device from being tracked when doing an active scan (Core 5.1, Vol 6,
|
* Part B, section 6.3)
|
*/
|
if (rl && rl->rl_has_local) {
|
ble_ll_resolv_get_priv_addr(rl, 1, rpa);
|
scana = rpa;
|
} else {
|
ble_ll_scan_refresh_nrpa(scansm);
|
scana = scansm->scan_nrpa;
|
}
|
|
hdr_byte |= BLE_ADV_PDU_HDR_TXADD_RAND;
|
}
|
#endif
|
|
/* Save scan request data */
|
pdu_data->hdr_byte = hdr_byte;
|
memcpy(pdu_data->scana, scana, BLE_DEV_ADDR_LEN);
|
memcpy(pdu_data->adva, adv_addr, BLE_DEV_ADDR_LEN);
|
}
|
|
static uint8_t
|
ble_ll_scan_req_tx_pdu_cb(uint8_t *dptr, void *pducb_arg, uint8_t *hdr_byte)
|
{
|
struct ble_ll_scan_sm *scansm = pducb_arg;
|
struct ble_ll_scan_pdu_data *pdu_data = &scansm->pdu_data;
|
|
memcpy(dptr, pdu_data->scana, BLE_DEV_ADDR_LEN);
|
memcpy(dptr + BLE_DEV_ADDR_LEN, pdu_data->adva, BLE_DEV_ADDR_LEN);
|
|
*hdr_byte = pdu_data->hdr_byte;
|
|
return BLE_DEV_ADDR_LEN * 2;
|
}
|
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV)
|
/* if copy_from is provided new report is initialized with that instead of
|
* defaults
|
*/
|
static struct ble_hci_ev *
|
ble_ll_scan_get_ext_adv_report(struct ext_adv_report *copy_from)
|
{
|
struct ble_hci_ev_le_subev_ext_adv_rpt *ev;
|
struct ext_adv_report *report;
|
struct ble_hci_ev *hci_ev;
|
|
hci_ev = ble_transport_alloc_evt(1);
|
if (!hci_ev) {
|
return NULL;
|
}
|
|
hci_ev->opcode = BLE_HCI_EVCODE_LE_META;
|
hci_ev->length = sizeof(*ev) + sizeof(*report);
|
ev = (void *) hci_ev->data;
|
|
memset(ev, 0, sizeof(*ev));
|
ev->subev_code = BLE_HCI_LE_SUBEV_EXT_ADV_RPT;
|
/* We support only one report per event now */
|
ev->num_reports = 1;
|
|
report = ev->reports;
|
|
if (copy_from) {
|
memcpy(report, copy_from, sizeof(*report));
|
report->data_len = 0;
|
} else {
|
memset(report, 0, sizeof(*report));
|
|
report->pri_phy = BLE_PHY_1M;
|
/* Init SID with "Not available" which is 0xFF */
|
report->sid = 0xFF;
|
/* Init TX Power with "Not available" which is 127 */
|
report->tx_power = 127;
|
/* Init RSSI with "Not available" which is 127 */
|
report->rssi = 127;
|
/* Init address type with "anonymous" which is 0xFF */
|
report->addr_type = 0xFF;
|
}
|
|
return hci_ev;
|
}
|
|
void
|
ble_ll_scan_end_adv_evt(struct ble_ll_aux_data *aux_data)
|
{
|
}
|
#endif
|
|
void
|
ble_ll_scan_halt(void)
|
{
|
struct ble_ll_scan_sm *scansm = &g_ble_ll_scan_sm;
|
|
/* Update backoff if we failed to receive scan response */
|
if (scansm->scan_rsp_pending) {
|
scansm->scan_rsp_pending = 0;
|
ble_ll_scan_req_backoff(scansm, 0);
|
}
|
}
|
|
/**
|
* Checks to see if we have received a scan response from this advertiser.
|
*
|
* @param adv_addr Address of advertiser
|
* @param txadd TxAdd bit (0: public; random otherwise)
|
*
|
* @return int 0: have not received a scan response; 1 otherwise.
|
*/
|
int
|
ble_ll_scan_have_rxd_scan_rsp(uint8_t *addr, uint8_t txadd,
|
uint8_t ext_adv, uint16_t adi)
|
{
|
uint8_t num_advs;
|
struct ble_ll_scan_advertisers *adv;
|
|
/* Do we have an address match? Must match address type */
|
adv = &g_ble_ll_scan_rsp_advs[0];
|
num_advs = g_ble_ll_scan_num_rsp_advs;
|
while (num_advs) {
|
if (!memcmp(&adv->adv_addr, addr, BLE_DEV_ADDR_LEN)) {
|
/* Address type must match */
|
if (txadd) {
|
if (adv->sc_adv_flags & BLE_LL_SC_ADV_F_RANDOM_ADDR) {
|
if (ext_adv) {
|
if (adi == adv->adi) {
|
return 1;
|
}
|
goto next;
|
}
|
return 1;
|
}
|
} else {
|
if ((adv->sc_adv_flags & BLE_LL_SC_ADV_F_RANDOM_ADDR) == 0) {
|
if (ext_adv) {
|
if (adi == adv->adi) {
|
return 1;
|
}
|
goto next;
|
}
|
return 1;
|
}
|
}
|
}
|
next:
|
++adv;
|
--num_advs;
|
}
|
|
return 0;
|
}
|
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV)
|
void
|
ble_ll_scan_add_scan_rsp_adv(uint8_t *addr, uint8_t txadd,
|
uint8_t ext_adv, uint16_t adi)
|
{
|
uint8_t num_advs;
|
struct ble_ll_scan_advertisers *adv;
|
|
/* XXX: for now, if we dont have room, just leave */
|
num_advs = g_ble_ll_scan_num_rsp_advs;
|
if (num_advs == MYNEWT_VAL(BLE_LL_NUM_SCAN_RSP_ADVS)) {
|
return;
|
}
|
|
/* Check if address is already on the list */
|
if (ble_ll_scan_have_rxd_scan_rsp(addr, txadd, ext_adv, adi)) {
|
return;
|
}
|
|
/* Add the advertiser to the array */
|
adv = &g_ble_ll_scan_rsp_advs[num_advs];
|
memcpy(&adv->adv_addr, addr, BLE_DEV_ADDR_LEN);
|
adv->sc_adv_flags = BLE_LL_SC_ADV_F_SCAN_RSP_RXD;
|
if (txadd) {
|
adv->sc_adv_flags |= BLE_LL_SC_ADV_F_RANDOM_ADDR;
|
}
|
adv->adi = adi;
|
++g_ble_ll_scan_num_rsp_advs;
|
|
return;
|
}
|
|
static int
|
ble_ll_hci_send_legacy_ext_adv_report(uint8_t evtype,
|
const uint8_t *addr, uint8_t addr_type,
|
int8_t rssi,
|
uint8_t adv_data_len,
|
struct os_mbuf *adv_data,
|
const uint8_t *inita, uint8_t inita_type)
|
{
|
struct ble_hci_ev_le_subev_ext_adv_rpt *ev;
|
struct ext_adv_report *report;
|
struct ble_hci_ev *hci_ev;
|
|
if (!ble_ll_hci_is_le_event_enabled(BLE_HCI_LE_SUBEV_EXT_ADV_RPT)) {
|
return -1;
|
}
|
|
/* Drop packet if adv data doesn't fit */
|
if ((sizeof(*ev) + sizeof(ev->reports[0]) + adv_data_len) > BLE_HCI_MAX_DATA_LEN) {
|
STATS_INC(ble_ll_stats, adv_evt_dropped);
|
return -1;
|
}
|
|
hci_ev = ble_ll_scan_get_ext_adv_report(NULL);
|
if (!hci_ev) {
|
return -1;
|
}
|
|
ev = (void *) hci_ev->data;
|
report = ev->reports;
|
|
switch (evtype) {
|
case BLE_HCI_ADV_RPT_EVTYPE_ADV_IND:
|
report->evt_type = BLE_HCI_LEGACY_ADV_EVTYPE_ADV_IND;
|
break;
|
case BLE_HCI_ADV_RPT_EVTYPE_DIR_IND:
|
report->evt_type = BLE_HCI_LEGACY_ADV_EVTYPE_ADV_DIRECT_IND;
|
break;
|
case BLE_HCI_ADV_RPT_EVTYPE_NONCONN_IND:
|
report->evt_type = BLE_HCI_LEGACY_ADV_EVTYPE_ADV_NONCON_IND;
|
break;
|
case BLE_HCI_ADV_RPT_EVTYPE_SCAN_RSP:
|
report->evt_type = BLE_HCI_LEGACY_ADV_EVTYPE_SCAN_RSP_ADV_IND;
|
break;
|
case BLE_HCI_ADV_RPT_EVTYPE_SCAN_IND:
|
report->evt_type = BLE_HCI_LEGACY_ADV_EVTYPE_ADV_SCAN_IND;
|
break;
|
default:
|
BLE_LL_ASSERT(0);
|
ble_transport_free(hci_ev);
|
return -1;
|
}
|
|
report->addr_type = addr_type;
|
memcpy(report->addr, addr, BLE_DEV_ADDR_LEN);
|
report->pri_phy = BLE_PHY_1M;
|
report->sid = 0xFF;
|
report->tx_power = 127;
|
report->rssi = rssi;
|
|
if (inita) {
|
report->dir_addr_type = inita_type;
|
memcpy(report->dir_addr, inita, BLE_DEV_ADDR_LEN);
|
}
|
|
if (adv_data_len) {
|
hci_ev->length += adv_data_len;
|
report->data_len = adv_data_len;
|
os_mbuf_copydata(adv_data, 0, adv_data_len, report->data);
|
}
|
|
return ble_ll_hci_event_send(hci_ev);
|
}
|
#endif
|
|
static int
|
ble_ll_hci_send_adv_report(uint8_t evtype,
|
const uint8_t *addr, uint8_t addr_type, int8_t rssi,
|
uint8_t adv_data_len, struct os_mbuf *adv_data)
|
{
|
struct ble_hci_ev_le_subev_adv_rpt *ev;
|
struct ble_hci_ev *hci_ev;
|
int8_t *ev_rssi;
|
|
if (!ble_ll_hci_is_le_event_enabled(BLE_HCI_LE_SUBEV_ADV_RPT)) {
|
return -1;
|
}
|
|
/* Drop packet if adv data doesn't fit, note extra 1 is for RSSI */
|
if ((sizeof(*ev) + sizeof(ev->reports[0]) + adv_data_len + 1) > BLE_HCI_MAX_DATA_LEN) {
|
STATS_INC(ble_ll_stats, adv_evt_dropped);
|
return -1;
|
}
|
|
hci_ev = ble_transport_alloc_evt(1);
|
if (!hci_ev) {
|
return -1;
|
}
|
|
hci_ev->opcode = BLE_HCI_EVCODE_LE_META;
|
hci_ev->length = sizeof(*ev) + sizeof(ev->reports[0]) + adv_data_len + 1;
|
ev = (void *) hci_ev->data;
|
|
ev->subev_code = BLE_HCI_LE_SUBEV_ADV_RPT;
|
ev->num_reports = 1;
|
|
ev->reports[0].type = evtype;
|
ev->reports[0].addr_type = addr_type;
|
memcpy(ev->reports[0].addr, addr, BLE_DEV_ADDR_LEN);
|
ev->reports[0].data_len = adv_data_len;
|
os_mbuf_copydata(adv_data, 0, adv_data_len, ev->reports[0].data);
|
|
/* RSSI is after adv data... */
|
ev_rssi = (int8_t *) (hci_ev->data + sizeof(*ev) + sizeof(ev->reports[0]) + adv_data_len);
|
*ev_rssi = rssi;
|
|
return ble_ll_hci_event_send(hci_ev);
|
}
|
|
static int
|
ble_ll_hci_send_dir_adv_report(const uint8_t *addr, uint8_t addr_type,
|
const uint8_t *inita, uint8_t inita_type,
|
int8_t rssi)
|
{
|
struct ble_hci_ev_le_subev_direct_adv_rpt *ev;
|
struct ble_hci_ev *hci_ev;
|
|
if (!ble_ll_hci_is_le_event_enabled(BLE_HCI_LE_SUBEV_DIRECT_ADV_RPT)) {
|
return -1;
|
}
|
|
hci_ev = ble_transport_alloc_evt(1);
|
if (!hci_ev) {
|
return -1;
|
}
|
|
hci_ev->opcode = BLE_HCI_EVCODE_LE_META;
|
hci_ev->length = sizeof(*ev) + sizeof(*(ev->reports));
|
ev = (void *) hci_ev->data;
|
|
ev->subev_code = BLE_HCI_LE_SUBEV_DIRECT_ADV_RPT;
|
ev->num_reports = 1;
|
|
ev->reports[0].type = BLE_HCI_ADV_RPT_EVTYPE_DIR_IND;
|
ev->reports[0].addr_type = addr_type;
|
memcpy(ev->reports[0].addr, addr, BLE_DEV_ADDR_LEN);
|
ev->reports[0].dir_addr_type = inita_type;
|
memcpy(ev->reports[0].dir_addr, inita, BLE_DEV_ADDR_LEN);
|
ev->reports[0].rssi = rssi;
|
|
return ble_ll_hci_event_send(hci_ev);
|
}
|
|
static int
|
ble_ll_scan_dup_update_legacy(uint8_t addr_type, const uint8_t *addr,
|
uint8_t subev, uint8_t evtype)
|
{
|
struct ble_ll_scan_dup_entry *e;
|
uint8_t type;
|
|
type = BLE_LL_SCAN_ENTRY_TYPE_LEGACY(addr_type);
|
|
/*
|
* We assume ble_ll_scan_dup_check() was called before which either matched
|
* some entry or allocated new one and placed in on the top of queue.
|
*/
|
|
e = TAILQ_FIRST(&g_scan_dup_list);
|
BLE_LL_ASSERT(e && e->type == type && !memcmp(e->addr, addr, 6));
|
|
if (subev == BLE_HCI_LE_SUBEV_DIRECT_ADV_RPT) {
|
e->flags |= BLE_LL_SCAN_DUP_F_DIR_ADV_REPORT_SENT;
|
} else {
|
if (evtype == BLE_HCI_ADV_RPT_EVTYPE_SCAN_RSP) {
|
e->flags |= BLE_LL_SCAN_DUP_F_SCAN_RSP_SENT;
|
} else {
|
e->flags |= BLE_LL_SCAN_DUP_F_ADV_REPORT_SENT;
|
}
|
}
|
|
return 0;
|
}
|
|
/**
|
* Send an advertising report to the host.
|
*
|
* NOTE: while we are allowed to send multiple devices in one report, we
|
* will just send for one for now.
|
*
|
* @param pdu_type
|
* @param txadd
|
* @param rxbuf
|
* @param hdr
|
* @param scansm
|
*/
|
static void
|
ble_ll_scan_send_adv_report(uint8_t pdu_type,
|
const uint8_t *adva, uint8_t adva_type,
|
const uint8_t *inita, uint8_t inita_type,
|
struct os_mbuf *om,
|
struct ble_mbuf_hdr *hdr,
|
struct ble_ll_scan_sm *scansm)
|
{
|
uint8_t subev = BLE_HCI_LE_SUBEV_ADV_RPT;
|
uint8_t adv_data_len;
|
uint8_t evtype;
|
int rc;
|
|
if (pdu_type == BLE_ADV_PDU_TYPE_ADV_DIRECT_IND) {
|
if (ble_ll_is_rpa(inita, inita_type)) {
|
/* For resolvable we send separate subevent */
|
subev = BLE_HCI_LE_SUBEV_DIRECT_ADV_RPT;
|
}
|
|
evtype = BLE_HCI_ADV_RPT_EVTYPE_DIR_IND;
|
adv_data_len = 0;
|
} else {
|
if (pdu_type == BLE_ADV_PDU_TYPE_ADV_IND) {
|
evtype = BLE_HCI_ADV_RPT_EVTYPE_ADV_IND;
|
} else if (pdu_type == BLE_ADV_PDU_TYPE_ADV_SCAN_IND) {
|
evtype = BLE_HCI_ADV_RPT_EVTYPE_SCAN_IND;
|
} else if (pdu_type == BLE_ADV_PDU_TYPE_ADV_NONCONN_IND) {
|
evtype = BLE_HCI_ADV_RPT_EVTYPE_NONCONN_IND;
|
} else {
|
evtype = BLE_HCI_ADV_RPT_EVTYPE_SCAN_RSP;
|
}
|
adv_data_len = om->om_data[1] - BLE_DEV_ADDR_LEN;
|
os_mbuf_adj(om, BLE_LL_PDU_HDR_LEN + BLE_DEV_ADDR_LEN);
|
}
|
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PRIVACY)
|
/* If RPA has been used, make sure we use correct address types
|
* in the advertising report.
|
*/
|
if (BLE_MBUF_HDR_RESOLVED(hdr)) {
|
adva_type += 2;
|
}
|
if (BLE_MBUF_HDR_TARGETA_RESOLVED(hdr)) {
|
inita_type += 2;
|
}
|
#endif
|
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV)
|
if (scansm->ext_scanning) {
|
rc = ble_ll_hci_send_legacy_ext_adv_report(evtype,
|
adva, adva_type,
|
hdr->rxinfo.rssi,
|
adv_data_len, om,
|
inita, inita_type);
|
goto done;
|
}
|
#endif
|
|
if (subev == BLE_HCI_LE_SUBEV_DIRECT_ADV_RPT) {
|
rc = ble_ll_hci_send_dir_adv_report(adva, adva_type, inita, inita_type,
|
hdr->rxinfo.rssi);
|
goto done;
|
}
|
|
rc = ble_ll_hci_send_adv_report(evtype, adva, adva_type, hdr->rxinfo.rssi,
|
adv_data_len, om);
|
done:
|
if (!rc && scansm->scan_filt_dups) {
|
ble_ll_scan_dup_update_legacy(adva_type, adva, subev, evtype);
|
}
|
}
|
|
/**
|
* Called to enable the receiver for scanning.
|
*
|
* Context: Link Layer task
|
*
|
* @param sch
|
*
|
* @return int
|
*/
|
static int
|
ble_ll_scan_start(struct ble_ll_scan_sm *scansm)
|
{
|
int rc;
|
struct ble_ll_scan_phy *scanp = scansm->scanp;
|
uint8_t chan;
|
#if (BLE_LL_BT5_PHY_SUPPORTED == 1)
|
uint8_t phy_mode;
|
int phy;
|
#endif
|
|
BLE_LL_ASSERT(scansm->scan_rsp_pending == 0);
|
|
/* Set channel */
|
chan = scanp->scan_chan;
|
rc = ble_phy_setchan(chan, BLE_ACCESS_ADDR_ADV, BLE_LL_CRCINIT_ADV);
|
BLE_LL_ASSERT(rc == 0);
|
|
/*
|
* Set transmit end callback to NULL in case we transmit a scan request.
|
* There is a callback for the connect request.
|
*/
|
ble_phy_set_txend_cb(NULL, NULL);
|
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_ENCRYPTION)
|
ble_phy_encrypt_disable();
|
#endif
|
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PRIVACY)
|
if (ble_ll_resolv_enabled()) {
|
ble_phy_resolv_list_enable();
|
} else {
|
ble_phy_resolv_list_disable();
|
}
|
#endif
|
|
#if (BLE_LL_BT5_PHY_SUPPORTED == 1)
|
phy = scanp->phy;
|
phy_mode = ble_ll_phy_to_phy_mode(phy, BLE_HCI_LE_PHY_CODED_ANY);
|
ble_phy_mode_set(phy_mode, phy_mode);
|
#endif
|
|
rc = ble_phy_rx_set_start_time(ble_ll_tmr_get() +
|
g_ble_ll_sched_offset_ticks, 0);
|
if (!rc || rc == BLE_PHY_ERR_RX_LATE) {
|
/* If we are late here, it is still OK because we keep scanning.
|
* Clear error
|
*/
|
rc = 0;
|
|
/* Enable/disable whitelisting */
|
if (scansm->scan_filt_policy & 1) {
|
ble_ll_whitelist_enable();
|
} else {
|
ble_ll_whitelist_disable();
|
}
|
|
ble_ll_state_set(BLE_LL_STATE_SCANNING);
|
}
|
|
return rc;
|
}
|
|
static uint8_t
|
ble_ll_scan_get_next_adv_prim_chan(uint8_t chan)
|
{
|
++chan;
|
if (chan == BLE_PHY_NUM_CHANS) {
|
chan = BLE_PHY_ADV_CHAN_START;
|
}
|
|
return chan;
|
}
|
|
static uint32_t
|
ble_ll_scan_move_window_to(struct ble_ll_scan_phy *scanp, uint32_t time)
|
{
|
uint32_t end_time;
|
|
/*
|
* Move window until given tick is before or inside window and move to next
|
* channel for each skipped interval.
|
*/
|
|
end_time = scanp->timing.start_time + scanp->timing.window;
|
while (LL_TMR_GEQ(time, end_time)) {
|
scanp->timing.start_time += scanp->timing.interval;
|
scanp->scan_chan = ble_ll_scan_get_next_adv_prim_chan(scanp->scan_chan);
|
end_time = scanp->timing.start_time + scanp->timing.window;
|
}
|
|
return scanp->timing.start_time;
|
}
|
|
static bool
|
ble_ll_scan_is_inside_window(struct ble_ll_scan_phy *scanp, uint32_t time)
|
{
|
uint32_t start_time;
|
|
/* Make sure we are checking against closest window */
|
start_time = ble_ll_scan_move_window_to(scanp, time);
|
|
if (scanp->timing.window == scanp->timing.interval) {
|
/* always inside window in continuous scan */
|
return true;
|
}
|
|
return LL_TMR_GEQ(time, start_time) &&
|
LL_TMR_LT(time, start_time + scanp->timing.window);
|
}
|
|
/**
|
* Stop the scanning state machine
|
*/
|
void
|
ble_ll_scan_sm_stop(int chk_disable)
|
{
|
os_sr_t sr;
|
uint8_t lls;
|
struct ble_ll_scan_sm *scansm;
|
|
/* Stop the scanning timer */
|
scansm = &g_ble_ll_scan_sm;
|
ble_ll_tmr_stop(&scansm->scan_timer);
|
|
/* Only set state if we are currently in a scan window */
|
if (chk_disable) {
|
OS_ENTER_CRITICAL(sr);
|
lls = ble_ll_state_get();
|
|
if (lls == BLE_LL_STATE_SCANNING) {
|
/* Disable phy */
|
ble_phy_disable();
|
|
/* Set LL state to standby */
|
ble_ll_state_set(BLE_LL_STATE_STANDBY);
|
}
|
OS_EXIT_CRITICAL(sr);
|
}
|
|
OS_ENTER_CRITICAL(sr);
|
|
#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL)
|
scansm->connsm = NULL;
|
#endif
|
|
/* Disable scanning state machine */
|
scansm->scan_enabled = 0;
|
scansm->restart_timer_needed = 0;
|
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV)
|
if (scansm->ext_scanning) {
|
ble_ll_sched_rmv_elem_type(BLE_LL_SCHED_TYPE_SCAN_AUX, ble_ll_scan_aux_sched_remove);
|
scansm->ext_scanning = 0;
|
}
|
#endif
|
|
/* Update backoff if we failed to receive scan response */
|
if (scansm->scan_rsp_pending) {
|
scansm->scan_rsp_pending = 0;
|
ble_ll_scan_req_backoff(scansm, 0);
|
}
|
OS_EXIT_CRITICAL(sr);
|
|
/* Count # of times stopped */
|
STATS_INC(ble_ll_stats, scan_stops);
|
|
/* No need for RF anymore */
|
OS_ENTER_CRITICAL(sr);
|
ble_ll_rfmgmt_scan_changed(false, 0);
|
ble_ll_rfmgmt_release();
|
OS_EXIT_CRITICAL(sr);
|
}
|
|
static int
|
ble_ll_scan_sm_start(struct ble_ll_scan_sm *scansm)
|
{
|
struct ble_ll_scan_phy *scanp;
|
struct ble_ll_scan_phy *scanp_next;
|
|
if (!ble_ll_is_valid_own_addr_type(scansm->own_addr_type, g_random_addr)) {
|
return BLE_ERR_INV_HCI_CMD_PARMS;
|
}
|
|
BLE_LL_ASSERT(scansm->scanp);
|
scanp = scansm->scanp;
|
scanp_next = scansm->scanp_next;
|
|
/* Count # of times started */
|
STATS_INC(ble_ll_stats, scan_starts);
|
|
/* Set flag telling us that scanning is enabled */
|
scansm->scan_enabled = 1;
|
|
/* Set first advertising channel */
|
scanp->scan_chan = BLE_PHY_ADV_CHAN_START;
|
if (scanp_next) {
|
scanp_next->scan_chan = BLE_PHY_ADV_CHAN_START;
|
}
|
|
/* Reset scan request backoff parameters to default */
|
scansm->upper_limit = 1;
|
scansm->backoff_count = 1;
|
scansm->scan_rsp_pending = 0;
|
|
/* Forget filtered advertisers from previous scan. */
|
g_ble_ll_scan_num_rsp_advs = 0;
|
|
os_mempool_clear(&g_scan_dup_pool);
|
TAILQ_INIT(&g_scan_dup_list);
|
|
/*
|
* First scan window can start when RF is enabled. Add 1 tick since we are
|
* most likely not aligned with ticks so RF may be effectively enabled 1
|
* tick later.
|
*/
|
scanp->timing.start_time = ble_ll_rfmgmt_enable_now();
|
ble_ll_rfmgmt_scan_changed(true, scanp->timing.start_time);
|
|
if (scanp_next) {
|
/* Schedule start time right after first phy */
|
scanp_next->timing.start_time = scanp->timing.start_time +
|
scanp->timing.window;
|
}
|
|
/* Start scan at 1st window */
|
ble_ll_tmr_start(&scansm->scan_timer, scanp->timing.start_time);
|
|
return BLE_ERR_SUCCESS;
|
}
|
|
static void
|
ble_ll_scan_interrupted_event_cb(struct ble_npl_event *ev)
|
{
|
struct ble_ll_scan_sm *scansm = &g_ble_ll_scan_sm;
|
|
if (!scansm->scan_enabled) {
|
return;
|
}
|
|
/*
|
* If we timed out waiting for a response, the scan response pending
|
* flag should be set. Deal with scan backoff. Put device back into rx.
|
*/
|
|
if (scansm->scan_rsp_pending) {
|
scansm->scan_rsp_pending = 0;
|
ble_ll_scan_req_backoff(scansm, 0);
|
}
|
|
ble_ll_scan_chk_resume();
|
}
|
|
/**
|
* Called to process the scanning OS event which was posted to the LL task
|
*
|
* Context: Link Layer task.
|
*
|
* @param arg
|
*/
|
static void
|
ble_ll_scan_event_proc(struct ble_npl_event *ev)
|
{
|
struct ble_ll_scan_sm *scansm;
|
os_sr_t sr;
|
bool start_scan;
|
bool inside_window;
|
struct ble_ll_scan_phy *scanp;
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV)
|
bool inside_window_next;
|
struct ble_ll_scan_phy *scanp_next;
|
#endif
|
uint32_t next_proc_time;
|
uint32_t now;
|
/*
|
* Get the scanning state machine. If not enabled (this is possible), just
|
* leave and do nothing (just make sure timer is stopped).
|
*/
|
scansm = (struct ble_ll_scan_sm *)ble_npl_event_get_arg(ev);
|
scanp = scansm->scanp;
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV)
|
scanp_next = scansm->scanp_next;
|
#endif
|
|
OS_ENTER_CRITICAL(sr);
|
if (!scansm->scan_enabled) {
|
ble_ll_tmr_stop(&scansm->scan_timer);
|
ble_ll_rfmgmt_scan_changed(false, 0);
|
ble_ll_rfmgmt_release();
|
OS_EXIT_CRITICAL(sr);
|
return;
|
}
|
|
if (scansm->scan_rsp_pending) {
|
/* Aux scan in progress. Wait */
|
STATS_INC(ble_ll_stats, scan_timer_stopped);
|
scansm->restart_timer_needed = 1;
|
OS_EXIT_CRITICAL(sr);
|
return;
|
}
|
|
now = ble_ll_tmr_get();
|
|
inside_window = ble_ll_scan_is_inside_window(scanp, now);
|
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV)
|
/* Update also next PHY if configured */
|
if (scanp_next) {
|
inside_window_next = ble_ll_scan_is_inside_window(scanp_next, now);
|
|
/*
|
* Switch PHY if current PHY is outside window and next PHY is either
|
* inside window or has next window earlier than current PHY.
|
*/
|
if (!inside_window &&
|
((inside_window_next || LL_TMR_LEQ(scanp_next->timing.start_time,
|
scanp->timing.start_time)))) {
|
scansm->scanp = scanp_next;
|
scansm->scanp_next = scanp;
|
scanp = scansm->scanp;
|
scanp_next = scansm->scanp_next;
|
inside_window = inside_window_next;
|
}
|
}
|
#endif
|
|
/*
|
* At this point scanp and scanp_next point to current or closest scan
|
* window on both PHYs (scanp is the closer one). Make sure RF is enabled
|
* on time.
|
*/
|
ble_ll_rfmgmt_scan_changed(true, scanp->timing.start_time);
|
|
/*
|
* If we are inside window, next scan proc should happen at the end of
|
* current window to either disable scan or switch to next PHY.
|
* If we are outside window, next scan proc should happen at the time of
|
* closest scan window.
|
*/
|
if (inside_window) {
|
next_proc_time = scanp->timing.start_time + scanp->timing.window;
|
} else {
|
next_proc_time = scanp->timing.start_time;
|
}
|
|
/*
|
* If we are not in the standby state it means that the scheduled
|
* scanning event was overlapped in the schedule. In this case all we do
|
* is post the scan schedule end event.
|
*/
|
start_scan = inside_window;
|
switch (ble_ll_state_get()) {
|
#if MYNEWT_VAL(BLE_LL_ROLE_BROADCASTER)
|
case BLE_LL_STATE_ADV:
|
start_scan = false;
|
break;
|
#endif
|
#if MYNEWT_VAL(BLE_LL_ROLE_PERIPHERAL) || MYNEWT_VAL(BLE_LL_ROLE_CENTRAL)
|
case BLE_LL_STATE_CONNECTION:
|
start_scan = false;
|
break;
|
#endif
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PERIODIC_ADV)
|
case BLE_LL_STATE_SYNC:
|
start_scan = false;
|
break;
|
#endif
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV)
|
case BLE_LL_STATE_SCAN_AUX:
|
start_scan = false;
|
break;
|
#endif
|
case BLE_LL_STATE_SCANNING:
|
/* Must disable PHY since we will move to a new channel */
|
ble_phy_disable();
|
if (!inside_window) {
|
ble_ll_state_set(BLE_LL_STATE_STANDBY);
|
}
|
break;
|
case BLE_LL_STATE_STANDBY:
|
break;
|
default:
|
BLE_LL_ASSERT(0);
|
break;
|
}
|
|
if (start_scan) {
|
ble_ll_scan_start(scansm);
|
} else {
|
ble_ll_rfmgmt_release();
|
}
|
|
OS_EXIT_CRITICAL(sr);
|
ble_ll_tmr_start(&scansm->scan_timer, next_proc_time);
|
}
|
|
/**
|
* ble ll scan rx pdu start
|
*
|
* Called when a PDU reception has started and the Link Layer is in the
|
* scanning state.
|
*
|
* Context: Interrupt
|
*
|
* @param pdu_type
|
* @param rxflags
|
*
|
* @return int
|
* 0: we will not attempt to reply to this frame
|
* 1: we may send a response to this frame.
|
*/
|
int
|
ble_ll_scan_rx_isr_start(uint8_t pdu_type, uint16_t *rxflags)
|
{
|
int rc;
|
struct ble_ll_scan_sm *scansm;
|
struct ble_ll_scan_phy *scanp;
|
|
rc = 0;
|
scansm = &g_ble_ll_scan_sm;
|
scanp = scansm->scanp;
|
|
switch (scanp->scan_type) {
|
case BLE_SCAN_TYPE_ACTIVE:
|
/* If adv ind or scan ind, we may send scan request */
|
if ((pdu_type == BLE_ADV_PDU_TYPE_ADV_IND) ||
|
(pdu_type == BLE_ADV_PDU_TYPE_ADV_SCAN_IND)) {
|
rc = 1;
|
}
|
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV)
|
if ((pdu_type == BLE_ADV_PDU_TYPE_ADV_EXT_IND && scansm->ext_scanning)) {
|
*rxflags |= BLE_MBUF_HDR_F_EXT_ADV;
|
rc = 1;
|
}
|
#endif
|
|
/*
|
* If this is the first PDU after we sent the scan response (as
|
* denoted by the scan rsp pending flag), we set a bit in the ble
|
* header so the link layer can check to see if the scan request
|
* was successful. We do it this way to let the Link Layer do the
|
* work for successful scan requests. If failed, we do the work here.
|
*/
|
if (scansm->scan_rsp_pending) {
|
scansm->scan_rsp_pending = 0;
|
|
if (pdu_type == BLE_ADV_PDU_TYPE_SCAN_RSP) {
|
*rxflags |= BLE_MBUF_HDR_F_SCAN_RSP_RXD;
|
} else if (pdu_type == BLE_ADV_PDU_TYPE_AUX_SCAN_RSP) {
|
*rxflags |= BLE_MBUF_HDR_F_SCAN_RSP_RXD;
|
} else {
|
ble_ll_scan_req_backoff(scansm, 0);
|
}
|
}
|
break;
|
case BLE_SCAN_TYPE_PASSIVE:
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV)
|
if ((pdu_type == BLE_ADV_PDU_TYPE_ADV_EXT_IND && scansm->ext_scanning)) {
|
*rxflags |= BLE_MBUF_HDR_F_EXT_ADV;
|
}
|
break;
|
#endif
|
#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL)
|
case BLE_SCAN_TYPE_INITIATE:
|
if ((pdu_type == BLE_ADV_PDU_TYPE_ADV_IND) ||
|
(pdu_type == BLE_ADV_PDU_TYPE_ADV_DIRECT_IND)) {
|
rc = 1;
|
}
|
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV)
|
if ((pdu_type == BLE_ADV_PDU_TYPE_ADV_EXT_IND && scansm->ext_scanning)) {
|
*rxflags |= BLE_MBUF_HDR_F_EXT_ADV;
|
rc = 1;
|
}
|
#endif
|
break;
|
#endif
|
default:
|
break;
|
}
|
|
return rc;
|
}
|
|
static void
|
ble_ll_scan_get_addr_data_from_legacy(uint8_t pdu_type, uint8_t *rxbuf,
|
struct ble_ll_scan_addr_data *addrd)
|
{
|
BLE_LL_ASSERT(pdu_type < BLE_ADV_PDU_TYPE_ADV_EXT_IND);
|
|
addrd->adva = rxbuf + BLE_LL_PDU_HDR_LEN;
|
addrd->adva_type = ble_ll_get_addr_type(rxbuf[0] & BLE_ADV_PDU_HDR_TXADD_MASK);
|
|
if (pdu_type == BLE_ADV_PDU_TYPE_ADV_DIRECT_IND) {
|
addrd->targeta = rxbuf + BLE_LL_PDU_HDR_LEN + BLE_DEV_ADDR_LEN;
|
addrd->targeta_type = ble_ll_get_addr_type(rxbuf[0] & BLE_ADV_PDU_HDR_RXADD_MASK);
|
} else {
|
addrd->targeta = NULL;
|
addrd->targeta_type = 0;
|
}
|
}
|
|
int
|
ble_ll_scan_rx_filter(uint8_t own_addr_type, uint8_t scan_filt_policy,
|
struct ble_ll_scan_addr_data *addrd, uint8_t *scan_ok)
|
{
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PRIVACY)
|
struct ble_ll_resolv_entry *rl = NULL;
|
#endif
|
bool scan_req_allowed = true;
|
bool resolved;
|
|
/* Note: caller is expected to fill adva, targeta and rpa_index in addrd */
|
|
/* Use AdvA as initial advertiser address, we may change it if resolved */
|
addrd->adv_addr = addrd->adva;
|
addrd->adv_addr_type = addrd->adva_type;
|
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PRIVACY)
|
addrd->adva_resolved = 0;
|
addrd->targeta_resolved = 0;
|
|
BLE_LL_ASSERT((addrd->rpa_index < 0) ||
|
(ble_ll_addr_subtype(addrd->adva, addrd->adva_type) ==
|
BLE_LL_ADDR_SUBTYPE_RPA));
|
|
switch (ble_ll_addr_subtype(addrd->adva, addrd->adva_type)) {
|
case BLE_LL_ADDR_SUBTYPE_RPA:
|
if (addrd->rpa_index < 0) {
|
break;
|
}
|
|
addrd->adva_resolved = 1;
|
|
/* Use resolved identity address as advertiser address */
|
rl = &g_ble_ll_resolv_list[addrd->rpa_index];
|
addrd->adv_addr = rl->rl_identity_addr;
|
addrd->adv_addr_type = rl->rl_addr_type;
|
break;
|
case BLE_LL_ADDR_SUBTYPE_IDENTITY:
|
/* If AdvA is an identity address, we need to check if that device was
|
* added to RL in order to use proper privacy mode.
|
*/
|
rl = ble_ll_resolv_list_find(addrd->adva, addrd->adva_type);
|
if (!rl) {
|
break;
|
}
|
|
/* Ignore device if using network privacy mode and it has IRK */
|
if ((rl->rl_priv_mode == BLE_HCI_PRIVACY_NETWORK) && rl->rl_has_peer) {
|
return -1;
|
}
|
|
addrd->rpa_index = ble_ll_resolv_get_idx(rl);
|
break;
|
default:
|
/* NRPA goes through filtering policy directly */
|
break;
|
}
|
|
if (addrd->targeta) {
|
switch (ble_ll_addr_subtype(addrd->targeta, addrd->targeta_type)) {
|
case BLE_LL_ADDR_SUBTYPE_RPA:
|
/* Check if TargetA can be resolved using the same RL entry as AdvA */
|
if (rl && ble_ll_resolv_rpa(addrd->targeta, rl->rl_local_irk)) {
|
addrd->targeta_resolved = 1;
|
break;
|
}
|
|
/* Check if scan filter policy allows unresolved RPAs to be processed */
|
if (!(scan_filt_policy & 0x02)) {
|
return -2;
|
}
|
|
/* Do not send scan request even if scan policy allows unresolved
|
* RPAs - we do not know if this one if directed to us.
|
*/
|
scan_req_allowed = false;
|
break;
|
case BLE_LL_ADDR_SUBTYPE_IDENTITY:
|
/* We shall ignore identity in TargetA if we are using RPA */
|
if ((own_addr_type & 0x02) && rl && rl->rl_has_local) {
|
return -1;
|
}
|
|
/* Ignore if not directed to us */
|
if (!ble_ll_is_our_devaddr(addrd->targeta, addrd->targeta_type)) {
|
return -1;
|
}
|
break;
|
default:
|
/* NRPA goes through filtering policy directly */
|
break;
|
}
|
}
|
|
resolved = addrd->adva_resolved;
|
#else
|
/* Ignore if not directed to us */
|
if (addrd->targeta &&
|
!ble_ll_is_our_devaddr(addrd->targeta, addrd->targeta_type)) {
|
return -1;
|
}
|
|
resolved = false;
|
#endif
|
|
if (scan_filt_policy & 0x01) {
|
/* Check on WL if required by scan filter policy */
|
if (!ble_ll_whitelist_match(addrd->adv_addr, addrd->adv_addr_type,
|
resolved)) {
|
return -2;
|
}
|
}
|
|
if (scan_ok) {
|
*scan_ok = scan_req_allowed;
|
}
|
|
return 0;
|
}
|
|
#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL)
|
int
|
ble_ll_scan_rx_check_init(struct ble_ll_scan_addr_data *addrd)
|
{
|
struct ble_ll_scan_sm *scansm;
|
struct ble_ll_conn_sm *connsm;
|
|
scansm = &g_ble_ll_scan_sm;
|
connsm = scansm->connsm;
|
BLE_LL_ASSERT(connsm);
|
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PRIVACY)
|
if ((connsm->peer_addr_type > BLE_ADDR_RANDOM) && !addrd->adva_resolved) {
|
return -1;
|
}
|
#endif
|
if ((addrd->adv_addr_type != (connsm->peer_addr_type & 0x01)) ||
|
memcmp(addrd->adv_addr, connsm->peer_addr, 6) != 0) {
|
return -1;
|
}
|
|
return 0;
|
}
|
#endif
|
|
static int
|
ble_ll_scan_rx_isr_end_on_adv(uint8_t pdu_type, uint8_t *rxbuf,
|
struct ble_mbuf_hdr *hdr,
|
struct ble_ll_scan_addr_data *addrd)
|
{
|
struct ble_ll_scan_sm *scansm = &g_ble_ll_scan_sm;
|
struct ble_ll_scan_phy *scanp = scansm->scanp;
|
struct ble_mbuf_hdr_rxinfo *rxinfo = &hdr->rxinfo;
|
uint8_t scan_ok;
|
int rc;
|
|
ble_ll_scan_get_addr_data_from_legacy(pdu_type, rxbuf, addrd);
|
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PRIVACY)
|
addrd->rpa_index = ble_hw_resolv_list_match();
|
#endif
|
|
rc = ble_ll_scan_rx_filter(scansm->own_addr_type,
|
scansm->scan_filt_policy, addrd, &scan_ok);
|
if (rc < 0) {
|
return 0;
|
}
|
|
#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL)
|
if ((scanp->scan_type == BLE_SCAN_TYPE_INITIATE) &&
|
!(scansm->scan_filt_policy & 0x01)) {
|
rc = ble_ll_scan_rx_check_init(addrd);
|
if (rc < 0) {
|
return 0;
|
}
|
}
|
#endif
|
|
rxinfo->flags |= BLE_MBUF_HDR_F_DEVMATCH;
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PRIVACY)
|
rxinfo->rpa_index = addrd->rpa_index;
|
if (addrd->adva_resolved) {
|
rxinfo->flags |= BLE_MBUF_HDR_F_RESOLVED;
|
}
|
if (addrd->targeta_resolved) {
|
rxinfo->flags |= BLE_MBUF_HDR_F_TARGETA_RESOLVED;
|
}
|
#endif
|
|
if (!scan_ok) {
|
/* Scan request forbidden by filter policy */
|
return 0;
|
}
|
|
/* Allow responding to all PDUs when initiating since unwanted PDUs were
|
* already filtered out in isr_start.
|
*/
|
if ((scanp->scan_type == BLE_SCAN_TYPE_ACTIVE) &&
|
((pdu_type == BLE_ADV_PDU_TYPE_ADV_IND) ||
|
(pdu_type == BLE_ADV_PDU_TYPE_ADV_SCAN_IND))) {
|
return 1;
|
}
|
|
#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL)
|
if (scanp->scan_type == BLE_SCAN_TYPE_INITIATE) {
|
return 1;
|
}
|
#endif
|
|
return 0;
|
}
|
|
static int
|
ble_ll_scan_rx_isr_end_on_scan_rsp(uint8_t pdu_type, uint8_t *rxbuf,
|
struct ble_mbuf_hdr *hdr,
|
struct ble_ll_scan_addr_data *addrd)
|
{
|
struct ble_ll_scan_sm *scansm = &g_ble_ll_scan_sm;
|
struct ble_mbuf_hdr_rxinfo *rxinfo = &hdr->rxinfo;
|
uint8_t sreq_adva_type;
|
uint8_t *sreq_adva;
|
|
ble_ll_scan_get_addr_data_from_legacy(pdu_type, rxbuf, addrd);
|
|
if (!BLE_MBUF_HDR_SCAN_RSP_RXD(hdr)) {
|
/*
|
* We were not expecting scan response so just ignore and do not
|
* update backoff.
|
*/
|
return -1;
|
}
|
|
sreq_adva_type = !!(scansm->pdu_data.hdr_byte & BLE_ADV_PDU_HDR_RXADD_MASK);
|
sreq_adva = scansm->pdu_data.adva;
|
|
/*
|
* Ignore scan response if AdvA does not match AdvA in request and also
|
* update backoff as if there was no scan response.
|
*/
|
if ((addrd->adva_type != sreq_adva_type) ||
|
memcmp(addrd->adva, sreq_adva, BLE_DEV_ADDR_LEN)) {
|
ble_ll_scan_req_backoff(scansm, 0);
|
return -1;
|
}
|
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PRIVACY)
|
/*
|
* We are not pushing this one through filters so need to update
|
* rpa_index here as otherwise pkt_in won't be able to determine
|
* advertiser address properly.
|
*/
|
rxinfo->rpa_index = ble_hw_resolv_list_match();
|
if (rxinfo->rpa_index >= 0) {
|
rxinfo->flags |= BLE_MBUF_HDR_F_RESOLVED;
|
}
|
#endif
|
|
rxinfo->flags |= BLE_MBUF_HDR_F_DEVMATCH;
|
|
return 0;
|
}
|
|
static bool
|
ble_ll_scan_send_scan_req(uint8_t pdu_type, uint8_t *rxbuf,
|
struct ble_mbuf_hdr *hdr,
|
struct ble_ll_scan_addr_data *addrd)
|
{
|
struct ble_ll_scan_sm *scansm = &g_ble_ll_scan_sm;
|
struct ble_mbuf_hdr_rxinfo *rxinfo = &hdr->rxinfo;
|
bool is_ext_adv = false;
|
int8_t rpa_index;
|
uint16_t adi = 0;
|
int rc;
|
|
/* Check if we already scanned this device successfully */
|
if (ble_ll_scan_have_rxd_scan_rsp(addrd->adv_addr, addrd->adv_addr_type,
|
is_ext_adv, adi)) {
|
return false;
|
}
|
|
/* Better not be a scan response pending */
|
BLE_LL_ASSERT(scansm->scan_rsp_pending == 0);
|
|
/* We want to send a request. See if backoff allows us */
|
if (scansm->backoff_count > 0) {
|
if (--scansm->backoff_count != 0) {
|
return false;
|
}
|
}
|
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PRIVACY)
|
rpa_index = addrd->rpa_index;
|
#else
|
rpa_index = -1;
|
#endif
|
|
/* Use original AdvA in scan request (Core 5.1, Vol 6, Part B, section 6.3) */
|
ble_ll_scan_req_pdu_prepare(scansm, addrd->adva, addrd->adva_type,
|
rpa_index);
|
|
rc = ble_phy_tx(ble_ll_scan_req_tx_pdu_cb, scansm, BLE_PHY_TRANSITION_TX_RX);
|
if (rc) {
|
return false;
|
}
|
|
scansm->scan_rsp_pending = 1;
|
rxinfo->flags |= BLE_MBUF_HDR_F_SCAN_REQ_TXD;
|
|
return true;
|
}
|
|
/**
|
* Called when a receive PDU has ended.
|
*
|
* Context: Interrupt
|
*
|
* @param rxpdu
|
*
|
* @return int
|
* < 0: Disable the phy after reception.
|
* == 0: Success. Do not disable the PHY.
|
* > 0: Do not disable PHY as that has already been done.
|
*/
|
int
|
ble_ll_scan_rx_isr_end(struct os_mbuf *rxpdu, uint8_t crcok)
|
{
|
struct ble_ll_scan_sm *scansm = &g_ble_ll_scan_sm;
|
struct ble_mbuf_hdr *hdr = BLE_MBUF_HDR_PTR(rxpdu);
|
struct ble_mbuf_hdr_rxinfo *rxinfo = &hdr->rxinfo;
|
uint8_t *rxbuf;
|
uint8_t pdu_type;
|
struct ble_ll_scan_addr_data addrd;
|
int rc;
|
|
/*
|
* If buffer for incoming PDU was not allocated we need to force scan to be
|
* restarted since LL will not be notified. Keep PHY enabled.
|
*/
|
if (rxpdu == NULL) {
|
ble_ll_scan_interrupted(scansm);
|
return 0;
|
}
|
|
if (!crcok) {
|
goto scan_rx_isr_ignore;
|
}
|
|
rxbuf = rxpdu->om_data;
|
pdu_type = rxbuf[0] & BLE_ADV_PDU_HDR_TYPE_MASK;
|
|
switch (pdu_type) {
|
case BLE_ADV_PDU_TYPE_ADV_IND:
|
case BLE_ADV_PDU_TYPE_ADV_DIRECT_IND:
|
case BLE_ADV_PDU_TYPE_ADV_NONCONN_IND:
|
case BLE_ADV_PDU_TYPE_ADV_SCAN_IND:
|
rc = ble_ll_scan_rx_isr_end_on_adv(pdu_type, rxbuf, hdr, &addrd);
|
break;
|
case BLE_ADV_PDU_TYPE_SCAN_RSP:
|
rc = ble_ll_scan_rx_isr_end_on_scan_rsp(pdu_type, rxbuf, hdr, &addrd);
|
break;
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV)
|
case BLE_ADV_PDU_TYPE_ADV_EXT_IND:
|
rc = ble_ll_scan_aux_rx_isr_end_on_ext(&g_ble_ll_scan_sm, rxpdu);
|
if (rc < 0) {
|
rxinfo->flags |= BLE_MBUF_HDR_F_IGNORED;
|
}
|
ble_ll_state_set(BLE_LL_STATE_STANDBY);
|
/* Return here, we do not want any further processing since it's all
|
* handled in scan_aux.
|
*/
|
return -1;
|
#endif
|
default:
|
/* This is not something we would like to process here */
|
rc = -1;
|
break;
|
}
|
|
if (rc == -1) {
|
goto scan_rx_isr_ignore;
|
}
|
|
if (rc == 1) {
|
switch (scansm->scanp->scan_type) {
|
case BLE_SCAN_TYPE_ACTIVE:
|
if (ble_ll_scan_send_scan_req(pdu_type, rxbuf, hdr, &addrd)) {
|
/* Keep PHY active and LL in scanning state */
|
return 0;
|
}
|
break;
|
#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL)
|
case BLE_SCAN_TYPE_INITIATE:
|
if (ble_ll_conn_send_connect_req(rxpdu, &addrd, 0) == 0) {
|
hdr->rxinfo.flags |= BLE_MBUF_HDR_F_CONNECT_IND_TXD;
|
return 0;
|
}
|
break;
|
#endif
|
}
|
}
|
|
/* We are done with this PDU so go to standby and let LL resume if needed */
|
ble_ll_state_set(BLE_LL_STATE_STANDBY);
|
return -1;
|
|
scan_rx_isr_ignore:
|
rxinfo->flags |= BLE_MBUF_HDR_F_IGNORED;
|
ble_ll_state_set(BLE_LL_STATE_STANDBY);
|
return -1;
|
}
|
|
/**
|
* Called to resume scanning. This is called after an advertising event or
|
* connection event has ended. It is also called if we receive a packet while
|
* in the initiating or scanning state.
|
*
|
* If periodic advertising is enabled this is also called on sync event end
|
* or sync packet received if chaining
|
*
|
* Context: Link Layer task
|
*/
|
void
|
ble_ll_scan_chk_resume(void)
|
{
|
os_sr_t sr;
|
struct ble_ll_scan_sm *scansm;
|
uint32_t now;
|
|
scansm = &g_ble_ll_scan_sm;
|
if (scansm->scan_enabled) {
|
OS_ENTER_CRITICAL(sr);
|
if (scansm->restart_timer_needed) {
|
scansm->restart_timer_needed = 0;
|
ble_ll_event_send(&scansm->scan_sched_ev);
|
STATS_INC(ble_ll_stats, scan_timer_restarted);
|
OS_EXIT_CRITICAL(sr);
|
return;
|
}
|
|
now = ble_ll_tmr_get();
|
if (ble_ll_state_get() == BLE_LL_STATE_STANDBY &&
|
ble_ll_scan_is_inside_window(scansm->scanp, now)) {
|
/* Turn on the receiver and set state */
|
ble_ll_scan_start(scansm);
|
}
|
OS_EXIT_CRITICAL(sr);
|
}
|
}
|
|
/**
|
* Scan timer callback; means that the scan window timeout has been reached
|
* and we should perform the appropriate actions.
|
*
|
* Context: Interrupt (cputimer)
|
*
|
* @param arg Pointer to scan state machine.
|
*/
|
void
|
ble_ll_scan_timer_cb(void *arg)
|
{
|
struct ble_ll_scan_sm *scansm;
|
|
scansm = (struct ble_ll_scan_sm *)arg;
|
ble_ll_event_send(&scansm->scan_sched_ev);
|
}
|
|
void
|
ble_ll_scan_interrupted(struct ble_ll_scan_sm *scansm)
|
{
|
ble_ll_event_send(&scansm->scan_interrupted_ev);
|
}
|
|
/**
|
* Called when the wait for response timer expires while in the scanning
|
* state.
|
*
|
* Context: Interrupt.
|
*/
|
void
|
ble_ll_scan_wfr_timer_exp(void)
|
{
|
struct ble_ll_scan_sm *scansm = &g_ble_ll_scan_sm;
|
|
/* Update backoff if we failed to receive scan response */
|
if (scansm->scan_rsp_pending) {
|
scansm->scan_rsp_pending = 0;
|
ble_ll_scan_req_backoff(scansm, 0);
|
}
|
|
ble_phy_restart_rx();
|
}
|
|
static inline void
|
ble_ll_scan_dup_move_to_head(struct ble_ll_scan_dup_entry *e)
|
{
|
if (e != TAILQ_FIRST(&g_scan_dup_list)) {
|
TAILQ_REMOVE(&g_scan_dup_list, e, link);
|
TAILQ_INSERT_HEAD(&g_scan_dup_list, e, link);
|
}
|
}
|
|
static inline struct ble_ll_scan_dup_entry *
|
ble_ll_scan_dup_new(void)
|
{
|
struct ble_ll_scan_dup_entry *e;
|
|
e = os_memblock_get(&g_scan_dup_pool);
|
if (!e) {
|
e = TAILQ_LAST(&g_scan_dup_list, ble_ll_scan_dup_list);
|
TAILQ_REMOVE(&g_scan_dup_list, e, link);
|
}
|
|
memset(e, 0, sizeof(*e));
|
|
return e;
|
}
|
|
static int
|
ble_ll_scan_dup_check_legacy(uint8_t addr_type, uint8_t *addr, uint8_t pdu_type)
|
{
|
struct ble_ll_scan_dup_entry *e;
|
uint8_t type;
|
int rc;
|
|
type = BLE_LL_SCAN_ENTRY_TYPE_LEGACY(addr_type);
|
|
TAILQ_FOREACH(e, &g_scan_dup_list, link) {
|
if ((e->type == type) && !memcmp(e->addr, addr, 6)) {
|
break;
|
}
|
}
|
|
if (e) {
|
if (pdu_type == BLE_ADV_PDU_TYPE_ADV_DIRECT_IND) {
|
rc = e->flags & BLE_LL_SCAN_DUP_F_DIR_ADV_REPORT_SENT;
|
} else if (pdu_type == BLE_ADV_PDU_TYPE_SCAN_RSP) {
|
rc = e->flags & BLE_LL_SCAN_DUP_F_SCAN_RSP_SENT;
|
} else {
|
rc = e->flags & BLE_LL_SCAN_DUP_F_ADV_REPORT_SENT;
|
}
|
|
ble_ll_scan_dup_move_to_head(e);
|
} else {
|
rc = 0;
|
|
e = ble_ll_scan_dup_new();
|
e->flags = 0;
|
e->type = type;
|
memcpy(e->addr, addr, 6);
|
|
TAILQ_INSERT_HEAD(&g_scan_dup_list, e, link);
|
}
|
|
return rc;
|
}
|
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV)
|
int
|
ble_ll_scan_dup_check_ext(uint8_t addr_type, uint8_t *addr, bool has_aux,
|
uint16_t adi)
|
{
|
struct ble_ll_scan_dup_entry *e;
|
bool is_anon;
|
uint8_t type;
|
int rc;
|
|
is_anon = addr == NULL;
|
adi = has_aux ? adi : 0;
|
|
type = BLE_LL_SCAN_ENTRY_TYPE_EXT(addr_type, has_aux, is_anon, adi);
|
|
TAILQ_FOREACH(e, &g_scan_dup_list, link) {
|
if ((e->type == type) &&
|
(is_anon || !memcmp(e->addr, addr, BLE_DEV_ADDR_LEN))) {
|
break;
|
}
|
}
|
|
if (e) {
|
if (e->adi != adi) {
|
rc = 0;
|
|
e->flags = 0;
|
e->adi = adi;
|
} else {
|
rc = e->flags & BLE_LL_SCAN_DUP_F_ADV_REPORT_SENT;
|
}
|
|
ble_ll_scan_dup_move_to_head(e);
|
} else {
|
rc = 0;
|
|
e = ble_ll_scan_dup_new();
|
e->flags = 0;
|
e->type = type;
|
e->adi = adi;
|
if (!is_anon) {
|
memcpy(e->addr, addr, 6);
|
}
|
|
TAILQ_INSERT_HEAD(&g_scan_dup_list, e, link);
|
}
|
|
return rc;
|
}
|
|
int
|
ble_ll_scan_dup_update_ext(uint8_t addr_type, uint8_t *addr, bool has_aux,
|
uint16_t adi)
|
{
|
struct ble_ll_scan_dup_entry *e;
|
bool is_anon;
|
uint8_t type;
|
|
is_anon = addr == NULL;
|
adi = has_aux ? adi : 0;
|
|
type = BLE_LL_SCAN_ENTRY_TYPE_EXT(addr_type, has_aux, is_anon, adi);
|
|
/*
|
* We assume ble_ll_scan_dup_check() was called before which either matched
|
* some entry or allocated new one and placed in on the top of queue.
|
*/
|
|
e = TAILQ_FIRST(&g_scan_dup_list);
|
BLE_LL_ASSERT(e && e->type == type && (is_anon || !memcmp(e->addr, addr, 6)));
|
|
e->flags |= BLE_LL_SCAN_DUP_F_ADV_REPORT_SENT;
|
|
return 0;
|
}
|
#endif
|
|
static void
|
ble_ll_scan_rx_pkt_in_restore_addr_data(struct ble_mbuf_hdr *hdr,
|
struct ble_ll_scan_addr_data *addrd)
|
{
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PRIVACY)
|
struct ble_ll_scan_sm *scansm = &g_ble_ll_scan_sm;
|
struct ble_mbuf_hdr_rxinfo *rxinfo = &hdr->rxinfo;
|
struct ble_ll_resolv_entry *rl;
|
#endif
|
|
addrd->adv_addr = addrd->adva;
|
addrd->adv_addr_type = addrd->adva_type;
|
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PRIVACY)
|
addrd->rpa_index = rxinfo->rpa_index;
|
|
if (hdr->rxinfo.flags & BLE_MBUF_HDR_F_RESOLVED) {
|
BLE_LL_ASSERT(rxinfo->rpa_index >= 0);
|
rl = &g_ble_ll_resolv_list[rxinfo->rpa_index];
|
addrd->adv_addr = rl->rl_identity_addr;
|
addrd->adv_addr_type = rl->rl_addr_type;
|
addrd->adva_resolved = 1;
|
} else {
|
addrd->adva_resolved = 0;
|
}
|
|
if (hdr->rxinfo.flags & BLE_MBUF_HDR_F_TARGETA_RESOLVED) {
|
addrd->targeta = ble_ll_get_our_devaddr(scansm->own_addr_type & 1);
|
addrd->targeta_type = scansm->own_addr_type & 1;
|
addrd->targeta_resolved = 1;
|
} else {
|
addrd->targeta_resolved = 0;
|
}
|
#endif
|
}
|
|
static void
|
ble_ll_scan_rx_pkt_in_on_legacy(uint8_t pdu_type, struct os_mbuf *om,
|
struct ble_mbuf_hdr *hdr,
|
struct ble_ll_scan_addr_data *addrd)
|
{
|
struct ble_ll_scan_sm *scansm = &g_ble_ll_scan_sm;
|
uint8_t *rxbuf = om->om_data;
|
bool send_hci_report;
|
|
|
if (!BLE_MBUF_HDR_DEVMATCH(hdr) ||
|
!BLE_MBUF_HDR_CRC_OK(hdr) ||
|
BLE_MBUF_HDR_IGNORED(hdr) ||
|
!scansm->scan_enabled) {
|
return;
|
}
|
|
ble_ll_scan_get_addr_data_from_legacy(pdu_type, rxbuf, addrd);
|
ble_ll_scan_rx_pkt_in_restore_addr_data(hdr, addrd);
|
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PRIVACY)
|
if (addrd->adva_resolved) {
|
BLE_LL_ASSERT(addrd->rpa_index >= 0);
|
ble_ll_resolv_set_peer_rpa(addrd->rpa_index, addrd->adva);
|
}
|
#endif
|
|
send_hci_report = !scansm->scan_filt_dups ||
|
!ble_ll_scan_dup_check_legacy(addrd->adv_addr_type,
|
addrd->adv_addr,
|
pdu_type);
|
if (send_hci_report) {
|
/* Sending advertising report will also update scan_dup list */
|
ble_ll_scan_send_adv_report(pdu_type,
|
addrd->adv_addr, addrd->adv_addr_type,
|
addrd->targeta, addrd->targeta_type,
|
om, hdr, scansm);
|
}
|
|
if (BLE_MBUF_HDR_SCAN_RSP_RXD(hdr)) {
|
ble_ll_scan_req_backoff(scansm, 1);
|
}
|
}
|
|
/**
|
* Process a received PDU while in the scanning state.
|
*
|
* Context: Link Layer task.
|
*
|
* @param pdu_type
|
* @param rxbuf
|
*/
|
void
|
ble_ll_scan_rx_pkt_in(uint8_t ptype, struct os_mbuf *om, struct ble_mbuf_hdr *hdr)
|
{
|
#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL)
|
struct ble_mbuf_hdr_rxinfo *rxinfo;
|
uint8_t *targeta;
|
#endif
|
struct ble_ll_scan_sm *scansm;
|
struct ble_ll_scan_addr_data addrd;
|
uint8_t max_pdu_type;
|
|
scansm = &g_ble_ll_scan_sm;
|
|
/* Ignore PDUs we do not expect here */
|
max_pdu_type = BLE_ADV_PDU_TYPE_ADV_SCAN_IND;
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV)
|
if (scansm->ext_scanning) {
|
/* Note: We do not expect AUX_CONNECT_RSP here */
|
max_pdu_type = BLE_ADV_PDU_TYPE_ADV_EXT_IND;
|
}
|
#endif
|
if (ptype > max_pdu_type) {
|
ble_ll_scan_chk_resume();
|
return;
|
}
|
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV)
|
if (ptype == BLE_ADV_PDU_TYPE_ADV_EXT_IND) {
|
ble_ll_scan_aux_pkt_in_on_ext(om, hdr);
|
ble_ll_scan_chk_resume();
|
return;
|
}
|
#endif
|
|
switch (scansm->scanp->scan_type) {
|
#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL)
|
case BLE_SCAN_TYPE_INITIATE:
|
rxinfo = &hdr->rxinfo;
|
if (rxinfo->flags & BLE_MBUF_HDR_F_CONNECT_IND_TXD) {
|
/* We need to keep original TargetA in case it was resolved, so rl
|
* can be updated properly.
|
*/
|
ble_ll_scan_get_addr_data_from_legacy(ptype, om->om_data, &addrd);
|
targeta = addrd.targeta;
|
ble_ll_scan_rx_pkt_in_restore_addr_data(hdr, &addrd);
|
|
ble_ll_scan_sm_stop(0);
|
ble_ll_conn_created_on_legacy(om, &addrd, targeta);
|
return;
|
}
|
break;
|
#endif
|
default:
|
ble_ll_scan_rx_pkt_in_on_legacy(ptype, om, hdr, &addrd);
|
break;
|
}
|
|
ble_ll_scan_chk_resume();
|
}
|
|
int
|
ble_ll_scan_hci_set_params(const uint8_t *cmdbuf, uint8_t len)
|
{
|
const struct ble_hci_le_set_scan_params_cp *cmd = (const void *)cmdbuf;
|
uint16_t scan_itvl;
|
uint16_t scan_window;
|
struct ble_ll_scan_sm *scansm;
|
struct ble_ll_scan_phy *scanp;
|
|
if (len != sizeof(*cmd)) {
|
return BLE_ERR_INV_HCI_CMD_PARMS;
|
}
|
|
/* If already enabled, we return an error */
|
scansm = &g_ble_ll_scan_sm;
|
if (scansm->scan_enabled) {
|
return BLE_ERR_CMD_DISALLOWED;
|
}
|
|
/* Get the scan interval and window */
|
scan_itvl = le16toh(cmd->scan_itvl);
|
scan_window = le16toh(cmd->scan_window);
|
|
/* Check scan type */
|
if ((cmd->scan_type != BLE_HCI_SCAN_TYPE_PASSIVE) &&
|
(cmd->scan_type != BLE_HCI_SCAN_TYPE_ACTIVE)) {
|
return BLE_ERR_INV_HCI_CMD_PARMS;
|
}
|
|
/* Check interval and window */
|
if ((scan_itvl < BLE_HCI_SCAN_ITVL_MIN) ||
|
(scan_itvl > BLE_HCI_SCAN_ITVL_MAX) ||
|
(scan_window < BLE_HCI_SCAN_WINDOW_MIN) ||
|
(scan_window > BLE_HCI_SCAN_WINDOW_MAX) ||
|
(scan_itvl < scan_window)) {
|
return BLE_ERR_INV_HCI_CMD_PARMS;
|
}
|
|
/* Check own addr type */
|
if (cmd->own_addr_type > BLE_HCI_ADV_OWN_ADDR_MAX) {
|
return BLE_ERR_INV_HCI_CMD_PARMS;
|
}
|
|
/* Check scanner filter policy */
|
if (cmd->filter_policy > BLE_HCI_SCAN_FILT_MAX) {
|
return BLE_ERR_INV_HCI_CMD_PARMS;
|
}
|
|
/* Store scan parameters */
|
g_ble_ll_scan_params.own_addr_type = cmd->own_addr_type;
|
g_ble_ll_scan_params.scan_filt_policy = cmd->filter_policy;
|
|
scanp = &g_ble_ll_scan_params.scan_phys[PHY_UNCODED];
|
scanp->configured = 1;
|
scanp->scan_type = cmd->scan_type;
|
scanp->timing.interval = ble_ll_scan_time_hci_to_ticks(scan_itvl);
|
scanp->timing.window = ble_ll_scan_time_hci_to_ticks(scan_window);
|
|
#if (BLE_LL_SCAN_PHY_NUMBER == 2)
|
scanp = &g_ble_ll_scan_params.scan_phys[PHY_CODED];
|
scanp->configured = 0;
|
#endif
|
|
return 0;
|
}
|
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV)
|
static int
|
ble_ll_scan_check_phy_params(uint8_t type, uint16_t itvl, uint16_t window)
|
{
|
/* Check scan type */
|
if ((type != BLE_HCI_SCAN_TYPE_PASSIVE) &&
|
(type != BLE_HCI_SCAN_TYPE_ACTIVE)) {
|
return BLE_ERR_INV_HCI_CMD_PARMS;
|
}
|
|
/* Check interval and window */
|
if ((itvl < BLE_HCI_SCAN_ITVL_MIN) ||
|
(itvl > BLE_HCI_SCAN_ITVL_MAX_EXT) ||
|
(window < BLE_HCI_SCAN_WINDOW_MIN) ||
|
(window > BLE_HCI_SCAN_WINDOW_MAX_EXT) ||
|
(itvl < window)) {
|
return BLE_ERR_INV_HCI_CMD_PARMS;
|
}
|
|
return 0;
|
}
|
|
int
|
ble_ll_scan_hci_set_ext_params(const uint8_t *cmdbuf, uint8_t len)
|
{
|
const struct ble_hci_le_set_ext_scan_params_cp *cmd = (const void *) cmdbuf;
|
const struct scan_params *params = cmd->scans;
|
|
struct ble_ll_scan_phy new_params[BLE_LL_SCAN_PHY_NUMBER] = { };
|
struct ble_ll_scan_phy *uncoded = &new_params[PHY_UNCODED];
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_CODED_PHY)
|
struct ble_ll_scan_phy *coded = &new_params[PHY_CODED];
|
#endif
|
uint16_t interval;
|
uint16_t window;
|
int rc;
|
|
if (len <= sizeof(*cmd)) {
|
return BLE_ERR_INV_HCI_CMD_PARMS;
|
}
|
|
len -= sizeof(*cmd);
|
|
/* If already enabled, we return an error */
|
if (g_ble_ll_scan_sm.scan_enabled) {
|
return BLE_ERR_CMD_DISALLOWED;
|
}
|
|
/* Check own addr type */
|
if (cmd->own_addr_type > BLE_HCI_ADV_OWN_ADDR_MAX) {
|
return BLE_ERR_INV_HCI_CMD_PARMS;
|
}
|
|
/* Check scanner filter policy */
|
if (cmd->filter_policy > BLE_HCI_SCAN_FILT_MAX) {
|
return BLE_ERR_INV_HCI_CMD_PARMS;
|
}
|
|
/* Check if no reserved bits in PHYS are set and that at least one valid PHY
|
* is set.
|
*/
|
if (!(cmd->phys & SCAN_VALID_PHY_MASK) ||
|
(cmd->phys & ~SCAN_VALID_PHY_MASK)) {
|
return BLE_ERR_INV_HCI_CMD_PARMS;
|
}
|
|
if (cmd->phys & BLE_HCI_LE_PHY_1M_PREF_MASK) {
|
if (len < sizeof(*params)) {
|
return BLE_ERR_INV_HCI_CMD_PARMS;
|
}
|
|
interval = le16toh(params->itvl);
|
window = le16toh(params->window);
|
|
rc = ble_ll_scan_check_phy_params(params->type, interval, window);
|
if (rc) {
|
return rc;
|
}
|
|
uncoded->scan_type = params->type;
|
uncoded->timing.interval = ble_ll_scan_time_hci_to_ticks(interval);
|
uncoded->timing.window = ble_ll_scan_time_hci_to_ticks(window);
|
|
/* That means user wants to use this PHY for scanning */
|
uncoded->configured = 1;
|
params++;
|
len -= sizeof(*params);
|
}
|
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_CODED_PHY)
|
if (cmd->phys & BLE_HCI_LE_PHY_CODED_PREF_MASK) {
|
if (len < sizeof(*params)) {
|
return BLE_ERR_INV_HCI_CMD_PARMS;
|
}
|
|
interval = le16toh(params->itvl);
|
window = le16toh(params->window);
|
|
rc = ble_ll_scan_check_phy_params(params->type, interval, window);
|
if (rc) {
|
return rc;
|
}
|
|
coded->scan_type = params->type;
|
coded->timing.interval = ble_ll_scan_time_hci_to_ticks(interval);
|
coded->timing.window = ble_ll_scan_time_hci_to_ticks(window);
|
|
/* That means user wants to use this PHY for scanning */
|
coded->configured = 1;
|
}
|
|
/* if any of PHYs is configured for continuous scan we alter interval to
|
* fit other PHY
|
*/
|
if (coded->configured && uncoded->configured) {
|
if (coded->timing.interval == coded->timing.window) {
|
coded->timing.interval += uncoded->timing.window;
|
}
|
|
if (uncoded->timing.interval == uncoded->timing.window) {
|
uncoded->timing.interval += coded->timing.window;
|
}
|
}
|
#endif
|
|
g_ble_ll_scan_params.own_addr_type = cmd->own_addr_type;
|
g_ble_ll_scan_params.scan_filt_policy = cmd->filter_policy;
|
|
memcpy(g_ble_ll_scan_params.scan_phys, new_params, sizeof(new_params));
|
|
return 0;
|
}
|
|
#endif
|
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV)
|
static void
|
ble_ll_scan_duration_period_timers_restart(struct ble_ll_scan_sm *scansm)
|
{
|
ble_npl_callout_stop(&scansm->duration_timer);
|
ble_npl_callout_stop(&scansm->period_timer);
|
|
if (scansm->duration_ticks) {
|
ble_npl_callout_reset(&scansm->duration_timer,
|
scansm->duration_ticks);
|
|
if (scansm->period_ticks) {
|
ble_npl_callout_reset(&scansm->period_timer,
|
scansm->period_ticks);
|
}
|
}
|
}
|
|
static void
|
ble_ll_scan_duration_timer_cb(struct ble_npl_event *ev)
|
{
|
struct ble_ll_scan_sm *scansm = ble_npl_event_get_arg(ev);
|
|
ble_ll_scan_sm_stop(2);
|
|
/* if period is set both timers get started from period cb */
|
if (!scansm->period_ticks) {
|
ble_ll_hci_ev_send_scan_timeout();
|
}
|
}
|
|
static void
|
ble_ll_scan_period_timer_cb(struct ble_npl_event *ev)
|
{
|
struct ble_ll_scan_sm *scansm = ble_npl_event_get_arg(ev);
|
|
ble_ll_scan_sm_start(scansm);
|
|
/* always start timer regardless of ble_ll_scan_sm_start result
|
* if it failed will restart in next period
|
*/
|
ble_ll_scan_duration_period_timers_restart(scansm);
|
}
|
#endif
|
|
/**
|
* ble ll scan set enable
|
*
|
* HCI scan set enable command processing function
|
*
|
* Context: Link Layer task (HCI Command parser).
|
*
|
* @return int BLE error code.
|
*/
|
static int
|
ble_ll_scan_set_enable(uint8_t enable, uint8_t filter_dups, uint16_t period,
|
uint16_t dur, bool ext)
|
{
|
int rc;
|
struct ble_ll_scan_sm *scansm;
|
struct ble_ll_scan_phy *scanp;
|
struct ble_ll_scan_phy *scanp_phy;
|
int i;
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV)
|
ble_npl_time_t period_ticks = 0;
|
ble_npl_time_t dur_ticks = 0;
|
#endif
|
|
/* Check for valid parameters */
|
if ((filter_dups > 1) || (enable > 1)) {
|
return BLE_ERR_INV_HCI_CMD_PARMS;
|
}
|
|
scansm = &g_ble_ll_scan_sm;
|
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV)
|
/* we can do that here since value will never change until reset */
|
scansm->ext_scanning = ext;
|
|
if (ext) {
|
/* Period parameter is ignored when the Duration parameter is zero */
|
if (!dur) {
|
period = 0;
|
}
|
|
/* period is in 1.28 sec units */
|
if (ble_npl_time_ms_to_ticks(period * 1280, &period_ticks)) {
|
return BLE_ERR_INV_HCI_CMD_PARMS;
|
}
|
|
/* duration is in 10ms units */
|
dur_ticks = ble_npl_time_ms_to_ticks32(dur * 10);
|
|
if (dur_ticks && period_ticks && (dur_ticks >= period_ticks)) {
|
return BLE_ERR_INV_HCI_CMD_PARMS;
|
}
|
}
|
#endif
|
|
/* disable*/
|
if (!enable) {
|
if (scansm->scan_enabled) {
|
ble_ll_scan_sm_stop(1);
|
}
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV)
|
ble_npl_callout_stop(&scansm->duration_timer);
|
ble_npl_callout_stop(&scansm->period_timer);
|
#endif
|
|
return BLE_ERR_SUCCESS;
|
}
|
|
/* if already enable we just need to update parameters */
|
if (scansm->scan_enabled) {
|
/* Controller does not allow initiating and scanning.*/
|
#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL)
|
for (i = 0; i < BLE_LL_SCAN_PHY_NUMBER; i++) {
|
scanp_phy = &scansm->scan_phys[i];
|
if (scanp_phy->configured &&
|
scanp_phy->scan_type == BLE_SCAN_TYPE_INITIATE) {
|
return BLE_ERR_CMD_DISALLOWED;
|
}
|
}
|
#endif
|
|
#if MYNEWT_VAL(BLE_LL_NUM_SCAN_DUP_ADVS)
|
/* update filter policy */
|
scansm->scan_filt_dups = filter_dups;
|
#endif
|
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV)
|
/* restart timers according to new settings */
|
scansm->duration_ticks = dur_ticks;
|
scansm->period_ticks = period_ticks;
|
ble_ll_scan_duration_period_timers_restart(scansm);
|
#endif
|
|
return BLE_ERR_SUCCESS;
|
}
|
|
/* we can store those upfront regardless of start scan result since scan is
|
* disabled now
|
*/
|
|
#if MYNEWT_VAL(BLE_LL_NUM_SCAN_DUP_ADVS)
|
scansm->scan_filt_dups = filter_dups;
|
#endif
|
scansm->scanp = NULL;
|
scansm->scanp_next = NULL;
|
|
scansm->own_addr_type = g_ble_ll_scan_params.own_addr_type;
|
scansm->scan_filt_policy = g_ble_ll_scan_params.scan_filt_policy;
|
|
for (i = 0; i < BLE_LL_SCAN_PHY_NUMBER; i++) {
|
scanp_phy = &scansm->scan_phys[i];
|
scanp = &g_ble_ll_scan_params.scan_phys[i];
|
|
if (!scanp->configured) {
|
continue;
|
}
|
|
scanp_phy->configured = scanp->configured;
|
scanp_phy->scan_type = scanp->scan_type;
|
scanp_phy->timing = scanp->timing;
|
|
if (!scansm->scanp) {
|
scansm->scanp = scanp_phy;
|
} else {
|
scansm->scanp_next = scanp_phy;
|
}
|
}
|
|
/* spec is not really clear if we should use defaults in this case
|
* or just disallow starting scan without explicit configuration
|
* For now be nice to host and just use values based on LE Set Scan
|
* Parameters defaults.
|
*/
|
if (!scansm->scanp) {
|
scansm->scanp = &scansm->scan_phys[PHY_UNCODED];
|
scansm->own_addr_type = BLE_ADDR_PUBLIC;
|
scansm->scan_filt_policy = BLE_HCI_SCAN_FILT_NO_WL;
|
|
scanp_phy = scansm->scanp;
|
scanp_phy->configured = 1;
|
scanp_phy->scan_type = BLE_SCAN_TYPE_PASSIVE;
|
scanp_phy->timing.interval =
|
ble_ll_scan_time_hci_to_ticks(BLE_HCI_SCAN_ITVL_DEF);
|
scanp_phy->timing.window =
|
ble_ll_scan_time_hci_to_ticks(BLE_HCI_SCAN_WINDOW_DEF);
|
}
|
|
rc = ble_ll_scan_sm_start(scansm);
|
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV)
|
if (rc == BLE_ERR_SUCCESS) {
|
scansm->duration_ticks = dur_ticks;
|
scansm->period_ticks = period_ticks;
|
ble_ll_scan_duration_period_timers_restart(scansm);
|
}
|
#endif
|
|
return rc;
|
}
|
|
int ble_ll_scan_hci_set_enable(const uint8_t *cmdbuf, uint8_t len)
|
{
|
const struct ble_hci_le_set_scan_enable_cp *cmd = (const void *) cmdbuf;
|
|
if (len != sizeof(*cmd)) {
|
return BLE_ERR_INV_HCI_CMD_PARMS;
|
}
|
|
return ble_ll_scan_set_enable(cmd->enable, cmd->filter_duplicates, 0, 0,
|
false);
|
}
|
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV)
|
int ble_ll_scan_hci_set_ext_enable(const uint8_t *cmdbuf, uint8_t len)
|
{
|
const struct ble_hci_le_set_ext_scan_enable_cp *cmd = (const void *) cmdbuf;
|
|
if (len != sizeof(*cmd)) {
|
return BLE_ERR_INV_HCI_CMD_PARMS;
|
}
|
|
return ble_ll_scan_set_enable(cmd->enable, cmd->filter_dup,
|
le16toh(cmd->period), le16toh(cmd->duration),
|
true);
|
}
|
#endif
|
|
/**
|
* Checks if controller can change the whitelist. If scanning is enabled and
|
* using the whitelist the controller is not allowed to change the whitelist.
|
*
|
* @return int 0: not allowed to change whitelist; 1: change allowed.
|
*/
|
int
|
ble_ll_scan_can_chg_whitelist(void)
|
{
|
int rc;
|
struct ble_ll_scan_sm *scansm;
|
|
scansm = &g_ble_ll_scan_sm;
|
if (scansm->scan_enabled && (scansm->scan_filt_policy & 1)) {
|
rc = 0;
|
} else {
|
rc = 1;
|
}
|
|
return rc;
|
}
|
|
#if MYNEWT_VAL(BLE_LL_ROLE_CENTRAL)
|
int
|
ble_ll_scan_initiator_start(struct ble_ll_conn_sm *connsm, uint8_t ext,
|
struct ble_ll_conn_create_scan *cc_scan)
|
{
|
struct ble_ll_scan_sm *scansm;
|
struct ble_ll_scan_phy *scanp_uncoded;
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV) && MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_CODED_PHY)
|
struct ble_ll_scan_phy *scanp_coded;
|
#endif
|
uint8_t init_phy_mask;
|
int rc;
|
|
scansm = &g_ble_ll_scan_sm;
|
scansm->own_addr_type = cc_scan->own_addr_type;
|
scansm->scan_filt_policy = cc_scan->filter_policy;
|
scansm->scanp = NULL;
|
scansm->scanp_next = NULL;
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV)
|
scansm->ext_scanning = ext;
|
init_phy_mask = cc_scan->init_phy_mask;
|
#else
|
init_phy_mask = BLE_PHY_MASK_1M;
|
#endif
|
scansm->connsm = connsm;
|
|
scanp_uncoded = &scansm->scan_phys[PHY_UNCODED];
|
if (init_phy_mask & BLE_PHY_MASK_1M) {
|
scanp_uncoded->configured = 1;
|
scanp_uncoded->timing.interval = ble_ll_scan_time_hci_to_ticks(
|
cc_scan->scan_params[PHY_UNCODED].itvl);
|
scanp_uncoded->timing.window = ble_ll_scan_time_hci_to_ticks(
|
cc_scan->scan_params[PHY_UNCODED].window);
|
scanp_uncoded->scan_type = BLE_SCAN_TYPE_INITIATE;
|
scansm->scanp = scanp_uncoded;
|
} else {
|
scanp_uncoded->configured = 0;
|
}
|
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV) && MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_CODED_PHY)
|
scanp_coded = &scansm->scan_phys[PHY_CODED];
|
if (init_phy_mask & BLE_PHY_MASK_CODED) {
|
scanp_coded->configured = 1;
|
scanp_coded->timing.interval = ble_ll_scan_time_hci_to_ticks(
|
cc_scan->scan_params[PHY_CODED].itvl);
|
scanp_coded->timing.window = ble_ll_scan_time_hci_to_ticks(
|
cc_scan->scan_params[PHY_CODED].window);
|
scanp_coded->scan_type = BLE_SCAN_TYPE_INITIATE;
|
if (scansm->scanp) {
|
scansm->scanp_next = scanp_coded;
|
} else {
|
scansm->scanp = scanp_coded;
|
}
|
} else {
|
scanp_coded->configured = 0;
|
}
|
|
/* if any of PHYs is configured for continuous scan we alter interval to
|
* fit other PHY
|
*/
|
if (scansm->scanp && scansm->scanp_next && scanp_coded->configured &&
|
scanp_uncoded->configured) {
|
if (scanp_coded->timing.interval == scanp_coded->timing.window) {
|
scanp_coded->timing.interval += scanp_uncoded->timing.window;
|
}
|
|
if (scanp_uncoded->timing.interval == scanp_uncoded->timing.window) {
|
scanp_uncoded->timing.interval += scanp_coded->timing.window;
|
}
|
}
|
#endif
|
|
rc = ble_ll_scan_sm_start(scansm);
|
if (rc == 0) {
|
g_ble_ll_conn_create_sm.connsm = connsm;
|
}
|
|
return rc;
|
}
|
#endif
|
|
/**
|
* Checks to see if the scanner is enabled.
|
*
|
* @return int 0: not enabled; enabled otherwise
|
*/
|
int
|
ble_ll_scan_enabled(void)
|
{
|
return (int)g_ble_ll_scan_sm.scan_enabled;
|
}
|
|
/**
|
* Returns the peer resolvable private address of last device connecting to us
|
*
|
* @return uint8_t*
|
*/
|
uint8_t *
|
ble_ll_scan_get_peer_rpa(void)
|
{
|
struct ble_ll_scan_sm *scansm;
|
|
/* XXX: should this go into IRK list or connection? */
|
scansm = &g_ble_ll_scan_sm;
|
return scansm->scan_peer_rpa;
|
}
|
|
/**
|
* Returns the local resolvable private address currently being using by
|
* the scanner/initiator
|
*
|
* @return uint8_t*
|
*/
|
uint8_t *
|
ble_ll_scan_get_local_rpa(void)
|
{
|
return g_ble_ll_scan_sm.pdu_data.scana;
|
}
|
|
/**
|
* Set the Resolvable Private Address in the scanning (or initiating) state
|
* machine.
|
*
|
* XXX: should this go into IRK list or connection?
|
*
|
* @param rpa
|
*/
|
void
|
ble_ll_scan_set_peer_rpa(uint8_t *rpa)
|
{
|
struct ble_ll_scan_sm *scansm;
|
|
scansm = &g_ble_ll_scan_sm;
|
memcpy(scansm->scan_peer_rpa, rpa, BLE_DEV_ADDR_LEN);
|
}
|
|
struct ble_ll_scan_pdu_data *
|
ble_ll_scan_get_pdu_data(void)
|
{
|
return &g_ble_ll_scan_sm.pdu_data;
|
}
|
|
static void
|
ble_ll_scan_common_init(void)
|
{
|
struct ble_ll_scan_sm *scansm;
|
struct ble_ll_scan_phy *scanp;
|
int i;
|
|
/* Clear state machine in case re-initialized */
|
scansm = &g_ble_ll_scan_sm;
|
memset(scansm, 0, sizeof(struct ble_ll_scan_sm));
|
|
/* Clear scan parameters in case re-initialized */
|
memset(&g_ble_ll_scan_params, 0, sizeof(g_ble_ll_scan_params));
|
|
/* Initialize scanning window end event */
|
ble_npl_event_init(&scansm->scan_sched_ev, ble_ll_scan_event_proc, scansm);
|
|
for (i = 0; i < BLE_LL_SCAN_PHY_NUMBER; i++) {
|
/* Set all non-zero default parameters */
|
scanp = &g_ble_ll_scan_params.scan_phys[i];
|
scanp->timing.interval =
|
ble_ll_scan_time_hci_to_ticks(BLE_HCI_SCAN_ITVL_DEF);
|
scanp->timing.window =
|
ble_ll_scan_time_hci_to_ticks(BLE_HCI_SCAN_WINDOW_DEF);
|
}
|
|
scansm->scan_phys[PHY_UNCODED].phy = BLE_PHY_1M;
|
#if (BLE_LL_SCAN_PHY_NUMBER == 2)
|
scansm->scan_phys[PHY_CODED].phy = BLE_PHY_CODED;
|
#endif
|
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PRIVACY)
|
/* Make sure we'll generate new NRPA if necessary */
|
scansm->scan_nrpa_timer = ble_npl_time_get();
|
#endif
|
|
/* Initialize scanning timer */
|
ble_ll_tmr_init(&scansm->scan_timer, ble_ll_scan_timer_cb, scansm);
|
|
/* Initialize extended scan timers */
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV)
|
ble_npl_callout_init(&scansm->duration_timer, &g_ble_ll_data.ll_evq,
|
ble_ll_scan_duration_timer_cb, scansm);
|
ble_npl_callout_init(&scansm->period_timer, &g_ble_ll_data.ll_evq,
|
ble_ll_scan_period_timer_cb, scansm);
|
#endif
|
|
ble_npl_event_init(&scansm->scan_interrupted_ev, ble_ll_scan_interrupted_event_cb, NULL);
|
}
|
|
/**
|
* Called when the controller receives the reset command. Resets the
|
* scanning state machine to its initial state.
|
*
|
* @return int
|
*/
|
void
|
ble_ll_scan_reset(void)
|
{
|
struct ble_ll_scan_sm *scansm;
|
|
scansm = &g_ble_ll_scan_sm;
|
|
/* If enabled, stop it. */
|
if (scansm->scan_enabled) {
|
ble_ll_scan_sm_stop(0);
|
}
|
|
/* stop extended scan timers */
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV)
|
ble_npl_callout_stop(&scansm->duration_timer);
|
ble_npl_callout_stop(&scansm->period_timer);
|
#endif
|
|
/* Reset duplicate advertisers and those from which we rxd a response */
|
g_ble_ll_scan_num_rsp_advs = 0;
|
memset(&g_ble_ll_scan_rsp_advs[0], 0, sizeof(g_ble_ll_scan_rsp_advs));
|
|
os_mempool_clear(&g_scan_dup_pool);
|
TAILQ_INIT(&g_scan_dup_list);
|
|
/* Call the common init function again */
|
ble_ll_scan_common_init();
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV)
|
ble_ll_scan_aux_init();
|
#endif
|
}
|
|
/**
|
* ble ll scan init
|
*
|
* Initialize a scanner. Must be called before scanning can be started.
|
* Expected to be called with a un-initialized scanning state machine.
|
*/
|
void
|
ble_ll_scan_init(void)
|
{
|
os_error_t err;
|
|
err = os_mempool_init(&g_scan_dup_pool,
|
MYNEWT_VAL(BLE_LL_NUM_SCAN_DUP_ADVS),
|
sizeof(struct ble_ll_scan_dup_entry),
|
g_scan_dup_mem,
|
"ble_ll_scan_dup_pool");
|
BLE_LL_ASSERT(err == 0);
|
|
TAILQ_INIT(&g_scan_dup_list);
|
|
ble_ll_scan_common_init();
|
#if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_EXT_ADV)
|
ble_ll_scan_aux_init();
|
#endif
|
}
|
|
#endif
|
