You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@mynewt.apache.org by we...@apache.org on 2016/02/10 08:12:54 UTC
[2/2] incubator-mynewt-larva git commit: Remove scanning events from
the scheduler as the code was just too ugly. Scanning is started/stopped from
link layer task
Remove scanning events from the scheduler as the code was just too ugly. Scanning is started/stopped from link layer task
Project: http://git-wip-us.apache.org/repos/asf/incubator-mynewt-larva/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-mynewt-larva/commit/425a9254
Tree: http://git-wip-us.apache.org/repos/asf/incubator-mynewt-larva/tree/425a9254
Diff: http://git-wip-us.apache.org/repos/asf/incubator-mynewt-larva/diff/425a9254
Branch: refs/heads/master
Commit: 425a9254eb3b860cd5239bb8f616f89dff214864
Parents: 8a8b601
Author: wes3 <wi...@micosa.io>
Authored: Tue Feb 9 23:12:26 2016 -0800
Committer: wes3 <wi...@micosa.io>
Committed: Tue Feb 9 23:12:42 2016 -0800
----------------------------------------------------------------------
.../controller/include/controller/ble_ll_scan.h | 4 +-
.../include/controller/ble_ll_sched.h | 3 -
net/nimble/controller/src/ble_ll_scan.c | 269 ++++++++-----------
net/nimble/controller/src/ble_ll_sched.c | 259 +++++-------------
4 files changed, 178 insertions(+), 357 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-larva/blob/425a9254/net/nimble/controller/include/controller/ble_ll_scan.h
----------------------------------------------------------------------
diff --git a/net/nimble/controller/include/controller/ble_ll_scan.h b/net/nimble/controller/include/controller/ble_ll_scan.h
index 7d690d8..5e3632b 100644
--- a/net/nimble/controller/include/controller/ble_ll_scan.h
+++ b/net/nimble/controller/include/controller/ble_ll_scan.h
@@ -21,6 +21,7 @@
#define H_BLE_LL_SCAN_
#include "controller/ble_ll_sched.h"
+#include "hal/hal_cputime.h"
/*
* Configuration items for the number of duplicate advertisers and the
@@ -82,11 +83,10 @@ struct ble_ll_scan_sm
uint16_t backoff_count;
uint16_t scan_itvl;
uint16_t scan_window;
- uint32_t last_sched_time;
uint32_t scan_win_start_time;
struct os_mbuf *scan_req_pdu;
struct os_event scan_sched_ev;
- struct ble_ll_sched_item scan_sch;
+ struct cpu_timer scan_timer;
};
/* Scan types */
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-larva/blob/425a9254/net/nimble/controller/include/controller/ble_ll_sched.h
----------------------------------------------------------------------
diff --git a/net/nimble/controller/include/controller/ble_ll_sched.h b/net/nimble/controller/include/controller/ble_ll_sched.h
index c773460..7fe2b06 100644
--- a/net/nimble/controller/include/controller/ble_ll_sched.h
+++ b/net/nimble/controller/include/controller/ble_ll_sched.h
@@ -79,9 +79,6 @@ int ble_ll_sched_adv_reschedule(struct ble_ll_sched_item *sch);
/* Reschedule a connection that had previously been scheduled or that is over */
int ble_ll_sched_conn_reschedule(struct ble_ll_conn_sm * connsm);
-/* Schedule a scanning schedule item (start or stop) */
-void ble_ll_sched_scan(struct ble_ll_sched_item *sch);
-
/* Stop the scheduler */
void ble_ll_sched_stop(void);
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-larva/blob/425a9254/net/nimble/controller/src/ble_ll_scan.c
----------------------------------------------------------------------
diff --git a/net/nimble/controller/src/ble_ll_scan.c b/net/nimble/controller/src/ble_ll_scan.c
index 1a79855..ada4407 100644
--- a/net/nimble/controller/src/ble_ll_scan.c
+++ b/net/nimble/controller/src/ble_ll_scan.c
@@ -48,11 +48,6 @@
* 3) 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.
- *
- * 4) The current way I do things, it is possible that keep rescheduling the
- * scanning item but never get a chance to execute it. This means that the
- * last scan win start time could get really old. If we keep the current
- * way of doing things we will need to address this issue.
*/
/* The scanning state machine global object */
@@ -63,7 +58,6 @@ struct ble_ll_scan_stats
{
uint32_t scan_starts;
uint32_t scan_stops;
- uint32_t scan_event_misses;
uint32_t scan_req_txf;
uint32_t scan_req_txg;
};
@@ -493,15 +487,15 @@ ble_ll_scan_chk_filter_policy(uint8_t pdu_type, uint8_t *rxbuf, uint8_t flags)
}
/**
- * Schedule callback for the start of a scan window
+ * Called to enable the receiver for scanning.
*
- * Context: Interrupt
+ * Context: Link Layer task
*
* @param sch
*
* @return int
*/
-static int
+static void
ble_ll_scan_start(struct ble_ll_scan_sm *scansm, uint8_t chan)
{
int rc;
@@ -518,49 +512,19 @@ ble_ll_scan_start(struct ble_ll_scan_sm *scansm, uint8_t chan)
/* Start receiving */
rc = ble_phy_rx();
- if (rc) {
- rc = BLE_LL_SCHED_STATE_DONE;
- } else {
+ if (!rc) {
/* Set link layer state to scanning */
if (scansm->scan_type == BLE_SCAN_TYPE_INITIATE) {
ble_ll_state_set(BLE_LL_STATE_INITIATING);
} else {
ble_ll_state_set(BLE_LL_STATE_SCANNING);
}
-
- /* Set end time to end of scan window */
- rc = BLE_LL_SCHED_STATE_RUNNING;
}
/* If there is a still a scan response pending, we have failed! */
if (scansm->scan_rsp_pending) {
ble_ll_scan_req_backoff(scansm, 0);
}
-
- return rc;
-}
-
-static void
-ble_ll_scan_update_window(struct ble_ll_scan_sm *scansm, uint32_t cputime)
-{
- uint8_t chan;
- uint32_t itvl;
- uint32_t win_start;
-
- itvl = cputime_usecs_to_ticks(scansm->scan_itvl * BLE_HCI_SCAN_ITVL);
- chan = scansm->scan_chan;
- win_start = scansm->scan_win_start_time;
- while ((int32_t)(cputime - win_start) >= itvl) {
- win_start += itvl;
- ++chan;
- if (chan == BLE_PHY_NUM_CHANS) {
- chan = BLE_PHY_ADV_CHAN_START;
- }
- }
-
- scansm->scan_chan = chan;
- scansm->scan_win_start_time = win_start;
- scansm->last_sched_time = cputime;
}
/**
@@ -568,7 +532,7 @@ ble_ll_scan_update_window(struct ble_ll_scan_sm *scansm, uint32_t cputime)
* are inside the scan window it means that the device should be receiving
* on the scan channel.
*
- * Context: Interrupt and Link Layer
+ * Context: Link Layer
*
* @param scansm
*
@@ -610,70 +574,6 @@ ble_ll_scan_window_chk(struct ble_ll_scan_sm *scansm, uint32_t cputime)
}
/**
- * Called when the scanning schedule item executes
- *
- * Context: Interrupt
- *
- * @param sch
- *
- * @return int
- */
-int
-ble_ll_scan_sched_cb(struct ble_ll_sched_item *sch)
-{
- int rc;
- uint32_t now;
- struct ble_ll_scan_sm *scansm;
-
- /*
- * 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.
- */
- switch (ble_ll_state_get()) {
- case BLE_LL_STATE_ADV:
- case BLE_LL_STATE_CONNECTION:
- rc = -1;
- break;
- case BLE_LL_STATE_INITIATING:
- case BLE_LL_STATE_SCANNING:
- /* Must disable PHY since we will move to a new channel */
- ble_phy_disable();
- rc = 0;
- break;
- case BLE_LL_STATE_STANDBY:
- rc = 0;
- break;
- default:
- rc = 0;
- assert(0);
- break;
- }
-
- now = cputime_get32();
- scansm = (struct ble_ll_scan_sm *)sch->cb_arg;
- if (rc) {
- rc = BLE_LL_SCHED_STATE_DONE;
- } else {
- /* Determine if we should be off or receiving */
- rc = ble_ll_scan_window_chk(scansm, now);
- if (!rc) {
- rc = BLE_LL_SCHED_STATE_RUNNING;
- } else {
- rc = BLE_LL_SCHED_STATE_DONE;
- }
- }
-
- /* Update scan window start time and channel */
- ble_ll_scan_update_window(scansm, now);
-
- /* Post scanning scheduled done event */
- ble_ll_event_send(&scansm->scan_sched_ev);
-
- return rc;
-}
-
-/**
* Stop the scanning state machine
*/
void
@@ -683,9 +583,9 @@ ble_ll_scan_sm_stop(int chk_disable)
uint8_t lls;
struct ble_ll_scan_sm *scansm;
- /* Remove any scheduled advertising items */
+ /* Stop the scanning timer */
scansm = &g_ble_ll_scan_sm;
- ble_ll_sched_rmv_elem(&scansm->scan_sch);
+ cputime_timer_stop(&scansm->scan_timer);
/* Disable scanning state machine */
scansm->scan_enabled = 0;
@@ -714,9 +614,6 @@ ble_ll_scan_sm_stop(int chk_disable)
static int
ble_ll_scan_sm_start(struct ble_ll_scan_sm *scansm)
{
- os_sr_t sr;
- struct ble_ll_sched_item *sch;
-
/*
* XXX: not sure if I should do this or just report whatever random
* address the host sent. For now, I will reject the command with a
@@ -755,75 +652,107 @@ ble_ll_scan_sm_start(struct ble_ll_scan_sm *scansm)
scansm->backoff_count = 1;
scansm->scan_rsp_pending = 0;
- /* Set schedule elements */
- sch = &scansm->scan_sch;
- sch->sched_type = BLE_LL_SCHED_TYPE_SCAN;
- sch->cb_arg = scansm;
- sch->sched_cb = ble_ll_scan_sched_cb;
-
/* XXX: align to current or next slot???. */
/* Schedule start time now */
scansm->scan_win_start_time = cputime_get32();
- scansm->last_sched_time = scansm->scan_win_start_time;
-
- /*
- * If we are in standby, start scanning. Otherwise, scanning will resume
- * when the currently scheduled event ends.
- */
- OS_ENTER_CRITICAL(sr);
- if (ble_ll_state_get() == BLE_LL_STATE_STANDBY) {
- ble_ll_scan_start(scansm, BLE_PHY_ADV_CHAN_START);
- }
- OS_EXIT_CRITICAL(sr);
- /* Post scanning scheduled done event */
+ /* Post scanning event to start off the scanning process */
ble_ll_event_send(&scansm->scan_sched_ev);
return BLE_ERR_SUCCESS;
}
+/**
+ * Called to process the scanning OS event which was posted to the LL task
+ *
+ * Context: Link Layer task.
+ *
+ * @param arg
+ */
void
ble_ll_scan_event_proc(void *arg)
{
+ os_sr_t sr;
+ int rxstate;
+ int start_scan;
+ uint8_t chan;
uint32_t now;
- uint32_t scan_win_start;
- uint32_t itvl;
- uint32_t win_ticks;
+ uint32_t dt;
+ uint32_t win;
+ uint32_t win_start;
+ uint32_t scan_itvl;
+ uint32_t next_event_time;
struct ble_ll_scan_sm *scansm;
- struct ble_ll_sched_item *sch;
+ /*
+ * 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 *)arg;
- sch = &scansm->scan_sch;
+ if (!scansm->scan_enabled) {
+ cputime_timer_stop(&scansm->scan_timer);
+ return;
+ }
- assert((int32_t)(scansm->last_sched_time-scansm->scan_win_start_time) >= 0);
+ /* Make sure the scan window start time and channel are up to date. */
+ now = cputime_get32();
- itvl = cputime_usecs_to_ticks(scansm->scan_itvl * BLE_HCI_SCAN_ITVL);
- scan_win_start = scansm->scan_win_start_time;
- while ((int32_t)(scansm->last_sched_time - scan_win_start) >= itvl) {
- scan_win_start += itvl;
+ scan_itvl = cputime_usecs_to_ticks(scansm->scan_itvl * BLE_HCI_SCAN_ITVL);
+ chan = scansm->scan_chan;
+ win_start = scansm->scan_win_start_time;
+ while ((int32_t)(now - win_start) >= scan_itvl) {
+ win_start += scan_itvl;
+ ++chan;
+ if (chan == BLE_PHY_NUM_CHANS) {
+ chan = BLE_PHY_ADV_CHAN_START;
+ }
}
- /* Determine what the next scheduled scanning item should be. */
- if (scansm->scan_window == scansm->scan_itvl) {
- scan_win_start += itvl;
- } else {
- win_ticks = cputime_usecs_to_ticks(scansm->scan_window * BLE_HCI_SCAN_ITVL);
- if ((scansm->last_sched_time - scansm->scan_win_start_time) < win_ticks) {
- scan_win_start += win_ticks;
+ dt = now - win_start;
+ scansm->scan_chan = chan;
+ scansm->scan_win_start_time = win_start;
+
+ /* Determine on/off state based on scan window */
+ rxstate = 1;
+ next_event_time = win_start + scan_itvl;
+ if (scansm->scan_window != scansm->scan_itvl) {
+ win = cputime_usecs_to_ticks(scansm->scan_window * BLE_HCI_SCAN_ITVL);
+ if (dt >= win) {
+ rxstate = 0;
} else {
- scan_win_start += itvl;
+ next_event_time = win_start + win;
}
}
- now = cputime_get32();
- if ((int32_t)(now - scan_win_start) <= 0) {
- sch->start_time = scan_win_start;
- } else {
- ++g_ble_ll_scan_stats.scan_event_misses;
- sch->start_time = now;
+ OS_ENTER_CRITICAL(sr);
+ /*
+ * 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 = 1;
+ switch (ble_ll_state_get()) {
+ case BLE_LL_STATE_ADV:
+ case BLE_LL_STATE_CONNECTION:
+ start_scan = 0;
+ break;
+ case BLE_LL_STATE_INITIATING:
+ case BLE_LL_STATE_SCANNING:
+ /* Must disable PHY since we will move to a new channel */
+ ble_phy_disable();
+ break;
+ case BLE_LL_STATE_STANDBY:
+ break;
+ default:
+ assert(0);
+ break;
+ }
+ if (start_scan && rxstate) {
+ ble_ll_scan_start(scansm, scansm->scan_chan);
}
- sch->end_time = sch->start_time;
- ble_ll_sched_scan(sch);
+ OS_EXIT_CRITICAL(sr);
+
+ cputime_timer_start(&scansm->scan_timer, next_event_time);
}
/**
@@ -860,14 +789,18 @@ ble_ll_scan_rx_isr_start(uint8_t pdu_type, struct os_mbuf *rxpdu)
/*
* 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
+ * 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.
+ * work for successful scan requests. If failed, we do the work here.
*/
if (scansm->scan_rsp_pending) {
- ble_hdr = BLE_MBUF_HDR_PTR(rxpdu);
- ble_hdr->rxinfo.flags |= BLE_MBUF_HDR_F_SCAN_RSP_CHK;
+ if (pdu_type == BLE_ADV_PDU_TYPE_SCAN_RSP) {
+ ble_hdr = BLE_MBUF_HDR_PTR(rxpdu);
+ ble_hdr->rxinfo.flags |= BLE_MBUF_HDR_F_SCAN_RSP_CHK;
+ } else {
+ ble_ll_scan_req_backoff(scansm, 0);
+ }
}
/* Disable wfr if running */
@@ -1025,6 +958,23 @@ ble_ll_scan_chk_resume(void)
}
/**
+ * Connection supervision timer callback; means that the connection supervision
+ * timeout has been reached and we should perform the appropriate actions.
+ *
+ * Context: Interrupt (cputimer)
+ *
+ * @param arg Pointer to connection 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);
+}
+
+/**
* Called when the wait for response timer expires while in the scanning
* state.
*
@@ -1368,6 +1318,9 @@ ble_ll_scan_init(void)
scansm->scan_itvl = BLE_HCI_SCAN_ITVL_DEF;
scansm->scan_window = BLE_HCI_SCAN_WINDOW_DEF;
+ /* Initialize connection supervision timer */
+ cputime_timer_init(&scansm->scan_timer, ble_ll_scan_timer_cb, scansm);
+
/* Get a scan request mbuf (packet header) and attach to state machine */
ble_get_packet(scansm->scan_req_pdu);
assert(scansm->scan_req_pdu != NULL);
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-larva/blob/425a9254/net/nimble/controller/src/ble_ll_sched.c
----------------------------------------------------------------------
diff --git a/net/nimble/controller/src/ble_ll_sched.c b/net/nimble/controller/src/ble_ll_sched.c
index a41c43c..c3b0436 100644
--- a/net/nimble/controller/src/ble_ll_sched.c
+++ b/net/nimble/controller/src/ble_ll_sched.c
@@ -77,36 +77,6 @@ ble_ll_sched_is_overlap(struct ble_ll_sched_item *s1,
return rc;
}
-/**
- * Checks if the scheduled item 'sch' overlaps the scanning schedule item
- * 'scan'. If so, the scanning scheduled item is removed and we post the
- * scan event so that we can reschedule the next scanning opportunity.
- *
- *
- * @param scan
- * @param sch
- */
-static void
-ble_ll_sched_chk_scan_overlap(struct ble_ll_sched_item *scan,
- struct ble_ll_sched_item *sch)
-{
- struct ble_ll_scan_sm *scansm;
-
- if (ble_ll_sched_is_overlap(scan, sch)) {
- scansm = (struct ble_ll_scan_sm *)scan->cb_arg;
- ble_ll_event_send(&scansm->scan_sched_ev);
- TAILQ_REMOVE(&g_ble_ll_sched_q, scan, link);
- scan->enqueued = 0;
- } else {
- /* If scheduled item is before the scan item, we need to reinsert */
- if ((int32_t)(sch->end_time - scan->start_time) <= 0) {
- TAILQ_REMOVE(&g_ble_ll_sched_q, scan, link);
- scan->enqueued = 0;
- ble_ll_sched_scan(scan);
- }
- }
-}
-
/*
* Determines if the schedule item overlaps the currently running schedule
* item. We only care about connection schedule items
@@ -171,7 +141,6 @@ ble_ll_sched_conn_reschedule(struct ble_ll_conn_sm *connsm)
struct ble_ll_sched_item *end_overlap;
struct ble_ll_sched_item *entry;
struct ble_ll_conn_sm *tmp;
- struct ble_ll_scan_sm *scansm;
/* Get schedule element from connection */
sch = &connsm->conn_sch;
@@ -208,10 +177,9 @@ ble_ll_sched_conn_reschedule(struct ble_ll_conn_sm *connsm)
TAILQ_FOREACH(entry, &g_ble_ll_sched_q, link) {
if (ble_ll_sched_is_overlap(sch, entry)) {
/* Only insert if this element is older than all that we overlap */
- if ((entry->sched_type != BLE_LL_SCHED_TYPE_SCAN) &&
- ((entry->sched_type == BLE_LL_SCHED_TYPE_ADV) ||
- !ble_ll_conn_is_lru((struct ble_ll_conn_sm *)sch->cb_arg,
- (struct ble_ll_conn_sm *)entry->cb_arg))) {
+ if ((entry->sched_type == BLE_LL_SCHED_TYPE_ADV) ||
+ !ble_ll_conn_is_lru((struct ble_ll_conn_sm *)sch->cb_arg,
+ (struct ble_ll_conn_sm *)entry->cb_arg)) {
start_overlap = NULL;
rc = -1;
break;
@@ -245,9 +213,6 @@ ble_ll_sched_conn_reschedule(struct ble_ll_conn_sm *connsm)
if (entry->sched_type == BLE_LL_SCHED_TYPE_CONN) {
tmp = (struct ble_ll_conn_sm *)entry->cb_arg;
ble_ll_event_send(&tmp->conn_ev_end);
- } else {
- scansm = (struct ble_ll_scan_sm *)entry->cb_arg;
- ble_ll_event_send(&scansm->scan_sched_ev);
}
TAILQ_REMOVE(&g_ble_ll_sched_q, entry, link);
@@ -284,14 +249,10 @@ ble_ll_sched_master_new(struct ble_ll_conn_sm *connsm, uint32_t adv_rxend,
uint32_t ce_end_time;
struct ble_ll_sched_item *entry;
struct ble_ll_sched_item *sch;
- struct ble_ll_sched_item *scan;
/* Better have a connsm */
assert(connsm != NULL);
- /* Assume no scheduled item is a scanning item */
- scan = NULL;
-
/* Get schedule element from connection */
rc = -1;
sch = &connsm->conn_sch;
@@ -340,25 +301,20 @@ ble_ll_sched_master_new(struct ble_ll_conn_sm *connsm, uint32_t adv_rxend,
sch->start_time = earliest_start;
sch->end_time = earliest_end;
- /* Ignore scan/initiate types */
- if (entry->sched_type == BLE_LL_SCHED_TYPE_SCAN) {
- scan = entry;
- } else {
- /* We can insert if before entry in list */
- if ((int32_t)(sch->end_time - entry->start_time) < 0) {
- if ((earliest_start - initial_start) <= itvl_t) {
- rc = 0;
- TAILQ_INSERT_BEFORE(entry, sch, link);
- }
- break;
+ /* We can insert if before entry in list */
+ if ((int32_t)(sch->end_time - entry->start_time) < 0) {
+ if ((earliest_start - initial_start) <= itvl_t) {
+ rc = 0;
+ TAILQ_INSERT_BEFORE(entry, sch, link);
}
+ break;
+ }
- /* Check for overlapping events */
- if (ble_ll_sched_is_overlap(sch, entry)) {
- /* Earliest start is end of this event since we overlap */
- earliest_start = entry->end_time;
- earliest_end = earliest_start + dur;
- }
+ /* Check for overlapping events */
+ if (ble_ll_sched_is_overlap(sch, entry)) {
+ /* Earliest start is end of this event since we overlap */
+ earliest_start = entry->end_time;
+ earliest_end = earliest_start + dur;
}
}
@@ -386,17 +342,6 @@ ble_ll_sched_master_new(struct ble_ll_conn_sm *connsm, uint32_t adv_rxend,
connsm->anchor_point = earliest_start +
cputime_usecs_to_ticks(XCVR_TX_SCHED_DELAY_USECS);
connsm->ce_end_time = earliest_end;
-
- /*
- * If there was a scanning item it is possible that the order of the
- * scanning item and the newly added connection are incorrect. So,
- * we check for overlap and if there is one, we reschedule the
- * scanning item
- */
- if (scan) {
- ble_ll_sched_chk_scan_overlap(scan, sch);
- sch = TAILQ_FIRST(&g_ble_ll_sched_q);
- }
}
OS_EXIT_CRITICAL(sr);
@@ -414,7 +359,6 @@ ble_ll_sched_slave_new(struct ble_ll_conn_sm *connsm)
struct ble_ll_sched_item *entry;
struct ble_ll_sched_item *next_sch;
struct ble_ll_sched_item *sch;
- struct ble_ll_sched_item *scan;
/* Get schedule element from connection */
rc = -1;
@@ -440,26 +384,20 @@ ble_ll_sched_slave_new(struct ble_ll_conn_sm *connsm)
/* Nothing in schedule. Schedule as soon as possible */
rc = 0;
} else {
- scan = NULL;
cputime_timer_stop(&g_ble_ll_sched_timer);
while (1) {
- /* Skip scanning schedule items */
next_sch = entry->link.tqe_next;
- if (entry->sched_type == BLE_LL_SCHED_TYPE_SCAN) {
- scan = entry;
- } else {
- /* Insert if event ends before next starts */
- if ((int32_t)(sch->end_time - entry->start_time) < 0) {
- rc = 0;
- TAILQ_INSERT_BEFORE(entry, sch, link);
- break;
- }
+ /* Insert if event ends before next starts */
+ if ((int32_t)(sch->end_time - entry->start_time) < 0) {
+ rc = 0;
+ TAILQ_INSERT_BEFORE(entry, sch, link);
+ break;
+ }
- if (ble_ll_sched_is_overlap(sch, entry)) {
- /* If we overlap with a connection, we re-schedule */
- if (ble_ll_sched_conn_overlap(entry)) {
- break;
- }
+ if (ble_ll_sched_is_overlap(sch, entry)) {
+ /* If we overlap with a connection, we re-schedule */
+ if (ble_ll_sched_conn_overlap(entry)) {
+ break;
}
}
@@ -476,9 +414,6 @@ ble_ll_sched_slave_new(struct ble_ll_conn_sm *connsm)
if (!rc) {
sch->enqueued = 1;
- if (scan) {
- ble_ll_sched_chk_scan_overlap(scan, sch);
- }
}
sch = TAILQ_FIRST(&g_ble_ll_sched_q);
}
@@ -499,7 +434,6 @@ ble_ll_sched_adv_new(struct ble_ll_sched_item *sch)
uint32_t adv_start;
uint32_t duration;
struct ble_ll_sched_item *entry;
- struct ble_ll_sched_item *scan;
/* Get length of schedule item */
duration = sch->end_time - sch->start_time;
@@ -524,26 +458,20 @@ ble_ll_sched_adv_new(struct ble_ll_sched_item *sch)
rc = 0;
adv_start = sch->start_time;
} else {
- scan = NULL;
cputime_timer_stop(&g_ble_ll_sched_timer);
TAILQ_FOREACH(entry, &g_ble_ll_sched_q, link) {
- /* Ignore scan/initiate types */
- if (entry->sched_type == BLE_LL_SCHED_TYPE_SCAN) {
- scan = entry;
- } else {
- /* We can insert if before entry in list */
- if ((int32_t)(sch->end_time - entry->start_time) < 0) {
- rc = 0;
- TAILQ_INSERT_BEFORE(entry, sch, link);
- break;
- }
+ /* We can insert if before entry in list */
+ if ((int32_t)(sch->end_time - entry->start_time) < 0) {
+ rc = 0;
+ TAILQ_INSERT_BEFORE(entry, sch, link);
+ break;
+ }
- /* Check for overlapping events */
- if (ble_ll_sched_is_overlap(sch, entry)) {
- /* Earliest start is end of this event since we overlap */
- sch->start_time = entry->end_time;
- sch->end_time = sch->start_time + duration;
- }
+ /* Check for overlapping events */
+ if (ble_ll_sched_is_overlap(sch, entry)) {
+ /* Earliest start is end of this event since we overlap */
+ sch->start_time = entry->end_time;
+ sch->end_time = sch->start_time + duration;
}
}
@@ -555,9 +483,6 @@ ble_ll_sched_adv_new(struct ble_ll_sched_item *sch)
if (!rc) {
sch->enqueued = 1;
- if (scan) {
- ble_ll_sched_chk_scan_overlap(scan, sch);
- }
}
/* Restart with head of list */
@@ -586,7 +511,6 @@ ble_ll_sched_adv_reschedule(struct ble_ll_sched_item *sch)
os_sr_t sr;
struct ble_ll_sched_item *entry;
struct ble_ll_sched_item *next_sch;
- struct ble_ll_sched_item *scan;
rc = 0;
OS_ENTER_CRITICAL(sr);
@@ -599,25 +523,19 @@ ble_ll_sched_adv_reschedule(struct ble_ll_sched_item *sch)
entry = ble_ll_sched_insert_if_empty(sch);
if (entry) {
- scan = NULL;
cputime_timer_stop(&g_ble_ll_sched_timer);
while (1) {
- /* Skip scanning schedule items */
+ /* Insert before if adv event is before this event */
next_sch = entry->link.tqe_next;
- if (entry->sched_type == BLE_LL_SCHED_TYPE_SCAN) {
- scan = entry;
- } else {
- /* Insert before if adv event is before this event */
- if ((int32_t)(sch->end_time - entry->start_time) < 0) {
- rc = 0;
- TAILQ_INSERT_BEFORE(entry, sch, link);
- break;
- }
+ if ((int32_t)(sch->end_time - entry->start_time) < 0) {
+ rc = 0;
+ TAILQ_INSERT_BEFORE(entry, sch, link);
+ break;
+ }
- if (ble_ll_sched_is_overlap(sch, entry)) {
- if (ble_ll_sched_conn_overlap(entry)) {
- assert(0);
- }
+ if (ble_ll_sched_is_overlap(sch, entry)) {
+ if (ble_ll_sched_conn_overlap(entry)) {
+ assert(0);
}
}
@@ -634,9 +552,6 @@ ble_ll_sched_adv_reschedule(struct ble_ll_sched_item *sch)
if (!rc) {
sch->enqueued = 1;
- if (scan) {
- ble_ll_sched_chk_scan_overlap(scan, sch);
- }
}
sch = TAILQ_FIRST(&g_ble_ll_sched_q);
@@ -649,46 +564,6 @@ ble_ll_sched_adv_reschedule(struct ble_ll_sched_item *sch)
return rc;
}
-void
-ble_ll_sched_scan(struct ble_ll_sched_item *sch)
-{
- int insert_head;
- os_sr_t sr;
- struct ble_ll_sched_item *entry;
-
- /* Assume insert to head */
- insert_head = 1;
-
- OS_ENTER_CRITICAL(sr);
-
- entry = ble_ll_sched_insert_if_empty(sch);
- if (entry) {
- TAILQ_FOREACH(entry, &g_ble_ll_sched_q, link) {
- /* No need to worry about overlap. */
- if ((int32_t)(sch->start_time - entry->start_time) < 0) {
- TAILQ_INSERT_BEFORE(entry, sch, link);
- break;
- }
- insert_head = 0;
- }
-
- if (!entry) {
- TAILQ_INSERT_TAIL(&g_ble_ll_sched_q, sch, link);
- } else {
- if (insert_head) {
- cputime_timer_stop(&g_ble_ll_sched_timer);
- }
- }
- sch->enqueued = 1;
- }
-
- OS_EXIT_CRITICAL(sr);
-
- if (insert_head) {
- cputime_timer_start(&g_ble_ll_sched_timer, sch->start_time);
- }
-}
-
/**
* Remove a schedule element
*
@@ -727,7 +602,9 @@ ble_ll_sched_rmv_elem(struct ble_ll_sched_item *sch)
}
/**
- * Executes a schedule item by calling the schedule callback function.
+ * Executes a schedule item by calling the schedule callback function.
+ *
+ * Context: Interrupt
*
* @param sch Pointer to schedule item
*
@@ -740,29 +617,23 @@ ble_ll_sched_execute_item(struct ble_ll_sched_item *sch)
uint8_t lls;
/*
- * Scanning items are special. If this is one, just call the callback.
- * If we are doing something else the callback will handle it.
- */
- if (sch->sched_type != BLE_LL_SCHED_TYPE_SCAN) {
- /*
- * This is either an advertising event or connection event start. If
- * we are scanning or initiating just stop it.
- */
- lls = ble_ll_state_get();
- if (lls != BLE_LL_STATE_STANDBY) {
- /* We have to disable the PHY no matter what */
- ble_phy_disable();
- ble_ll_wfr_disable();
- if ((lls == BLE_LL_STATE_SCANNING) ||
- (lls == BLE_LL_STATE_INITIATING)) {
- ble_ll_state_set(BLE_LL_STATE_STANDBY);
- } else if (lls == BLE_LL_STATE_ADV) {
- ++g_ble_ll_stats.sched_state_adv_errs;
- ble_ll_adv_halt();
- } else {
- ble_ll_conn_event_halt();
- ++g_ble_ll_stats.sched_state_conn_errs;
- }
+ * This is either an advertising event or connection event start. If
+ * we are scanning or initiating just stop it.
+ */
+ lls = ble_ll_state_get();
+ if (lls != BLE_LL_STATE_STANDBY) {
+ /* We have to disable the PHY no matter what */
+ ble_phy_disable();
+ ble_ll_wfr_disable();
+ if ((lls == BLE_LL_STATE_SCANNING) ||
+ (lls == BLE_LL_STATE_INITIATING)) {
+ ble_ll_state_set(BLE_LL_STATE_STANDBY);
+ } else if (lls == BLE_LL_STATE_ADV) {
+ ++g_ble_ll_stats.sched_state_adv_errs;
+ ble_ll_adv_halt();
+ } else {
+ ble_ll_conn_event_halt();
+ ++g_ble_ll_stats.sched_state_conn_errs;
}
}