mirror of https://github.com/ARMmbed/mbed-os.git
261 lines
11 KiB
C
261 lines
11 KiB
C
/*
|
|
* Copyright (c) 2014-2018, Arm Limited and affiliates.
|
|
* SPDX-License-Identifier: BSD-3-Clause
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. Neither the name of the copyright holder nor the
|
|
* names of its contributors may be used to endorse or promote products
|
|
* derived from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
|
|
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
#ifndef THREAD_ROUTING_H_
|
|
#define THREAD_ROUTING_H_
|
|
|
|
#include "NWK_INTERFACE/Include/protocol.h"
|
|
#include <ns_list.h>
|
|
#ifndef UINT_FAST12_MAX
|
|
typedef uint_fast16_t uint_fast12_t;
|
|
#define UINT_FAST12_MAX UINT_FAST16_MAX
|
|
#endif
|
|
|
|
#include "Service_Libs/Trickle/trickle.h"
|
|
|
|
struct thread_info_s;
|
|
|
|
#define MAX_ROUTER_ID 62
|
|
#define N_THREAD_ROUTERS 64
|
|
#define THREAD_ROUTER_ID_BITS 6
|
|
#define THREAD_ROUTER_MASK 0xFC00
|
|
#define THREAD_ROUTER_SHIFT 10
|
|
#define THREAD_CHILD_MASK 0x03FF
|
|
#define THREAD_ROUTER_IDX 0
|
|
|
|
typedef uint_fast8_t thread_router_id_t;
|
|
|
|
#define THREAD_QUALITY_BITS 2
|
|
#define THREAD_COST_BITS 4
|
|
#define THREAD_COST_INFINITE 0
|
|
#define THREAD_MAX_ROUTE_COST 15
|
|
|
|
/* Scaled link margin */
|
|
#define THREAD_LINK_MARGIN_BITS 12
|
|
#define THREAD_LINK_MARGIN_SCALING 3 /* For 1/8 exponential moving average weighting */
|
|
|
|
#if THREAD_LINK_MARGIN_BITS == 12
|
|
typedef uint_fast12_t thread_link_margin_t;
|
|
#define THREAD_LINK_MARGIN_MAX UINT_FAST12_MAX
|
|
#endif
|
|
|
|
/* I want to use uint_fast4_t - create it if it doesn't exist */
|
|
#ifndef UINT_FAST4_MAX
|
|
typedef uint_fast8_t uint_fast4_t;
|
|
#define UINT_FAST4_MAX UINT_FAST8_MAX
|
|
#endif
|
|
typedef uint_fast4_t thread_route_cost_t;
|
|
|
|
typedef enum {
|
|
QUALITY_20dB = 3,
|
|
QUALITY_10dB = 2,
|
|
QUALITY_2dB = 1,
|
|
QUALITY_BAD = 0,
|
|
} thread_link_quality_e;
|
|
|
|
/* The draft-kelsey-thread-routing-00 Link Set */
|
|
/* XXX - probably don't need this - put it into mle_neigh_table? */
|
|
typedef struct thread_router_link_s {
|
|
// *INDENT-OFF* astyle
|
|
unsigned router_id : THREAD_ROUTER_ID_BITS;
|
|
unsigned incoming_quality : THREAD_QUALITY_BITS;
|
|
unsigned outgoing_quality : THREAD_QUALITY_BITS;
|
|
unsigned link_margin : THREAD_LINK_MARGIN_BITS;
|
|
// *INDENT-ON*
|
|
unsigned age : 12; /* 100ms ticks, so good for ~2 hours */
|
|
bool outgoing_quality_known : 1;
|
|
bool as_good : 1;
|
|
ns_list_link_t link;
|
|
} thread_router_link_t;
|
|
|
|
/* The draft-kelsey-thread-routing-00 Route Set */
|
|
typedef struct thread_route_s {
|
|
// *INDENT-OFF* astyle
|
|
unsigned destination : THREAD_ROUTER_ID_BITS;
|
|
unsigned next_hop : THREAD_ROUTER_ID_BITS;
|
|
unsigned route_cost : THREAD_COST_BITS; /* Cost according to next_hop - doesn't include our cost to next_hop */
|
|
// *INDENT-ON* astyle
|
|
ns_list_link_t link;
|
|
} thread_route_t;
|
|
|
|
/* Fast routing table - also serves as the draft-kelsey-thread-routing-00 Router ID Set
|
|
* Entries currently squeeze into 1 byte, making fast_route_table a 64-byte array
|
|
*
|
|
* "INVALID_ID" or not is always live info, as that's the master ID Set
|
|
* storage. If ID is valid, the route decision is a cache generated from
|
|
* route_set and link_set, and it needs to be kept up-to-date with
|
|
* thread_update_fast_route_table() when those change.
|
|
*/
|
|
#define FAST_ROUTE_INVALID_ID 0xFF
|
|
#define FAST_ROUTE_NO_ROUTE 0xFE
|
|
#if N_THREAD_ROUTERS > 0xFD
|
|
#error "rework fast_route_table"
|
|
#endif
|
|
|
|
typedef struct thread_routing_info_s {
|
|
NS_LIST_HEAD(thread_router_link_t, link) link_set;
|
|
NS_LIST_HEAD(thread_route_t, link) route_set;
|
|
uint_least8_t fast_route_table[N_THREAD_ROUTERS];
|
|
bool activated;
|
|
bool router_id_sequence_valid;
|
|
uint8_t router_id_sequence;
|
|
uint16_t networkFragmentationTimer;
|
|
uint16_t networkIdTimeout; //!< timeout in seconds
|
|
trickle_t mle_advert_timer;
|
|
}
|
|
thread_routing_info_t;
|
|
|
|
#ifdef HAVE_THREAD
|
|
|
|
/* See ns_types.h for explanation */
|
|
NS_INLINE thread_router_id_t thread_router_id_from_addr(uint16_t addr);
|
|
NS_INLINE uint16_t thread_router_addr_from_id(thread_router_id_t addr);
|
|
NS_INLINE uint16_t thread_router_addr_from_addr(uint16_t addr);
|
|
NS_INLINE bool thread_is_router_addr(uint16_t addr);
|
|
NS_INLINE bool thread_addr_is_child(uint16_t a, uint16_t b);
|
|
NS_INLINE bool thread_addr_is_equal_or_child(uint16_t a, uint16_t b);
|
|
|
|
#if defined NS_ALLOW_INLINING || defined THREAD_ROUTING_FN
|
|
#ifndef THREAD_ROUTING_FN
|
|
#define THREAD_ROUTING_FN NS_INLINE
|
|
#endif
|
|
THREAD_ROUTING_FN thread_router_id_t thread_router_id_from_addr(uint16_t addr)
|
|
{
|
|
return addr >> THREAD_ROUTER_SHIFT;
|
|
}
|
|
|
|
THREAD_ROUTING_FN uint16_t thread_router_addr_from_id(thread_router_id_t addr)
|
|
{
|
|
return (uint_fast16_t) addr << THREAD_ROUTER_SHIFT;
|
|
}
|
|
|
|
THREAD_ROUTING_FN uint16_t thread_router_addr_from_addr(uint16_t addr)
|
|
{
|
|
return (addr & THREAD_ROUTER_MASK) | THREAD_ROUTER_IDX;
|
|
}
|
|
|
|
THREAD_ROUTING_FN bool thread_is_router_addr(uint16_t addr)
|
|
{
|
|
return (addr & ~ THREAD_ROUTER_MASK) == THREAD_ROUTER_IDX;
|
|
}
|
|
|
|
/* Return true if b is a child of a */
|
|
THREAD_ROUTING_FN bool thread_addr_is_child(uint16_t a, uint16_t b)
|
|
{
|
|
if (thread_is_router_addr(b)) {
|
|
return false;
|
|
}
|
|
return thread_router_addr_from_addr(b) == a;
|
|
}
|
|
|
|
/* Return true if b is equal to a, or b is a child of a */
|
|
THREAD_ROUTING_FN bool thread_addr_is_equal_or_child(uint16_t a, uint16_t b)
|
|
{
|
|
return b == a || thread_addr_is_child(a, b);
|
|
}
|
|
#endif /* NS_ALLOW_INLINING || defined THREAD_ROUTING_FN */
|
|
#endif // HAVE_THREAD
|
|
|
|
#ifdef HAVE_THREAD_ROUTER
|
|
|
|
bool thread_i_am_router(const protocol_interface_info_entry_t *cur);
|
|
|
|
void thread_routing_init(thread_routing_info_t *routing);
|
|
void thread_routing_reset(thread_routing_info_t *routing);
|
|
void thread_routing_free(thread_routing_info_t *routing);
|
|
void thread_routing_activate(thread_routing_info_t *routing);
|
|
void thread_routing_deactivate(thread_routing_info_t *routing);
|
|
bool thread_routing_timer(struct thread_info_s *thread, uint8_t ticks);
|
|
void thread_routing_trickle_advance(thread_routing_info_t *routing, uint16_t ticks);
|
|
void thread_routing_leader_connection_validate(struct thread_info_s *thread, uint16_t disconnect_period);
|
|
void thread_routing_set_mesh_callbacks(protocol_interface_info_entry_t *cur);
|
|
|
|
uint_fast8_t thread_routing_cost_get_by_router_id(thread_routing_info_t *routing, uint8_t routerId);
|
|
bool router_id_sequence_is_greater(const thread_routing_info_t *routing, uint8_t seq);
|
|
|
|
uint_fast8_t thread_routing_count_neighbours_for_downgrade(thread_routing_info_t *routing, uint_fast8_t *as_good);
|
|
uint_fast8_t thread_routing_count_active_routers(thread_routing_info_t *routing);
|
|
uint_fast8_t thread_routing_count_active_routers_from_mask(const uint8_t *id_mask);
|
|
|
|
//Init
|
|
void thread_routing_update_id_set(protocol_interface_info_entry_t *cur, uint8_t seq, const uint8_t *id_mask);
|
|
void thread_routing_force_next_hop(protocol_interface_info_entry_t *cur, uint8_t id_seq, const uint8_t *id_mask, thread_router_id_t next_hop_id);
|
|
|
|
int_fast8_t thread_routing_update_link_margin(protocol_interface_info_entry_t *cur,
|
|
uint16_t sender,
|
|
uint8_t link_margin_db,
|
|
uint8_t outgoing_link_margin_db);
|
|
int_fast8_t thread_routing_force_link_margin(protocol_interface_info_entry_t *cur,
|
|
uint16_t addr,
|
|
uint8_t link_margin_db);
|
|
int_fast8_t thread_routing_add_link(protocol_interface_info_entry_t *cur,
|
|
uint16_t sender, uint8_t link_margin_db,
|
|
uint8_t id_seq,
|
|
const uint8_t *id_mask,
|
|
const uint8_t *route_data,
|
|
bool is_static);
|
|
int_fast8_t thread_routing_remove_link(protocol_interface_info_entry_t *cur,
|
|
uint16_t sender);
|
|
|
|
uint8_t thread_routing_get_route_data_size(protocol_interface_info_entry_t *cur);
|
|
|
|
int_fast8_t thread_routing_get_route_data(protocol_interface_info_entry_t *cur,
|
|
uint8_t *id_seq,
|
|
uint8_t *id_mask,
|
|
uint8_t *data,
|
|
uint8_t *len_out);
|
|
#else // HAVE_THREAD_ROUTER
|
|
|
|
#define thread_i_am_router(cur) false
|
|
#define thread_routing_init(routing)
|
|
#define thread_routing_reset(routing)
|
|
#define thread_routing_free(routing)
|
|
#define thread_routing_activate(routing)
|
|
#define thread_routing_deactivate(routing)
|
|
#define thread_routing_timer(thread, ticks) false
|
|
#define thread_routing_trickle_advance(routing, ticks)
|
|
#define thread_routing_leader_connection_validate(thread, disconnect_period)
|
|
#define thread_routing_set_mesh_callbacks(cur)
|
|
#define thread_routing_cost_get_by_router_id(routing, routerId) (0)
|
|
#define thread_routing_count_active_routers(routing) 0
|
|
#define thread_routing_count_active_routers_from_mask(id_mask) 0
|
|
#define thread_routing_update_id_set(cur, seq, id_mask)
|
|
#define thread_routing_update_link_margin(cur, sender, link_margin_db, outgoing_link_margin_db) (-3)
|
|
#define thread_routing_force_link_margin(cur, addr, link_margin_db) (-3)
|
|
#define thread_routing_add_link(cur, sender, link_margin_db, id_seq, id_mask, route_data, is_static) (-2)
|
|
#define thread_is_router_addr(addr) false
|
|
#define thread_routing_remove_link(cur, sender) 0
|
|
#define thread_routing_get_route_data_size(cur) 0
|
|
#define thread_routing_get_route_data(cur,id_seq,id_mask,data,len_out) (0)
|
|
#define thread_addr_is_equal_or_child(a, b) false
|
|
#define thread_addr_is_child(a, b) false
|
|
|
|
#endif // HAVE_THREAD_ROUTER
|
|
|
|
#endif /* THREAD_ROUTING_H_ */
|