diff options
Diffstat (limited to 'thirdparty/nRF5_SDK_15.0.0_a53641a/components/802_15_4/api/SysAL')
14 files changed, 2765 insertions, 0 deletions
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/802_15_4/api/SysAL/sys_crc.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/802_15_4/api/SysAL/sys_crc.h new file mode 100644 index 0000000..f85430b --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/802_15_4/api/SysAL/sys_crc.h @@ -0,0 +1,95 @@ +/** + * Copyright (c) 2016 - 2018 Nordic Semiconductor ASA and Luxoft Global Operations Gmbh. + * + * All Rights Reserved. + * + * 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, except as embedded into a Nordic + * Semiconductor ASA integrated circuit in a product or a software update for + * such product, 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 Nordic Semiconductor ASA nor the names of its + * contributors may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * 4. This software, with or without modification, must only be used with a + * Nordic Semiconductor ASA integrated circuit. + * + * 5. Any software provided in binary form under this license must not be reverse + * engineered, decompiled, modified and/or disassembled. + * + * + * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA 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 SYS_CRC_H_INCLUDED +#define SYS_CRC_H_INCLUDED + +#include <stdint.h> +#include <stddef.h> + +/** @file + * This file contains declarations of the CRC computing routines and necessary macros/types. + * + * @defgroup sys_crc System CRC API + * @ingroup sys_15_4 + * @{ + * @brief Module to declare System CRC API. + * @details The CRC module implements a set of routines to compute the 16-bit CRC value for octet arrays. + */ + +/** + * @brief Defines an initial value for the CRC sum. + */ +#define SYS_CRC_INIT 0 + +/** + * @brief CRC value type. This module uses 16-bit CRC. + */ +typedef uint16_t sys_crc_t; + +/** + * @brief Function for computing CRC value for given data. + * + * @param[in] p_data Pointer to data to compute. + * @param[in] length Length of data. + * + * @return Returns the CRC value for input data. + */ +sys_crc_t sys_crc_calc(const uint8_t * p_data, size_t length); + +/** + * @brief Function for updating the CRC value taking into the account the previously counted value. + * + * @details This function is used when input data is represented by several pieces. + * Consequently, a call to this function for each piece will give a correct + * total CRC value. + * + * @param[in] current_crc Previously counted CRC value. Should be SYS_CRC_INIT for the first piece. + * @param[in] p_data Pointer to the current piece of data. + * @param[in] length Length of the current piece of data. + * + * @return Returns the updated CRC value. + */ +sys_crc_t sys_crc_continue(sys_crc_t current_crc, const uint8_t * p_data, size_t length); + +/** @} */ + +#endif /* SYS_CRC_H_INCLUDED */ diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/802_15_4/api/SysAL/sys_debug.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/802_15_4/api/SysAL/sys_debug.h new file mode 100644 index 0000000..c9943de --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/802_15_4/api/SysAL/sys_debug.h @@ -0,0 +1,177 @@ +/** + * Copyright (c) 2016 - 2018 Nordic Semiconductor ASA and Luxoft Global Operations Gmbh. + * + * All Rights Reserved. + * + * 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, except as embedded into a Nordic + * Semiconductor ASA integrated circuit in a product or a software update for + * such product, 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 Nordic Semiconductor ASA nor the names of its + * contributors may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * 4. This software, with or without modification, must only be used with a + * Nordic Semiconductor ASA integrated circuit. + * + * 5. Any software provided in binary form under this license must not be reverse + * engineered, decompiled, modified and/or disassembled. + * + * + * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA 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 SYS_DEBUG_H_INCLUDED +#define SYS_DEBUG_H_INCLUDED + + +#include "hal_debug_interface.h" +#include "hal_trace_interface.h" +#include <stdbool.h> +#include <stdarg.h> + +/* This header file contains macros for debugging. */ + +#ifndef ASSERT + #ifdef CONFIG_DEBUG + #define ASSERT(CONDITION_STATEMENT) \ + do \ + { \ + bool LOCAL_CONDITION_CHECK = (CONDITION_STATEMENT); \ + if (LOCAL_CONDITION_CHECK != true) \ + { \ + sys_assert_handler((#CONDITION_STATEMENT), __LINE__, __FILE__); \ + } \ + } while (0) + #else + + #define ASSERT(CONDITION_STATEMENT) + + #endif // CONFIG_DEBUG +#endif // ASSERT + +#ifndef ASSERT_INFO + #ifdef CONFIG_DEBUG + #define ASSERT_INFO(CONDITION_STATEMENT, INFO_FMT, ...) \ + do \ + { \ + bool LOCAL_CONDITION_CHECK = (CONDITION_STATEMENT); \ + if (LOCAL_CONDITION_CHECK != true) \ + { \ + sys_assert_info_handler((#CONDITION_STATEMENT), __LINE__, __FILE__, \ + INFO_FMT, __VA_ARGS__); \ + } \ + } while (0) + + #else + + #define ASSERT_INFO(CONDITION_STATEMENT, INFO_FMT, ...) + + #endif // CONFIG_DEBUG +#endif // ASSERT_INFO + +#ifndef ASSERT_STATIC + #ifdef CONFIG_DEBUG + #define ASSERT_STATIC(e) do { enum {SA = 1/(e)}; } while (0) + #else + #define ASSERT_STATIC(e) + #endif // CONFIG_DEBUG +#endif // ASSERT_STATIC + +/** + * @defgroup sys_debug Debugging macros + * @ingroup sys_15_4 + * @{ + * @brief Functions used for debugging. + */ + + +/**@brief System assertion fault handler. + * + * @details This macro should be used whenever an assertion fault is detected. + * + * @param[in] CONDITION_STRING Assertion condition string, which occurred to be not true. + */ +#define SYS_ASSERT_HANDLER(CONDITION_STRING) \ + do \ + { \ + sys_assert_handler(CONDITION_STRING, __LINE__, __FILE__); \ + } while (0) + + +#ifndef TRACE_PUTS + #ifdef CONFIG_TRACE + #define TRACE_PUTS(s) HAL_TRACE_INTERFACE_PUTS(s) + #else + #define TRACE_PUTS(s) + #endif //CONFIG_TRACE +#endif //TRACE_PUTS + + +#ifndef TRACE + #ifdef CONFIG_TRACE + #define TRACE(INFO_FMT, ...) sys_trace_handler(INFO_FMT, __VA_ARGS__) + #else + #define TRACE(INFO_FMT, ...) + #endif // CONFIG_DEBUG +#endif // TRACE + + +/**@brief System assertion fault handler function. + * + * @param[in] condition Assertion condition string, which was expected to be true. + * + * @param[in] line Line number. + * + * @param[in] file File name. + */ +extern void sys_assert_handler( + const char * condition, const int line, const char * file); + + +/**@brief System assertion fault handler function with additional assertion information. + * + * @param[in] condition Assertion condition string, which was expected to be true. + * + * @param[in] line Line number. + * + * @param[in] file File name. + * + * @param[in] info_fmt Format string for additional assert information. + * + * @param[in] ... Arguments list corresponding to the format string. + */ +extern void sys_assert_info_handler( + const char * condition, const int line, const char * file, + const char * info_fmt, ...); + + +/**@brief System trace output handler function. + * + * @param[in] fmt Format string for trace output. + * + * @param[in] ... Arguments list corresponding to the format string. + */ +extern void sys_trace_handler(const char * fmt, ...); + +/** @} */ + +#endif // SYS_DEBUG_H_INCLUDED diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/802_15_4/api/SysAL/sys_events.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/802_15_4/api/SysAL/sys_events.h new file mode 100644 index 0000000..554f892 --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/802_15_4/api/SysAL/sys_events.h @@ -0,0 +1,167 @@ +/** + * Copyright (c) 2016 - 2018 Nordic Semiconductor ASA and Luxoft Global Operations Gmbh. + * + * All Rights Reserved. + * + * 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, except as embedded into a Nordic + * Semiconductor ASA integrated circuit in a product or a software update for + * such product, 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 Nordic Semiconductor ASA nor the names of its + * contributors may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * 4. This software, with or without modification, must only be used with a + * Nordic Semiconductor ASA integrated circuit. + * + * 5. Any software provided in binary form under this license must not be reverse + * engineered, decompiled, modified and/or disassembled. + * + * + * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA 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 SYS_EVENTS_H_INCLUDED +#define SYS_EVENTS_H_INCLUDED + +#include <stddef.h> +#include "sys_queue.h" + +/** @file + * This file contains declarations of the Events API and necessary types. The Events feature is implemented + * using the Queue functionality. + * + * @defgroup sys_events System events API + * @ingroup sys_15_4 + * @{ + * @brief Module for declaring system events API. + * @details The Events module defines some routines to subscribe/unsubscribe to/from system events. The events pool + * can be extended by adding new events to the sys_event_id_t enumeration. The registered callbacks + * can be called for an array of events. The callbacks can be called implicitly via posting the event by the + * sys_event_post() routine. + */ + +/**@brief IDs of globally available events. + * + * @details Event IDs are system extension points that allow the user to implement + * specific processing of predefined set of events, occurring in different modules. + */ +typedef enum +{ + SYS_EVENT_FALLING_ASLEEP, /**< Falling asleep event. */ + SYS_EVENT_WAKE_UP, /**< Waking up event. */ + SYS_EVENT_OUT_OF_MEMORY, /**< Out of memory event. */ + SYS_EVENT_MEMORY_FREED, /**< Memory was freed up event. */ + + /** \note The list of system events can be extended during the implementation phase. */ + + /* The following event IDs are used only for unit testing */ + TST_EVENT_0, /**< Test event #0. */ + TST_EVENT_1, /**< Test event #1. */ + TST_EVENT_2, /**< Test event #2. */ + +#if (CONFIG_USE_SYS_TASK_NOTIFIER == 1) + /** This event is posted when there are unhandled events available in + * any of the schedulers. + */ + SYS_EVENT_NEW_TASK, +#endif + + SYS_EVENTS_AMOUNT +} sys_event_id_t; + + +/**@brief Prototype of user-implemented callback for processing an event. + * + * @details This callback is registered for the given event by a *_subscribe routine, + * and is then called by the system events engine, when this event occurs. + * + * @param[in] p_data Pointer to the data, specific for this event. + */ +typedef void (* sys_event_callback_t)(const void * p_data); + + +/**@brief Event descriptor. + * + * @details This descriptor is used to subscribe/unsubscribe to/from the event. + */ +typedef struct +{ + /** Service field. */ + sys_queue_item_t queue_item; + + /** ID of the event to which this callback is to be subscribed. */ + sys_event_id_t event_id; + + /** Callback function which is to be called when this event occurs. */ + sys_event_callback_t callback; +} sys_event_desc_t; + + +/**@brief Function for initializing the global events infrastructure. + */ +void sys_events_init(void); + + +/**@brief Function for subscribing to a system event. + * + * @param[in] p_event_desc Pointer to the event descriptor. + */ +void sys_event_subscribe(sys_event_desc_t * p_event_desc); + + +/**@brief Function for unsubscribing from a system event event. + * + * @param[in] p_event_desc Pointer to the event descriptor. + */ +void sys_event_unsubscribe(sys_event_desc_t * p_event_desc); + + +/**@brief Function for subscribing to a group of events. + * + * @param[in] p_desc_array Pointer to the array of event descriptors. + * @param[in] desc_amount Amount of event descriptors in the array. + */ +void sys_events_array_subscribe(sys_event_desc_t * p_desc_array, size_t desc_amount); + + +/**@brief Function for unsubscribing from the group of events. + * + * + * @param[in] p_desc_array Pointer to the array of event descriptors. + * @param[in] desc_amount Amount of the event descriptors in the array. + */ +void sys_events_array_unsubscribe(sys_event_desc_t * p_desc_array, size_t desc_amount); + + +/**@brief Function for posting an event. + * + * @details This function is used to notify all the subscribers of the given events via + * their callbacks, when the given event occurs. + * + * @param[in] event_id ID of the event to be posted. + * @param[in] p_data Pointer to be passed to the event handlers' callbacks. + */ +void sys_event_post(sys_event_id_t event_id, const void * p_data); + +/** @} */ + +#endif // SYS_EVENTS_H_INCLUDED diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/802_15_4/api/SysAL/sys_fsm.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/802_15_4/api/SysAL/sys_fsm.h new file mode 100644 index 0000000..51a3ee2 --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/802_15_4/api/SysAL/sys_fsm.h @@ -0,0 +1,286 @@ +/** + * Copyright (c) 2016 - 2018 Nordic Semiconductor ASA and Luxoft Global Operations Gmbh. + * + * All Rights Reserved. + * + * 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, except as embedded into a Nordic + * Semiconductor ASA integrated circuit in a product or a software update for + * such product, 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 Nordic Semiconductor ASA nor the names of its + * contributors may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * 4. This software, with or without modification, must only be used with a + * Nordic Semiconductor ASA integrated circuit. + * + * 5. Any software provided in binary form under this license must not be reverse + * engineered, decompiled, modified and/or disassembled. + * + * + * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA 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 SYS_FSM_H_INCLUDED +#define SYS_FSM_H_INCLUDED + +#include <stdint.h> +#include <stdbool.h> + +/** @file + * This file contains declarations of the Finite State Machine (FSM) primitives and necessary types. + * + * @defgroup sys_fsm Finite State Machine API + * @ingroup sys_15_4 + * @{ + * @brief Module to declare Finite State Machine API + * @details The FSM module implements the Finite State Machine abstraction. The user is intended to implement a transition + * table of states with guards and actions in order to represent some event-driven subject. When a table is + * implemented, call sys_fsm_init() to initialize the FSM. After that, the only routine to + * work with FSM is sys_fsm_event_post(). + */ + +/**@brief Fixed-size type for FSM state ID. + */ +typedef uint8_t sys_fsm_state_id_t; + + +/**@brief Fixed-size type for FSM event ID. + */ +typedef uint8_t sys_fsm_event_id_t; + + +/**@brief Fixed-size type for FSM guard condition ID. + */ +typedef uint8_t sys_fsm_guard_id_t; + + +/**@brief Fixed-size type for FSM action ID. + */ +typedef uint8_t sys_fsm_action_id_t; + + +/**@brief FSM transition description (item of FSM transition table). + * + * @details When an event with given event_id occurs, the guard condition with guard_id + * is checked, and if it returns true, the action with action_id is performed, + * and state machine is switched to the state with new_state_id. + */ +typedef struct +{ + sys_fsm_event_id_t event_id; /**< FSM event ID. */ + sys_fsm_guard_id_t guard_id; /**< FSM guard ID. */ + sys_fsm_action_id_t action_id; /**< FSM action ID. */ + sys_fsm_state_id_t new_state_id; /**< New state ID. */ +#if defined(CONFIG_FSM_DEBUG) + const char * debug_string; +#endif +} sys_fsm_transition_t; + + +/**@brief FSM transition declaration (item of FSM transition table). + */ +#if defined(CONFIG_FSM_DEBUG) +# define SYS_FSM_TRANSITION(event_id, guard_id, action_id, new_state_id) \ + {(event_id), (guard_id), (action_id), (new_state_id), \ + "(" #event_id ", " #guard_id ", " #action_id " -> " #new_state_id ")"} +#else +# define SYS_FSM_TRANSITION(event_id, guard_id, action_id, new_state_id) \ + {(event_id), (guard_id), (action_id), (new_state_id)} +#endif + + +/**@brief FSM state declaration. + * + * @details The state is an aggregator item of the FSM transition table, aggregating + * the transitions, declared immediately after this state declaration. + * All transition declaration items, following the state declaration item, + * will be aggregated in this state, until the next state declaration item, + * or the "end of table" item. + */ +#define SYS_FSM_STATE(state_id) \ + {(state_id) | SYS_FSM_STATE_FLAG, 0, 0, 0} + + +/**@brief Empty guard condition ID. + * + * @details Special value of the guard_id field. If it is used in transition declaration, + * guard check will be omitted. + */ +#define SYS_FSM_NO_GUARD 0xFF + + +/**@brief Empty guard condition ID (useful synonym). + * + * @details Special value of the guard_id field. If it is used in transition declaration, + * guard check will be omitted. + */ +#define SYS_FSM_OTHERWISE 0xFF + + +/**@brief Empty guard condition ID (useful synonym). + * + * @details Special value of the guard_id field. If it is used in transition declaration, + * guard check will be omitted. + */ +#define SYS_FSM_ALWAYS 0xFF + + +/**@brief Empty action ID. + * + * @details Special value of the action_id field. If it is used in transition declaration, + * no action will be performed during the transition. + */ +#define SYS_FSM_NO_ACTION 0xFF + + +/**@brief Same state ID. + * + * @details Special value of the next_state_id field. If it is used in transition + * declaration, the current state will not be changed. + */ +#define SYS_FSM_SAME_STATE 0xFF + + +/**@brief Any state ID. + * + * @details Special value of the event_id field. If it is used in transition + * declaration table, then the transitions listed in this state will be applied + * in case they have not been listed in the transition table for the + * current FSM state. + * Only one SYS_FSM_STATE(SYS_FSM_ANY_STATE) can be present in the transition table. + */ +#define SYS_FSM_ANY_STATE 0xFF + + +/**@brief State declaration flag. + * + * @details Special flag of the event_id field. This flag is used to distinguish + * between state declaration and transition declaration. + */ +#define SYS_FSM_STATE_FLAG 0x80 + + +/**@brief Prototype of a user-defined FSM guard condition function. + * + * @details You must implement a single FSM guard condition function which will + * use an ID of the needed guard check as a parameter. + * + * @param[in] guard_id Guard condition ID to be checked. + * @param[in] p_data Additional FSM specific data. + * + * @retval true Transition is allowed, false otherwise. + */ +typedef bool (* sys_fsm_guard_t)(sys_fsm_guard_id_t guard_id, void * p_data); + + +/**@brief Prototype of a user-defined FSM action function. + * + * @details You must implement a single FSM action function which will + * use an ID of the needed action as a parameter. + * + * @param[in] action_id Action ID to be performed. + * @param[in] p_data Additional FSM specific data. + */ +typedef void (* sys_fsm_action_t)(sys_fsm_action_id_t action_id, void * p_data); + + +/**@brief Constant FSM descriptor which can reside in read-only memory. + */ +typedef struct +{ +#if defined(CONFIG_FSM_DEBUG) + const char * debug_fsm_name; +#endif + /** Pointer to the transition table. + */ + const sys_fsm_transition_t * transition_table; + + /** Number of transitions in the transition table. + */ + uint8_t transitions_amount; + + /** Initial state ID. + */ + sys_fsm_state_id_t initial_state; + + /** Pointer to the guard condition function. + */ + sys_fsm_guard_t guard; + + /** Pointer to the action function. + */ + sys_fsm_action_t action; +} sys_fsm_const_descriptor_t; + + +/**@brief FSM dynamic descriptor, holding the current state of the FSM. +*/ +typedef struct +{ + /** Pointer to the constant FSM descriptor which can reside in read-only memory. + */ + const sys_fsm_const_descriptor_t * fsm_const_desc; + + /** Index of the "any state transitions" block. + */ + uint8_t any_state_transitions_index; + + /** Current state ID. + */ + volatile sys_fsm_state_id_t current_state; + + /** Recursion protection. + */ + volatile uint8_t recursion_protection; +} sys_fsm_t; + + +#if defined(CONFIG_FSM_DEBUG) + #define FSM_DEBUG_NAME(name_string) .debug_fsm_name = name_string, +#else + #define FSM_DEBUG_NAME(name_string) +#endif + + +/**@brief Function for initializing a specific FSM. + * + * @param[in] p_fsm Pointer to FSM descriptor to initialize. + * @param[in] p_fsm_const Pointer to constant FSM descriptor with transition table, etc. + */ +void sys_fsm_init(sys_fsm_t * p_fsm, const sys_fsm_const_descriptor_t * p_fsm_const); + + +/**@brief Function for posting an event to FSM. + * + * @details This function causes FSM transition from the current state to the new state, + * according to the transition table of this FSM. + * The corresponding guard check and action is performed. + * + * @param[in] p_fsm Pointer to FSM descriptor. + * @param[in] event_id Event ID to post. + * @param[in] p_data Pointer to the FSM-specific data. + */ +void sys_fsm_event_post(sys_fsm_t * p_fsm, sys_fsm_event_id_t event_id, void * p_data); + +/** @} */ + +#endif // SYS_FSM_H_INCLUDED diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/802_15_4/api/SysAL/sys_init.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/802_15_4/api/SysAL/sys_init.h new file mode 100644 index 0000000..8efeaf6 --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/802_15_4/api/SysAL/sys_init.h @@ -0,0 +1,69 @@ +/** + * Copyright (c) 2016 - 2018 Nordic Semiconductor ASA and Luxoft Global Operations Gmbh. + * + * All Rights Reserved. + * + * 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, except as embedded into a Nordic + * Semiconductor ASA integrated circuit in a product or a software update for + * such product, 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 Nordic Semiconductor ASA nor the names of its + * contributors may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * 4. This software, with or without modification, must only be used with a + * Nordic Semiconductor ASA integrated circuit. + * + * 5. Any software provided in binary form under this license must not be reverse + * engineered, decompiled, modified and/or disassembled. + * + * + * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA 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 SYS_INIT_H_INCLUDED +#define SYS_INIT_H_INCLUDED + +#include <stddef.h> + +/** + * @defgroup sys_15_4_init Initialization API + * @ingroup sys_15_4 + * @{ + * @brief API for initizalizing the system abstraction library. + */ + +/** @brief Initializes every component of this stack. + * + * This function must be called before using any of the components. + * + * @param[in] p_start Pool start address. + * @param[in] size Size of the pool in bytes. + * + * @details The pool start address must be aligned on the ALIGN_VALUE boundary, which is + * defined in @c sys_utils.h. + * The pool size should be multiple of an ALIGN_VALUE, which is defined in @c sys_utils.h. + */ +void sys_init(void * p_start, size_t size); + +/** @} */ + +#endif /* SYS_INIT_H_INCLUDED */ diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/802_15_4/api/SysAL/sys_list.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/802_15_4/api/SysAL/sys_list.h new file mode 100644 index 0000000..533ee6f --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/802_15_4/api/SysAL/sys_list.h @@ -0,0 +1,248 @@ +/** + * Copyright (c) 2016 - 2018 Nordic Semiconductor ASA and Luxoft Global Operations Gmbh. + * + * All Rights Reserved. + * + * 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, except as embedded into a Nordic + * Semiconductor ASA integrated circuit in a product or a software update for + * such product, 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 Nordic Semiconductor ASA nor the names of its + * contributors may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * 4. This software, with or without modification, must only be used with a + * Nordic Semiconductor ASA integrated circuit. + * + * 5. Any software provided in binary form under this license must not be reverse + * engineered, decompiled, modified and/or disassembled. + * + * + * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA 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 SYS_LIST_H_INCLUDED +#define SYS_LIST_H_INCLUDED + +/** @file + * This file contains declarations of the doubly linked list primitives and necessary types. + * This implementation is Linux-proven and used in the memory management module. + * + * @defgroup sys_list Doubly linked list API. + * @ingroup sys_15_4 + * @{ + * @brief Module to declare the doubly linked list API. + */ + +/** + * Internal list "head" struct. + */ +struct sys_list_head +{ + struct sys_list_head * next; + struct sys_list_head * prev; +}; + +typedef struct sys_list_head sys_list_head_t; + + +/** + * @brief Initializes a list by variable name. + * @warning this macro assumes that a list "head" (sys_list_head_t) variable + * with name \a name is already created. + * + * @param[inout] name The "head" struct name. + */ +#define LIST_HEAD_INIT(name) { &(name), &(name) } + +/** + * @brief Defines and initializes a new list. + * @details A call to this macro creates a new variable with the given name and + * initializes it as a list "head". + * + * @param[inout] name The "head" struct name. + */ +#define LIST_HEAD(name) sys_list_head_t name = { &(name), &(name) } + + +/** + * @brief Initializes a list by pointer. + * + * @param[inout] ptr Pointer to a list. + */ +#define INIT_LIST_HEAD(ptr) \ + do \ + { \ + (ptr)->prev = (ptr); \ + (ptr)->next = (ptr); \ + } while (0) + + +/** + * @brief Checks if a list is empty. + * + * @param[in] sys_list_head Pointer to a list. + * @return 0 if not empty, non-zero otherwise. + */ +#define IS_EMPTY(sys_list_head) (sys_list_head)->next == (sys_list_head) + + +/** + * @brief Adds a new item to the list between \a l_prev and \a l_next elements. + * @warning This routine assumes that \a l_next is next to \a l_prev in the list. + * @note This is an internal helper routine which is not intended to be used by the user. + * + * @param[in] l_prev Pointer to the previous element. + * @param[in] l_next Pointer to the next element. + * @param[in] l_new Pointer to a new element. + */ +static inline void sys_ll_list_add(sys_list_head_t * l_prev, + sys_list_head_t * l_next, + sys_list_head_t * l_new) +{ + l_new->prev = l_prev; + l_prev->next = l_new; + l_next->prev = l_new; + l_new->next = l_next; +} + +/** + * @brief Deletes an element between \a l_prev and \a l_next elements. + * @warning This macro assumes that \a l_next is next to \a l_prev in the list. + * @note This is an internal helper routine which is not intended to be used by the user. + * + * @param[in] l_prev Pointer to the previous element. + * @param[in] l_next Pointer to the next element. + */ +static inline void sys_ll_list_del(sys_list_head_t * l_next, + sys_list_head_t * l_prev) +{ + l_next->prev = l_prev; + l_prev->next = l_next; +} + +/** + * @brief Function for adding a new item to the head of the list. + * + * @param[in] new Pointer to a new element. + * @param[in] head Pointer to the list head. + */ +static inline void sys_list_add(sys_list_head_t * new, sys_list_head_t * head) +{ + sys_ll_list_add(head, head->next, new); +} + + +/** + * @brief Function for adding a new item to the tail of the list. + * + * @param[in] new Pointer to a new element. + * @param[in] head Pointer to the list head. + */ +static inline void sys_list_add_tail(sys_list_head_t * new, sys_list_head_t * head) +{ + sys_ll_list_add(head->prev, head, new); +} + + +/** + * @brief Function for deleting an entry from list. + * + * @param[in] entry The element to delete from the list. + */ +static inline void sys_list_del(sys_list_head_t * entry) +{ + sys_ll_list_del(entry->next, entry->prev); +} + + +/** + * @brief Function for deleting an entry from the list and reinitializing it. + * + * @param[in] entry The element to delete from the list. + */ +static inline void sys_list_del_init(sys_list_head_t * entry) +{ + sys_ll_list_del(entry->next, entry->prev); + INIT_LIST_HEAD(entry); +} + + +/** + * @brief Function for testing if a list is empty. + + * @param[in] head The list to test. + * @return 0 if not empty, non-zero otherwise. + */ +static inline unsigned int sys_list_empty(sys_list_head_t * head) +{ + return IS_EMPTY(head); +} + + +/** + * @brief Sets a pointer to a variable to the parent structure pointer using a + * pointer to a field in this structure. + * + * @note This is a version of @ref GET_PARENT_BY_FIELD() extended by setting to a variable. + * + * @param[out] ll_ret_var Variable pointer name to return. + * @param[in] ll_ptr Pointer to the structure field. + * @param[in] ll_type Name of the parent structure. + * @param[in] ll_member Name of the structure field. + */ +#define SYS_LIST_ENTRY(ll_ret_var, ll_ptr, ll_type, ll_member) \ + do \ + { \ + size_t p = (size_t) ll_ptr; \ + size_t off = offsetof(ll_type, ll_member); \ + ll_ret_var = (ll_type *) (p - off); \ + } while (0) + + +/** + * @brief Iterates through the list. + * @note Use @ref SYS_LIST_FOR_EACH_SAFE() for thread-safe cases. + * + * @param[out] pos Iterator variable. + * @param[in] head Pointer to the list head. + */ +#define SYS_LIST_FOR_EACH(pos, head) \ + for (pos = ((head)->next); \ + ((pos) != (head)); \ + pos = (pos)->next) + + +/** + * @brief Thread-safe version of @ref SYS_LIST_FOR_EACH(). + * + * @param[out] ll_pos Iterator variable. + * @param[out] ll_pos_n Temporary iterator variable (next entry). + * @param[in] ll_head Pointer to the list head. + */ +#define SYS_LIST_FOR_EACH_SAFE(ll_pos, ll_pos_n, ll_head) \ + for (ll_pos = (ll_head)->next, ll_pos_n = (ll_head)->next->next; \ + (ll_pos) != (ll_head); \ + ll_pos = ll_pos_n, ll_pos_n = ll_pos->next) + +/** @} */ + +#endif /* SYS_LIST_H_INCLUDED */ diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/802_15_4/api/SysAL/sys_memory_manager.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/802_15_4/api/SysAL/sys_memory_manager.h new file mode 100644 index 0000000..c05849b --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/802_15_4/api/SysAL/sys_memory_manager.h @@ -0,0 +1,92 @@ +/** + * Copyright (c) 2016 - 2018 Nordic Semiconductor ASA and Luxoft Global Operations Gmbh. + * + * All Rights Reserved. + * + * 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, except as embedded into a Nordic + * Semiconductor ASA integrated circuit in a product or a software update for + * such product, 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 Nordic Semiconductor ASA nor the names of its + * contributors may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * 4. This software, with or without modification, must only be used with a + * Nordic Semiconductor ASA integrated circuit. + * + * 5. Any software provided in binary form under this license must not be reverse + * engineered, decompiled, modified and/or disassembled. + * + * + * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA 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 SYS_MEMORY_MANAGER_H_INCLUDED +#define SYS_MEMORY_MANAGER_H_INCLUDED + +#include <stddef.h> +#include <stdint.h> + +/** @file + * This file contains declarations of the Memory manager API. + * + * @defgroup sys_memory_manager Memory Manager API + * @ingroup sys_15_4 + * @{ + * @brief Module to declare Memory Manager API. + * @details The Memory Manager module implements the standard API for allocating/freeing memory chunks. The module must + * be initialized by sys_mm_init() before a call to any alloc/free routines. The memory can be allocated by a + * call to sys_mm_alloc() and freed by a call to sys_mm_free(). Minimal chunk of memory to allocate is one byte, + * however the sys_mm_alloc() routine will allocate the number of bytes aligned to the length of the + * machine word (e.g. 4 bytes for 32-bit architectures). The module is implemented using the doubly linked + * lists API. + */ + +/**@brief Function for initializing the memory manager. + * @details Initialize the memory manager pool of the 'size' bytes length at 'p_start' address. + * + * @param p_start Pool start address. + * @param size Size of the pool in bytes. + */ +void sys_mm_init(void * p_start, size_t size); + + +/**@brief Function for allocating memory in the pool. + * @details Search and allocate free memory resources. + * + * @param[in] size Size of the requested memory. + * + * @retval Pointer to allocated memory, + * NULL in case of error. + */ +void * sys_mm_alloc(size_t size); + + +/**@brief Function for freeing the allocated memory. + * + * @param[in] p_addr Pointer to the memory to free. + * + */ +void sys_mm_free(void * p_addr); + +/** @} */ + +#endif // SYS_MEMORY_MANAGER_H_INCLUDED diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/802_15_4/api/SysAL/sys_queue.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/802_15_4/api/SysAL/sys_queue.h new file mode 100644 index 0000000..8f817c0 --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/802_15_4/api/SysAL/sys_queue.h @@ -0,0 +1,290 @@ +/** + * Copyright (c) 2016 - 2018 Nordic Semiconductor ASA and Luxoft Global Operations Gmbh. + * + * All Rights Reserved. + * + * 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, except as embedded into a Nordic + * Semiconductor ASA integrated circuit in a product or a software update for + * such product, 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 Nordic Semiconductor ASA nor the names of its + * contributors may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * 4. This software, with or without modification, must only be used with a + * Nordic Semiconductor ASA integrated circuit. + * + * 5. Any software provided in binary form under this license must not be reverse + * engineered, decompiled, modified and/or disassembled. + * + * + * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA 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 SYS_QUEUE_H_INCLUDED +#define SYS_QUEUE_H_INCLUDED + +#include <stdbool.h> +#include <stdint.h> + +/** @file + * This file contains declarations of the primitives to work with queues and necessary types. + * + * @defgroup sys_queues Queue API + * @ingroup sys_15_4 + * @{ + * @brief Module to declare the queue API. + * @details The queue module implements a set of routines to deal with queues. Before + * any calls to its API are issued, a queue must be initialized using sys_queue_init(). The following routines + * return queue items from different parts of an initialized queue without removing it from the queue: + * sys_queue_front(), sys_queue_back(), sys_queue_next(), and sys_queue_at(). + * The following routines insert elements to the queue: sys_queue_push_front(), + * sys_queue_push_back(), sys_queue_push_predicated(), sys_queue_push_predicated_force(), and sys_queue_insert(). + * The following routines remove elements from the queue: sys_queue_pop_front(), sys_queue_remove(), + * sys_queue_remove_after(). These helper routines get information about a queue: sys_queue_size() and + * sys_queue_is_empty(). The module also supports an iterator macro implemented by SYS_QUEUE_FOR_EACH(). + */ + +/**@brief Queue item descriptor. + * + * @details In order to store any user data struct in a queue, the user struct should contain + * a field of type 'sys_queue_item_t'. This field may be at any offset. + * The user data item can be cast from the queue item, + * by the \ref GET_PARENT_BY_FIELD() macro from sys_utils.h. + */ +typedef struct sys_queue_item_s +{ + struct sys_queue_item_s * next; +} sys_queue_item_t; + +/**@brief Queue descriptor. + */ +typedef sys_queue_item_t sys_queue_t; + +/**@brief Prototype of a predicate function for pushing an item into the queue. + * + * @details As a user of the queue library, implement the predicate function and pass it + * as a parameter to \ref sys_queue_push_predicated(). You can choose + * whether insertion of a new item should be done before the given existing item of + * the queue, or not. + * + * @param[in] p_before_item Pointer to the existing item before which a new item + * should be inserted. + * @param[in] p_new_item Pointer to the item to be inserted into the queue. + * + * @retval true Insertion is to be done before the given item, false otherwise. + */ +typedef bool (* sys_queue_push_predicate_t)( + sys_queue_item_t * p_before_item, + sys_queue_item_t * p_new_item); + + +/**@brief Function for initializing the queue before any other usage of the queue. + * + * @details Initialize (reset) the queue to its initial state. The queue becomes empty. + * + * @param[in] p_queue Queue to be initialized. + */ +void sys_queue_init(sys_queue_t * p_queue); + + +/**@brief Function for getting the front (head) item of the queue without removing it. + * + * @details Return a pointer to the item from the head of the queue but leave it in the queue. + * + * @param[in] p_queue Queue to get the item from. + * + * @retval Pointer to the head item of the queue, or NULL if the queue is empty. + */ +sys_queue_item_t * sys_queue_front(const sys_queue_t * p_queue); + + +/**@brief Function for getting the back (tail) item of the queue without removing it. + * + * @details Return a pointer to the item from the tail of the queue but leave it in the queue. + * + * @param[in] p_queue Queue to get the item from. + * + * @retval Pointer to the tail item of the queue, or NULL if the queue is empty. + */ +sys_queue_item_t * sys_queue_back(const sys_queue_t * p_queue); + + +/**@brief Function for getting the item, next to the given item of the queue. + * + * @details Return a pointer to the next item after the given one, or NULL if the + * given item is the last item of the queue. + * + * @param[in] p_queue Pointer to the queue. + * @param[in] p_item Pointer to the item. + * + * @retval Pointer to the next item after the given one, or NULL if the + * given item is the last item of the queue. + */ +sys_queue_item_t * sys_queue_next(const sys_queue_t * p_queue, const sys_queue_item_t * p_item); + + +/**@brief Function for pushing an item to the front (head) of the queue. + * + * @details This function inserts an item to the head of the queue. + * + * @param[in] p_queue Queue to push the item to. + * @param[in] p_item Item to insert to the front of the queue. + */ +void sys_queue_push_front(sys_queue_t * p_queue, sys_queue_item_t * p_item); + + +/**@brief Function for pushing an item to the back (tail) of the queue. + * + * @details This function inserts an item to the tail of the queue. + * + * @param[in] p_queue Queue to push the item to. + * @param[in] p_item Item to insert to the tail of the queue. + */ +void sys_queue_push_back(sys_queue_t * p_queue, sys_queue_item_t * p_item); + + +/**@brief Function for pushing an item to the queue with a predicate. + * + * @details Conditionally push an item to the queue using the given predicate that tries to determine + * the insertion position. + * + * @param[in] p_queue Queue to push the item to. + * @param[in] p_item Item to be pushed. + * @param[in] predicate Predicate to be used to find the insertion position. + * + * @retval true The item was inserted into the queue, false otherwise. + */ +bool sys_queue_push_predicated( + sys_queue_t * p_queue, + sys_queue_item_t * p_item, + sys_queue_push_predicate_t predicate); + + +/**@brief Function for pushing an item to the queue with a predicate forcing insertion to the tail if the predicate + * fails. + * + * @details Unconditionally push an item to the queue using the given predicate that tries to + * determine the insertion position. + * If predicate returns false, then force the insertion to the tail of the queue. + * + * @param[in] p_queue Queue to push item to. + * @param[in] p_item Item to be pushed. + * @param[in] predicate Predicate to be used to find the insertion position. + */ +void sys_queue_push_predicated_force( + sys_queue_t * p_queue, + sys_queue_item_t * p_item, + sys_queue_push_predicate_t predicate); + + +/**@brief Function for getting and removing the front (head) item from the queue. + * + * @details Get an item from the head of the queue and remove it from the queue. + * + * @param[in] p_queue Queue to get and remove the head item from. + * + * @retval Pointer to the head item of queue or NULL if the queue is empty. + */ +sys_queue_item_t * sys_queue_pop_front(sys_queue_t * p_queue); + + +/**@brief Function for removing an item from the queue. + * + * @details The given item will be removed from the queue. + * + * @note The complexity of this function is O(n). Use function \ref sys_queue_remove_after() + * whenever the previous item of the queue is known. + * + * @param[in] p_queue Queue to remove the item from. + * @param[in] p_item Item to remove from the queue. + */ +void sys_queue_remove(sys_queue_t * p_queue, sys_queue_item_t * p_item); + + +/**@brief Function for removing the item after the given item from the queue. + * + * @details The item next to the given one will be removed from the queue. + * + * @param[in] p_queue Queue to remove the item from. + * @param[in] p_after_item Next to this item will be removed. + */ +void sys_queue_remove_after(sys_queue_t * p_queue, sys_queue_item_t * p_after_item); + + +/**@brief Function for returning the current size of a queue, i.e. number of elements inside it. + * + * @details This function goes through the whole queue, so it is relatively slow. + * + * @param[in] p_queue Queue to work with. + * + * @retval Number of items currently inserted into the queue. + */ +uint8_t sys_queue_size(const sys_queue_t * p_queue); + + +/**@brief Function for returning a pointer to the item inside a queue represented by an index. + * + * @details This function searches through the whole queue, so it is relatively slow. + * + * @param[in] p_queue Queue to work with. + * @param[in] index Requested index. + * + * @retval Pointer to the requested item or NULL if the queue size is less + * than \a index. + */ +sys_queue_item_t * sys_queue_at(const sys_queue_t * p_queue, const uint8_t index); + + +/**@brief Function for inserting an item at the specified position represented by an index in the queue. + * If this position is too big, it is inserted to the tail of the queue. + * + * @details This function searches through the whole queue, so it is relatively slow. + * + * @param[in] p_queue Queue to insert to. + * @param[in] p_item Item to be inserted. + * @param[in] pos Position inside the queue (0 is the front). + */ +void sys_queue_insert(sys_queue_t * p_queue, sys_queue_item_t * p_item, const uint8_t pos); + + +/**@brief Function for determining if a queue is empty. + * + * @param[in] p_queue Queue to be checked. + * + * @retval True if queue is empty, false otherwise. + */ +bool sys_queue_is_empty(const sys_queue_t * p_queue); + + +/**@brief Macro for iterating through all items in the queue. + * + * @param[in] p_queue Pointer to the queue (sys_queue_t *). + * @param[in] p_iterator Variable to be used as an iterator (sys_queue_item_t *). + */ +#define SYS_QUEUE_FOR_EACH(p_queue, p_iterator) \ + for (sys_queue_item_t * p_iterator = sys_queue_front(p_queue); \ + p_iterator != NULL; \ + p_iterator = sys_queue_next(p_queue, p_iterator)) + +/** @} */ + +#endif // SYS_QUEUE_H_INCLUDED diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/802_15_4/api/SysAL/sys_ringbuffer.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/802_15_4/api/SysAL/sys_ringbuffer.h new file mode 100644 index 0000000..fcd8277 --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/802_15_4/api/SysAL/sys_ringbuffer.h @@ -0,0 +1,202 @@ +/** + * Copyright (c) 2016 - 2018 Nordic Semiconductor ASA and Luxoft Global Operations Gmbh. + * + * All Rights Reserved. + * + * 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, except as embedded into a Nordic + * Semiconductor ASA integrated circuit in a product or a software update for + * such product, 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 Nordic Semiconductor ASA nor the names of its + * contributors may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * 4. This software, with or without modification, must only be used with a + * Nordic Semiconductor ASA integrated circuit. + * + * 5. Any software provided in binary form under this license must not be reverse + * engineered, decompiled, modified and/or disassembled. + * + * + * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA 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 SYS_RINGBUFFER_H_INCLUDED +#define SYS_RINGBUFFER_H_INCLUDED + +#include <stdint.h> +#include <stdlib.h> +#include <stdbool.h> + +/** @file + * This file contains declarations of the Ring buffer routines and necessary types. Please note that + * each ring buffer element should have size of 1 byte. + * + * @defgroup sys_ringbuffer System Ring buffer API + * @ingroup sys_15_4 + * @{ + * @brief Module for declaring System Ring buffer API. + * @details The Ring Buffer module implements routines to deal with the ring buffer. The following routines are supported: + * sys_ringbuffer_insert(), sys_ringbuffer_remove() to operate with single element. The + * sys_ringbuffer_remove_multiple() can be used to remove (read) several elements at once. The + * sys_ringbuffer_clear(), sys_ringbuffer_init(), and sys_ringbuffer_init_over() functions are used to clean up and + * initialize the ring buffer. Some information about the initialized ring buffer is available via the + * following routines: sys_ringbuffer_size_get() to get the number of used elements, sys_ringbuffer_chunk_get() + * to return the biggest, available to read, continuous chunk of elements, sys_ringbuffer_is_empty() and + * sys_ringbuffer_is_full() to check if the ring buffer is empty/full, and sys_ringbuffer_max_size_get() to get + * the ring buffer capacity. One of the samples for ring buffer usage is the UART implementation. + */ + +/** This structure holds all necessary information about a ring buffer. It is intentionally left undocumented + * by Doxygen. + * + * All these fields are private and must NOT be changed by the user. + */ +typedef struct +{ + size_t write_index; + size_t read_index; + uint8_t * array; + size_t size; + bool is_full; +} sys_ringbuffer_t; + +/** @brief Function for initializing an empty ring buffer over passed memory. + * + * @param[inout] buffer Instance of sys_ringbuffer_t that will be initialized. + * @param[in] memory Start address of the memory region used as a ring buffer. + * @param[in] length Size in bytes of the memory region used as a ring buffer. + */ +void sys_ringbuffer_init(sys_ringbuffer_t * buffer, + const void * memory, + const size_t length); + +/** @brief Function for initializing a ring buffer over passed memory and marking all + * pre_init_length elements as inserted. + * + * @details This function may be used to initialize a buffer with some + * pre-initialized data in it. Passed memory region is interpreted by this function + * as an already filled (partly or fully) ring buffer so that \a pre_init_length + * elements are marked as inserted. + * + * @param[inout] buffer Instance of sys_ringbuffer_t that will be initialized. + * @param[in] memory Start address of the memory region used as a ring buffer. + * @param[in] pre_init_length Number of elements (bytes) that had already been in \a memory. + * They would be inserted into the newly-initialized ring buffer in a FIFO manner. + * @param[in] length Size of the memory region used as a ring buffer. + */ +void sys_ringbuffer_init_over(sys_ringbuffer_t * buffer, + const void * memory, + const size_t pre_init_length, + const size_t length); + +/** @brief Function for removing an element from a ring buffer and returning it. + * + * @param[inout] buf Instance of @c sys_ringbuffer_t. + * + * @return Value of the removed element. + * + * @warning This buffer has no underflow control except assert. + */ +uint8_t sys_ringbuffer_remove(sys_ringbuffer_t * buf); + +/** @brief Function for quickly removing up to chunk_size elements from a ring buffer + * and marking those elements as available in the ring buffer. + * + * @param[inout] buffer Instance of @c sys_ringbuffer_t. + * @param[in] chunk_size Number of elements to release. + */ +void sys_ringbuffer_remove_multiple(sys_ringbuffer_t * buffer, + const size_t chunk_size); + +/** @brief Function for inserting a new element into a ring buffer. + * + * @param[inout] buffer Instance of @c sys_ringbuffer_t. + * @param[in] data Element value to insert. + * + * @warning In case of overflow, this buffer will overwrite the oldest + * element and the number of available elements will remain unchanged. + */ +void sys_ringbuffer_insert(sys_ringbuffer_t * buffer, const uint8_t data); + +/** @brief Function for clearing an instance of \a sys_ringbuffer_t, making it empty. + * + * @param[inout] buffer Instance of @c sys_ringbuffer_t. + */ +void sys_ringbuffer_clear(sys_ringbuffer_t * buffer); + +/** @brief Function for returning the number of used elements in a ring buffer instance. + * + * @param[inout] buf Instance of sys_ringbuffer_t. + * + * @return Number of elements. + */ +size_t sys_ringbuffer_size_get(const sys_ringbuffer_t * buf); + +/** @brief Function for returning the biggest, available to read, continuous chunk from a ring buffer array. + * + * @param[inout] buffer Instance of @c sys_ringbuffer_t. + * @param[out] chunk Pointer to a memory chunk removed from the ring buffer. + * @param[out] chunk_size Size of the removed chunk. + * + * @warning The returned chunk is still part of the ring buffer. To make the chunk elements available + * for write, call @c sys_ringbuffer_remove_multiple() after the chunk is processed. + */ +void sys_ringbuffer_chunk_get(sys_ringbuffer_t * buffer, + void ** chunk, + size_t * chunk_size); + +/** @brief Function for checking whether a ring buffer is empty. + * + * @param[inout] buf Instance of @c sys_ringbuffer_t. + * + * @return True if the ring buffer is empty. + */ +static inline bool sys_ringbuffer_is_empty(const sys_ringbuffer_t * buf) +{ + return ((buf->write_index == buf->read_index) && (!buf->is_full)); +} + +/** @brief Function for checking whether a ring buffer is full. + * + * @param[inout] buf Instance of @c sys_ringbuffer_t. + * + * @return True if number of items in the buffer equals to (length - 1). + */ +static inline bool sys_ringbuffer_is_full(const sys_ringbuffer_t * buf) +{ + return buf->is_full; +} + +/** @brief Function for returning number of elements that can be potentially put into the buffer. + * + * @param[inout] buf Instance of @c sys_ringbuffer_t. + * + * @return Number of elements. + */ +static inline size_t sys_ringbuffer_max_size_get(const sys_ringbuffer_t * buf) +{ + return buf->size; +} + +/** @} */ + +#endif /* SYS_RINGBUFFER_H_INCLUDED */ diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/802_15_4/api/SysAL/sys_slab_allocator.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/802_15_4/api/SysAL/sys_slab_allocator.h new file mode 100644 index 0000000..006f7d2 --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/802_15_4/api/SysAL/sys_slab_allocator.h @@ -0,0 +1,142 @@ +/** + * Copyright (c) 2016 - 2018 Nordic Semiconductor ASA and Luxoft Global Operations Gmbh. + * + * All Rights Reserved. + * + * 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, except as embedded into a Nordic + * Semiconductor ASA integrated circuit in a product or a software update for + * such product, 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 Nordic Semiconductor ASA nor the names of its + * contributors may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * 4. This software, with or without modification, must only be used with a + * Nordic Semiconductor ASA integrated circuit. + * + * 5. Any software provided in binary form under this license must not be reverse + * engineered, decompiled, modified and/or disassembled. + * + * + * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA 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 SYS_SLAB_ALLOCATOR_H_INCLUDED +#define SYS_SLAB_ALLOCATOR_H_INCLUDED + +#include "phy_pd_data.h" + +#ifndef CONFIG_SLAB_FRAME_POOL_SIZE +#define CONFIG_SLAB_FRAME_POOL_SIZE 4 +#warning "CONFIG_SLAB_FRAME_POOL_SIZE not set in .config, using default" +#endif + +/** @file + * This file contains declarations of the SLAB allocator API. + * + * @defgroup sys_slab_allocator SLAB Allocator API + * @ingroup sys_15_4 + * @{ + * @brief Module for declaring the SLAB Allocator API + */ + +/**@brief The SLAB allocator buffer type (free or busy buffer). + */ +typedef enum +{ + SYS_SLAB_FREE_BUFFER, /**< The buffer is free */ + SYS_SLAB_BUSY_BUFFER, /**< The buffer is busy */ +} sys_slab_buffer_type_t; + +/**@brief Initializes the SLAB allocator. + * + * @details Preallocates the frame pool + */ +void sys_sa_init(void); + +/**@brief Resets the SLAB allocator. + * + * @details Clear allocated the frame pools + */ +void sys_sa_reset(void); + +/**@brief Inserts item into one of the queues of the SLAB allocator. + * + * @details This function is used to put the item into the SLAB allocator + * queue. Type of buffer shall be chosen. + * + * @param[in] type Type of an inserted buffer (free or busy). + * @param[in] p_item Pointer to an inserted buffer. + */ +void sys_sa_buffer_put(sys_slab_buffer_type_t type, pd_data_ind_t * p_item); + +/**@brief Gets item from one of the queues of the SLAB allocator. + * + * @details This function is used to get the item from the SLAB allocator + * queues. Type of buffer shall be chosen. The buffer is deleted + * from the SLAB allocator + * + * @param[in] type Type of a gotten buffer (free or busy). + * + * @retval Pointer to a gotten buffer in case of success. NULL otherwise. + */ +pd_data_ind_t * sys_sa_buffer_get(sys_slab_buffer_type_t type); + +/**@brief Deletes an allocated item from the heap. + * + * @details This function is used to delete allocated by SLAB allocator buffer + * from the heap. Pointer to a frame memory of an allocated item shall be used. + * + * @param[in] p_frame Pointer to a frame memory of an allocated item. + */ +void sys_sa_buffer_free(uint8_t * p_frame); + +/**@brief Returns buffer back to queue of free buffers. + * + * @details This function is used to return allocated buffer back to the queue + * without allocation and deallocation. + * + * @param[in] p_item Pointer to an allocated item. + */ +void sys_sa_buffer_release(pd_data_ind_t * p_item); + +/**@brief Allocates memory for the queue of free buffers. + * + * @details This function is used to allocate buffer from heap + * and put them into the queue + * + * @retval True in case of success. False otherwise. + */ +bool sys_sa_memory_allocate(void); + +/**@brief Checks if there are any buffers in the SLAB allocator queue or not. + * + * @details Type of checked buffers shall be passed. + * + * @param[in] type Type of an checked buffers (free or busy). + * + * @retval True in case of absence of buffers. False otherwise. + */ +bool sys_sa_is_empty(sys_slab_buffer_type_t type); + +/** @} */ + +#endif /* SYS_SLAB_ALLOCATOR_H_INCLUDED */ diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/802_15_4/api/SysAL/sys_sleep.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/802_15_4/api/SysAL/sys_sleep.h new file mode 100644 index 0000000..0174ac4 --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/802_15_4/api/SysAL/sys_sleep.h @@ -0,0 +1,155 @@ +/** + * Copyright (c) 2016 - 2018 Nordic Semiconductor ASA and Luxoft Global Operations Gmbh. + * + * All Rights Reserved. + * + * 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, except as embedded into a Nordic + * Semiconductor ASA integrated circuit in a product or a software update for + * such product, 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 Nordic Semiconductor ASA nor the names of its + * contributors may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * 4. This software, with or without modification, must only be used with a + * Nordic Semiconductor ASA integrated circuit. + * + * 5. Any software provided in binary form under this license must not be reverse + * engineered, decompiled, modified and/or disassembled. + * + * + * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA 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 SYS_SLEEP_H_INCLUDED +#define SYS_SLEEP_H_INCLUDED + +#include <stdint.h> +#include "sys_events.h" +#include "hal_sleep.h" + + +/** @file + * + * @defgroup sys_sleep Falling Asleep API + * @ingroup sys_15_4 + * @{ + * @brief Module for declaring the Falling Asleep API. + * @details Because additional preparation may be required to be done by user modules, + * prior to putting hardware into the sleep mode, a notification and approval mechanism + * is provided to the user. + * Each module that wants to be notified about the "falling asleep" event, has to subscribe + * to the HAL_EVENT_FALLING_ASLEEP event, using sys_sleep_approver_register(), and to + * get the unique approver's ID value. + * In the handler of the HAL_EVENT_FALLING_ASLEEP event, the module is able to perform + * the required preparation before falling asleep, and to approve the falling asleep request, + * using the module unique approver ID, after all preparation to sleep is finished. + * The hardware will fall asleep only after all the registered approvers + * approve the fall asleep request. + */ + +/**@brief Approver ID typedef. + */ +typedef uint8_t sys_sleep_approver_id_t; + + +/* Sanity check for CONFIG_MAX_SLEEP_APPROVERS + */ +#if (!defined(CONFIG_MAX_SLEEP_APPROVERS)) +# error "CONFIG_MAX_SLEEP_APPROVERS must be defined in config file" +#elif (CONFIG_MAX_SLEEP_APPROVERS >= 256) +# error "CONFIG_MAX_SLEEP_APPROVERS must be less than 256" +#endif + + +/**@brief Function for initializing the system sleep module. + * + * @details This function must be called before any usage of the System Sleep module. + */ +void sys_sleep_init(void); + + +/**@brief Function for registering the approver of the system sleep request. + * + * @details After the sleep approver is registered with this function, the hardware will + * not fall asleep without its approval. + * + * @param[in] p_event_falling_asleep Event descriptor, which will handle + * the SYS_EVENT_FALLING_ASLEEP event. + * @param[in] p_event_wake_up Event descriptor, which will handle + * the SYS_EVENT_WAKE_UP event. + * + * @retval The unique approver ID, reserved for this newly-registered approver. + * This ID will be required to approve system sleep requests by this approver module. + */ +sys_sleep_approver_id_t sys_sleep_approver_register( + sys_event_desc_t * p_event_falling_asleep, + sys_event_desc_t * p_event_wake_up); + + +/**@brief Function for unregistering the approver of the system sleep request. + * + * @details After the approver is unregistered, its approval will not be + * required to put the system into sleep mode. + * + * @param[in] approver_id The unique approver ID to be unregistered. + * @param[in] p_event_falling_asleep Event descriptor to unsubscribe from + * the SYS_EVENT_FALLING_ASLEEP event. + * @param[in] p_event_wake_up Event descriptor to unsubscribe from + * the SYS_EVENT_WAKE_UP event. + */ +void sys_sleep_approver_unregister( + sys_sleep_approver_id_t approver_id, + sys_event_desc_t * p_event_falling_asleep, + sys_event_desc_t * p_event_wake_up); + + +/**@brief Function for approving the system sleep request. + * + * @details This function is to be called by the registered approver + * in order to approve putting the system into the sleep mode. + * + * @param[in] approver_id The unique approver ID. + */ +void sys_sleep_approve(sys_sleep_approver_id_t approver_id); + + +/**@brief Function for requesting the system to safely enter into sleep mode. + * + * @details This function notifies all the registered sleep approvers with the + * HAL_EVENT_FALLING_ASLEEP event, allowing them to perform all the needed preparation + * before the hardware falls asleep. The hardware will enter sleep mode only after + * all registered approvers approve the fall asleep request. + * + * @param[in] sleep_time_ms Defines sleep time in ms. + */ +void sys_sleep_request_ms(uint32_t sleep_time_ms); + + +/**@brief Function for getting information about the wakeup reason. + * + * @retval hal_wakeup_reason Interrupt source which was the wakeup reason. + */ +hal_wakeup_reason_t sys_sleep_wakeup_reason(void); + +/** @} */ + +#endif // SYS_SLEEP_H_INCLUDED diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/802_15_4/api/SysAL/sys_task_scheduler.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/802_15_4/api/SysAL/sys_task_scheduler.h new file mode 100644 index 0000000..201b931 --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/802_15_4/api/SysAL/sys_task_scheduler.h @@ -0,0 +1,121 @@ +/** + * Copyright (c) 2016 - 2018 Nordic Semiconductor ASA and Luxoft Global Operations Gmbh. + * + * All Rights Reserved. + * + * 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, except as embedded into a Nordic + * Semiconductor ASA integrated circuit in a product or a software update for + * such product, 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 Nordic Semiconductor ASA nor the names of its + * contributors may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * 4. This software, with or without modification, must only be used with a + * Nordic Semiconductor ASA integrated circuit. + * + * 5. Any software provided in binary form under this license must not be reverse + * engineered, decompiled, modified and/or disassembled. + * + * + * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA 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 SYS_TASK_SCHEDULER_H_INCLUDED +#define SYS_TASK_SCHEDULER_H_INCLUDED + +#include <stdint.h> +#include <stdbool.h> +#include "sys_utils.h" +#include "hal_atomic.h" +#include "sys_events.h" + +/** @file + * @defgroup sys_task_scheduler Task scheduler + * @ingroup sys_15_4 + * @{ + * @brief Module for task scheduling. + */ + +/**@brief Identificators for registered handlers. + * + * Handlers will be called from the task scheduler. + */ +typedef enum +{ + PHY_TASK_ID, + HAL_TASK_ID, +#if (CONFIG_HIGHEST_LAYER_PHY == 0) + MAC_TASK_ID, +#endif + APP_TASK_ID, + SYS_TASK_ID, + SYS_TASKS_AMOUNT +} sys_task_ids_t; + +/**@brief Prototype of a task handler. + * + * @details Handler which will be called by the scheduler. + */ +typedef void (* sys_task_handler_t)(void); + +/**@brief Pending tasks. + * + * @details Variable which includes markers of pending tasks. + */ +extern volatile uint_fast16_t g_tasks; + +/**@brief Notify task scheduler to add a task for execution. + * + * @details The function sets a marker for the task for execution. + * The task handler implements a tree architecture. + * Task handler of each layer includes handlers of the layer's components. + * + * @param[in] task_id Task identificator. + */ +static inline void sys_task_post(sys_task_ids_t task_id) +{ + atomic_t atomic = 0; + + hal_atomic_start(&atomic); + g_tasks |= BIT(task_id); +#if (CONFIG_USE_SYS_TASK_NOTIFIER == 1) + sys_event_post(SYS_EVENT_NEW_TASK, NULL); +#endif + hal_atomic_end(&atomic); +} + +/**@brief Returns true, if there are any event flags awaiting in the system scheduler. + */ +static inline bool sys_tasks_pending(void) +{ + return g_tasks != 0; +} + +/**@brief Handle tasks in the main function. + * + * @details Handle tasks in the main function. + */ +void sys_task_run(void); + +/** @} */ + +#endif // SYS_TASK_SCHEDULER_H_INCLUDED diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/802_15_4/api/SysAL/sys_time.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/802_15_4/api/SysAL/sys_time.h new file mode 100644 index 0000000..00155b3 --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/802_15_4/api/SysAL/sys_time.h @@ -0,0 +1,180 @@ +/** + * Copyright (c) 2016 - 2018 Nordic Semiconductor ASA and Luxoft Global Operations Gmbh. + * + * All Rights Reserved. + * + * 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, except as embedded into a Nordic + * Semiconductor ASA integrated circuit in a product or a software update for + * such product, 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 Nordic Semiconductor ASA nor the names of its + * contributors may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * 4. This software, with or without modification, must only be used with a + * Nordic Semiconductor ASA integrated circuit. + * + * 5. Any software provided in binary form under this license must not be reverse + * engineered, decompiled, modified and/or disassembled. + * + * + * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA 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 SYS_TIME_H_INCLUDED +#define SYS_TIME_H_INCLUDED + +#include <stdint.h> +#include "sys_queue.h" + +/** @file + * This file contains declarations of the primitives to work with Time (timers) and necessary types. + * + * @defgroup sys_time Time API + * @ingroup sys_15_4 + * @{ + * @brief Module for declaring Time API. + * @details The system time module implements some routines to deal with time (timers). The timer can be started by + * sys_timer_start(), stopped by sys_timer_stop(), and adjusted after sleep by sys_timer_adjust(). Some + * information can be acquired by sys_timer_is_started() and sys_time_get(). The correct API for implementing hardware + * delays is sys_time_delay_us(). Note that the module must be initialized by sys_timers_init() which + * is done by sys_init(). + */ + +/**@brief Unsigned type of system time. + */ +typedef uint64_t sys_time_t; + +/**@brief Signed type of system time. + */ +typedef int64_t sys_signed_time_t; + +/**@brief Prototype of the user-defined timer callback. + * + * @param p_data Pointer to the data, specific for this callback. + */ +typedef void (* sys_timer_callback_t)(void * p_data); + + +/**@brief System timer type (one-shot or periodic timer). + */ +typedef enum +{ + SYS_TIMER_ONESHOT, /**< The timer is Oneshot */ + SYS_TIMER_PERIODIC /**< The timer is Periodic */ +} sys_timer_type_t; + + +/**@brief Timer descriptor. + */ +typedef struct +{ + /** Service field. */ + sys_queue_item_t item; + + /** Service field. */ + sys_time_t absolute_time; + + /** Relevant time moment, at which this timer is programmed to be triggered, + * measured in microseconds. + */ + sys_time_t interval; + + /** Periodic or one-shot timer. + * + * @details If type is set to SYS_TIMER_PERIODIC, the timer will restart automatically + * with the same period. + */ + sys_timer_type_t type; + + /** Timer callback function. + * + * @details This function is to be called, when this timer triggers. + */ + sys_timer_callback_t callback; + + /** Timer callback parameter. + * + * @details This pointer is to be passed to the timer callback function. + */ + void * p_data; +} sys_timer_t; + + +/**@brief Function for initializing the timers module. + */ +void sys_timers_init(void); + + +/**@brief Function for starting the timer. + * + * @details See the description of \ref sys_timer_t fields for the details + * on how to program the timer. + * + * @param[in] p_timer Pointer to a valid timer descriptor, which is filled by the user, + * according to \ref sys_timer_t fields description. + */ +void sys_timer_start(sys_timer_t * p_timer); + + +/**@brief Function for stopping the timer. + * + * @details This function is used to stop the timer, which was started earlier. + * After this function is called, the timer will not fire. + * + * @param[in] p_timer Pointer to a valid timer descriptor. + */ +void sys_timer_stop(sys_timer_t * p_timer); + + +/**@brief Function for checking if input timer has been started. + * + * @param[in] p_timer Pointer to a timer. + * + * @retval true p_timer has been started and has not been stopped yet. + * @retval false p_timer has never been started or already timed out. + */ +bool sys_timer_is_started(sys_timer_t * p_timer); + + +/**@brief Function for getting the current system time. + * + * @retval The current system timer counter value in microseconds. + */ +sys_time_t sys_time_get(void); + + +/**@brief Function for implementing a delay for short hardware delays. + * + * @warning Interrupts are NOT disabled inside this function. + * + * @param[in] delay_us Number of microseconds to delay. + */ +void sys_time_delay_us(uint32_t delay_us); + + +/**@brief Function for executing expired timers after sleep. + */ +void sys_timer_adjust(void); + +/** @} */ + +#endif // SYS_TIME_H_INCLUDED diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/802_15_4/api/SysAL/sys_utils.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/802_15_4/api/SysAL/sys_utils.h new file mode 100644 index 0000000..d577292 --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/802_15_4/api/SysAL/sys_utils.h @@ -0,0 +1,541 @@ +/** + * Copyright (c) 2016 - 2018 Nordic Semiconductor ASA and Luxoft Global Operations Gmbh. + * + * All Rights Reserved. + * + * 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, except as embedded into a Nordic + * Semiconductor ASA integrated circuit in a product or a software update for + * such product, 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 Nordic Semiconductor ASA nor the names of its + * contributors may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * 4. This software, with or without modification, must only be used with a + * Nordic Semiconductor ASA integrated circuit. + * + * 5. Any software provided in binary form under this license must not be reverse + * engineered, decompiled, modified and/or disassembled. + * + * + * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA 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 SYS_UTILS_H_INCLUDED +#define SYS_UTILS_H_INCLUDED + +#include <stdint.h> +#include <stddef.h> +#include <string.h> +#if (defined(__GNUC__) && !defined(__SES_ARM)) +#include <strings.h> +#endif +#ifdef __MINGW32__ +#define ffs __builtin_ffs +#endif + +/** @file + * This file contains definitions of useful macros and types. + * + * @defgroup sys_utils System Utilities API + * @ingroup sys_15_4 + * @{ + * @brief Module to declare System Utilities API. + * @details The System Utilities module implements multiple useful macros and inlines for the whole stack. Including + * this header you will get access to GET_PARENT_BY_FIELD(), FIELD_SIZE() to work with complex structures, + * ARRAY_SIZE() for arrays, mathematics macros like IMP(), LL_MIN(), LL_MAX(), CEIL(), ROUND(), Bitmap helpers + * and many others. The variable arguments support macros are also defined here. Some SWAP routines are implemented + * by this module as well. + */ + +/**@brief Returns the pointer to the data structure + * + * @param[in] struct_type name of the parent structure + * @param[in] field_name name of the structure field + * @param[in] field_pointer pointer to the structure field + * + * @retval Pointer to the parent structure which includes the field. + */ +#define GET_PARENT_BY_FIELD(struct_type, field_name, field_pointer) \ + ((struct_type*)(void*)(((uint8_t*)field_pointer) - offsetof(struct_type, field_name))) + + +/**@brief Returns the implication of two given expressions x and y. + * @details The implication means: if X==TRUE then Y==TRUE. + * The formula is: (X imp Y) = ((not X) or Y) + */ +#define IMP(x, y) ( !(x) || (y) ) + + +/**@brief Returns the minimum of two given expressions x and y. + */ +#define LL_MIN(x, y) ( ((x) < (y)) ? (x) : (y) ) + + +/**@brief Returns the maximum of two given expressions x and y. + */ +#define LL_MAX(x, y) ( ((x) > (y)) ? (x) : (y) ) + + +/**@brief Returns the quotient of a divided by b rounded upwards to the nearest + * integer. + */ +#define CEIL(a, b) ((a) ? (((a) - 1U) / (b) + 1U) : 0U) + + +/**@brief Returns the quotient of a divided by b rounded to the nearest integer + * according to the standard arithmetic rules: if the fractional part of (a/b) is greater + * or equal to 0.5 then the result is rounded upwards; if the fractional part of (a/b) is + * less then 0.5 the result is rounded downwards. + * + * @note Use this formula only for unsigned arguments. The formula is not compatible with + * the signed arguments: when a and b have different signs it gives incorrect result. + */ +#define ROUND(a, b) ( ((a) + ((b) >> 1)) / (b) ) + + +/**@brief Declares a long bitmap named name of size bits. The size is rounded + * upwards to come a multiple of 8. + */ +#define BITMAP_DECLARE(name, size) uint8_t name[CEIL(size, 8)] + +/**@brief Clears all bits in given bitmap. + */ +#define BITMAP_RESET(name) memset((name), 0U, sizeof(name)) + +/**@brief Returns the value of a bit at position bit in the long bitmap named name. + */ +#define BITMAP_ISSET(name, bit) ( 0 != ((name)[(bit) >> 3] & (1 << ((bit) & 0x7))) ) + +/**@brief Sets the bit at position bit in the long bitmap named name. + */ +#define BITMAP_SET(name, bit) (name)[(bit) >> 3] |= (1 << ((bit) & 0x7)) + +/**@brief Clears the bit at position bit in the long bitmap named name. + */ +#define BITMAP_CLR(name, bit) (name)[(bit) >> 3] &= ~(1 << ((bit) & 0x7)) + +/**@brief Assigns the given bitmap with the second bitmap. + */ +#define BITMAP_ASSIGN(nameDst, nameSrc) memcpy((nameDst), (nameSrc), sizeof(nameDst)) + +/**@brief Compares two bitmaps and returns zero if they are equal. + */ +#define BITMAP_EQUAL(name1, name2) ((sizeof(name1) == sizeof(name2)) && \ + (memcmp((name1), (name2), sizeof(name1)) == 0)) + +/**@brief Checks number. Return true if number is power of two. + */ +#define LL_IS_POWER_OF_TWO(name) ((0 != (name)) && (0 == ((name)&(name - 1)))) + +/**@brief Return True if mask is fully included into a given set and False otherwise + */ +#define IS_SUBSET_OF(mask, set) ((mask) == ((set) & (mask))) + +/**@brief Creates a bit mask with single set bit on the specified position. + */ +#define BIT(pos) (1UL << (pos)) + +/**@brief Gets the given bit in the given value + */ +#define BIT_GET(val, pos) ((((uint32_t)val) & BIT(pos)) != 0) + +/**@brief Sets or clears the given bit in the given value + */ +#define BIT_SET(val, pos, bit) { \ + if (bit) \ + { \ + val |= BIT(pos); \ + } \ + else \ + { \ + val &= ~BIT(pos); \ + } \ + } + +/**@brief Returns two to the income power.*/ +#define POWER2(n) (1ULL << (n)) + +/**@brief Creates a bit mask of specified length. + */ +#define BIT_MASK(len) (BIT(len) - 1UL) + +/**@brief Creates a bit field mask of specified length and start position. + */ +#define BIT_FIELD_MASK(start, len) (BIT_MASK(len) << (start)) + +/**@brief Creates a bit field mask of specified length, start position and value. + */ +#define BIT_FIELD_VALUE(value, start, len) (((value) & BIT_MASK(len)) << (start)) + +/**@brief Extracts a bit field value of specified start position and length. + */ +#define GET_BITFIELD_VALUE(bitmask, start, len) (((bitmask) >> (start)) & BIT_MASK(len)) + +/**@brief Inserts a bit field value with specified start position and length. + */ +#define SET_BITFIELD_VALUE(bitmask, start, len, value) \ + (bitmask = (bitmask & ~BIT_FIELD_MASK(start, len)) | BIT_FIELD_VALUE(value, start, len)) + +/**@brief Extracts a mask from a BITMAP. + * BITMAP MUST be aligned and mask length MUST be one of 2, 4, 8, 16, 32. + */ +#define BITMAP_MASK_GET(bitmap, bit, len) \ + GET_BITFIELD_VALUE(((uint32_t*)(bitmap))[(bit) >> 5], (bit) & 0x1F, len) + +/**@brief Sets up a mask to a BITMAP. + * BITMAP MUST be aligned and mask length MUST be one of 2, 4, 8, 16, 32. + */ +#define BITMAP_MASK_SET(bitmap, bit, len, value) \ + SET_BITFIELD_VALUE(((uint32_t*)(bitmap))[(bit) >> 5], (bit) & 0x1F, len, value) + +/**@brief Gets amount of the arguments. + */ +#define VA_NARGS(...) VA_NARGS_EVAL(__VA_ARGS__) +#define VA_NARGS_EVAL(...) VA_NARGS_IMPL(__VA_ARGS__, \ + /* 255, 254, */ 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240, \ + 239, 238, 237, 236, 235, 234, 233, 232, 231, 230, 229, 228, 227, 226, 225, 224, \ + 223, 222, 221, 220, 219, 218, 217, 216, 215, 214, 213, 212, 211, 210, 209, 208, \ + 207, 206, 205, 204, 203, 202, 201, 200, 199, 198, 197, 196, 195, 194, 193, 192, \ + 191, 190, 189, 188, 187, 186, 185, 184, 183, 182, 181, 180, 179, 178, 177, 176, \ + 175, 174, 173, 172, 171, 170, 169, 168, 167, 166, 165, 164, 163, 162, 161, 160, \ + 159, 158, 157, 156, 155, 154, 153, 152, 151, 150, 149, 148, 147, 146, 145, 144, \ + 143, 142, 141, 140, 139, 138, 137, 136, 135, 134, 133, 132, 131, 130, 129, 128, \ + 127, 126, 125, 124, 123, 122, 121, 120, 119, 118, 117, 116, 115, 114, 113, 112, \ + 111, 110, 109, 108, 107, 106, 105, 104, 103, 102, 101, 100, 99, 98, 97, 96, \ + 095, 94, 93, 92, 91, 90, 89, 88, 87, 86, 85, 84, 83, 82, 81, 80, \ + 079, 78, 77, 76, 75, 74, 73, 72, 71, 70, 69, 68, 67, 66, 65, 64, \ + 063, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, \ + 047, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, \ + 031, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, \ + 015, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0) + +/**@brief Helper macro. Gets amount of the arguments. + */ +#define VA_NARGS_IMPL(_________1, _2, _3, _4, _5, _6, _7, \ + _8, _9, _10, _11, _12, _13, _14, _15, \ + __16, _17, _18, _19, _20, _21, _22, _23, \ + _24, _25, _26, _27, _28, _29, _30, _31, \ + __32, _33, _34, _35, _36, _37, _38, _39, \ + _40, _41, _42, _43, _44, _45, _46, _47, \ + __48, _49, _50, _51, _52, _53, _54, _55, \ + _56, _57, _58, _59, _60, _61, _62, _63, \ + __64, _65, _66, _67, _68, _69, _70, _71, \ + _72, _73, _74, _75, _76, _77, _78, _79, \ + __80, _81, _82, _83, _84, _85, _86, _87, \ + _88, _89, _90, _91, _92, _93, _94, _95, \ + __96, _97, _98, _99, _100, _101, _102, _103, \ + _104, _105, _106, _107, _108, _109, _110, _111, \ + _112, _113, _114, _115, _116, _117, _118, _119, \ + _120, _121, _122, _123, _124, _125, _126, _127, \ + _128, _129, _130, _131, _132, _133, _134, _135, \ + _136, _137, _138, _139, _140, _141, _142, _143, \ + _144, _145, _146, _147, _148, _149, _150, _151, \ + _152, _153, _154, _155, _156, _157, _158, _159, \ + _160, _161, _162, _163, _164, _165, _166, _167, \ + _168, _169, _170, _171, _172, _173, _174, _175, \ + _176, _177, _178, _179, _180, _181, _182, _183, \ + _184, _185, _186, _187, _188, _189, _190, _191, \ + _192, _193, _194, _195, _196, _197, _198, _199, \ + _200, _201, _202, _203, _204, _205, _206, _207, \ + _208, _209, _210, _211, _212, _213, _214, _215, \ + _216, _217, _218, _219, _220, _221, _222, _223, \ + _224, _225, _226, _227, _228, _229, _230, _231, \ + _232, _233, _234, _235, _236, _237, _238, _239, \ + _240, _241, _242, _243, _244, _245, _246, _247, \ + _248, _249, _250, _251, _252, _253, /* _254, _255, */\ + N, ...) N + +/**@brief Gets amount of the arguments. Execute by compiler. + */ +#define VA_NARGS_COMPILE_TIME(...) ((uint8_t)(sizeof((uint8_t[]){ __VA_ARGS__ })/sizeof(uint8_t))) + +/**@brief Swaps values. + */ +#define SWAP_XOR(a, b) \ + do \ + { \ + (((b) ^= (a) ^= (b), (a) ^= (b))); \ + } while(0); + +/**@brief Compare two number and take care of overflow threshold limit. + */ +#define COMPARE_WITH_THRESHOLD(a, b, threshold) \ + (((LL_MAX((a), (b)) - LL_MIN((a), (b))) < (threshold)) ? ((a) >= (b) ? 1 : 0) : ((a) > (b) ? 0 : 1)) + + +#define ROUND_MASK(a) ((a) - 1) +#define ROUND_UP(x, a) (((x) + ROUND_MASK(a)) & ~ROUND_MASK(a)) +#define ROUND_DOWN(x, a) ((x) & ~ROUND_MASK(a)) + +/**@brief Dereferences input pointer \a y as a type \a x. + * + * @param[in] x type name. + * @param[in] y pointer name. + */ +#define DEREF_VOID_PTR_AS(x, y) (*(x *)y) + +/**@brief Extends some bit value to the left extending 2's complement value + * to 8-bit length. + * + * @param[out] result variable, where result is store to. + * @param[in] x input value. + * @param[in] sign_pos an integer in range 2..6 specifying bit position of sign bit. + */ +#define SIGN_EXTENSION(result, x, sign_pos) \ + do \ + { \ + result = x & (1 << sign_pos) ? \ + x | (~((1 << (sign_pos + 1)) - 1)) : \ + x & ((1 << (sign_pos + 1)) - 1); \ + } while (0) + +/**@brief Clears some most significant bits of integer value reducing it precision. + * Name and interface of the macro emphasizes complementary action to #SIGN_EXTENSION. + * + * @param[out] result variable, where result is store to. + * @param[in] x input value. + * @param[in] sign_pos an integer in range 2..6 specifying bit position of sign bit. + */ +#define SIGN_COMPRESSION(result, x, sign_pos) \ + do \ + { \ + result = x & ((1 << (sign_pos + 1)) - 1); \ + } while (0) + +/************************* PROTOTYPES **************************************************/ +/**@brief Swaps values of two bytes. + * + */ +static inline void SWAP8(uint8_t * const x, uint8_t * const y) +{ + uint8_t _x = *x; + *x = *y; + *y = _x; +} + +/**@brief Swaps values of two double words (DWORD). + * + */ +static inline void SWAP32(uint32_t * const x, uint32_t * const y) +{ + uint32_t _x = *x; + *x = *y; + *y = _x; +} + +/**@brief Swaps values of two arrays. + * + * @param[inout] x array pointer + * @param[inout] y array pointer + * @param[in] length amount of bytes to swap + */ +static inline void SWAP_ARRAYS(void * x, void * y, uint32_t length) +{ + uint8_t *_x = (uint8_t *)(void *)x; + uint8_t *_y = (uint8_t *)(void *)y; + if (0x0 == ((((size_t)_x) | ((size_t)_y)) & 0x3)) + { + size_t len4 = length / sizeof(uint32_t); + for (size_t i = 0; i < len4; i++) + { + SWAP32((uint32_t*)_x, (uint32_t*)_y); + _x += sizeof(uint32_t); + _y += sizeof(uint32_t); + } + length &= 0x3; + } + + for (size_t i = 0; i < length; i++) + { + SWAP8(_x, _y); + _x++; + _y++; + } +} + + +/**@brief Find the first bit of the bitmap with the given value + * (one or zero, as specified). + * + * @param[in] p_bitmap Pointer to bitmap. + * @param[in] bitmap_size Number of bits in the bitmap. + * @param[in] bit_value The bit value to find (one or zero). + * + * @retval Bit position of the bit with specified value, or bitmap_size if no such bit + * was found. + */ +static inline size_t bitmap_find_bit(uint8_t * p_bitmap, size_t bitmap_size, uint8_t bit_value) +{ +#if (defined(__GNUC__) && !defined(__SES_ARM)) + if (bitmap_size <= 32) + { + uint32_t bitmap; + memcpy(&bitmap, p_bitmap, sizeof(uint32_t)); + if (!bit_value) + { + bitmap ^= 0xFFFFFFFF; + } + size_t result = ffs(bitmap); + if (result == 0 || result > bitmap_size) + { + return bitmap_size; + } + // built-in ffs implementation gives ffs(1) = 1, not 0 + return result - 1; + } + else +#endif + { + for (size_t i = 0; i < bitmap_size; i++) + { + if (BITMAP_ISSET(p_bitmap, i) == bit_value) + { + return i; + } + } + return bitmap_size; + } +} + +/**@brief Reverse the elements of array + * + * @param[in] ptr Pointer to array. + * @param[in] len Length of array. + */ +static inline void array_reverse(uint8_t * ptr, size_t len) +{ + for (size_t i = 0; i < len/2; i++) + { + SWAP_XOR(ptr[i], ptr[len - 1 - i]); + } +} + +/**@brief Returns least significant byte of word. + */ +#define LSB_WORD(x) ((uint8_t)(x & 0xFF)) + +/**@brief Returns least significant byte of halfword. + */ +#define LSB_HWORD(x) LSB_WORD(x) + +/**@brief Returns most significant byte of halfword. + */ +#define MSB_HWORD(x) ((uint8_t)(x >> 8)) + +#define ALIGN_VALUE (sizeof(size_t)) + +/**@brief Compiler-independent definitions. + */ +#if defined ( __CC_ARM ) + + #ifndef __WEAK + #define __WEAK __weak + #endif + + #ifndef PACK + #define PACK __attribute__ ((packed)) + #endif + + #ifndef BEGIN_PACK + #define BEGIN_PACK + #endif + + #ifndef END_PACK + #define END_PACK + #endif + +#ifndef __ALIGN + #define __ALIGN(n) __align(n) +#endif + +#elif defined ( __ICCARM__ ) + + #ifndef __WEAK + #define __WEAK __weak + #endif + + #ifndef PACK + #define PACK + #endif + + #ifndef BEGIN_PACK + #define BEGIN_PACK _Pragma("pack(push, 1)") + #endif + + #ifndef END_PACK + #define END_PACK _Pragma("pack(pop)") + #endif + +#ifndef __ALIGN + #define __ALIGN(n) +#endif + +#elif defined ( __GNUC__ ) + + #ifndef __WEAK + #define __WEAK __attribute__((weak)) + #endif + + #ifndef PACK + #define PACK __attribute__ ((packed)) + #endif + + #ifndef BEGIN_PACK + #define BEGIN_PACK _Pragma("pack(push,1)") + + #endif + + #ifndef END_PACK + #define END_PACK _Pragma("pack(pop)") + #endif + +#ifndef __ALIGN + #define __ALIGN(n) __attribute__((aligned(n))) +#endif + +#elif defined ( __TASKING__ ) + + #ifndef __WEAK + #define __WEAK __attribute__((weak)) + #endif + + #ifndef PACK + #define PACK __attribute__ ((packed)) + #endif + + #ifndef BEGIN_PACK + #define BEGIN_PACK + #endif + + #ifndef END_PACK + #define END_PACK + #endif + +#ifndef __ALIGN + #define __ALIGN(n) __align(n) +#endif + +#endif + +/** @} */ + +#endif /* SYS_UTILS_H_INCLUDED */ |