vance/vos
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

initial commit

Browse Source
This commit is contained in:
vance
2022-10-23 23:45:43 -07:00
commit e190fa5193
6450 changed files with 8626944 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
ambiq-hal-sys/ambiq-sparkfun-sdk/third_party/exactle/wsf/include/hci_defs.h
Vendored
+1372
View File
File diff suppressed because it is too large Load Diff
ambiq-hal-sys/ambiq-sparkfun-sdk/third_party/exactle/wsf/include/ll_defs.h
Vendored
+338
View File
@@ -0,0 +1,338 @@
/*************************************************************************************************/
/*!
* \file
*
* \brief Link layer constant definitions.
*
* $Date: 2017-03-10 20:10:06 -0600 (Fri, 10 Mar 2017) $
* $Revision: 11511 $
*
* Copyright (c) 2013-2017 ARM Ltd., all rights reserved.
* ARM Ltd. confidential and proprietary.
*
* IMPORTANT. Your use of this file is governed by a Software License Agreement
* ("Agreement") that must be accepted in order to download or otherwise receive a
* copy of this file. You may not use or copy this file for any purpose other than
* as described in the Agreement. If you do not agree to all of the terms of the
* Agreement do not use this file and delete all copies in your possession or control;
* if you do not have a copy of the Agreement, you must contact ARM Ltd. prior
* to any use, copying or further distribution of this software.
*/
/*************************************************************************************************/
#ifndef LL_DEFS_H
#define LL_DEFS_H
#include "wsf_types.h"
#ifdef __cplusplus
extern "C" {
#endif
/**************************************************************************************************
Constants
**************************************************************************************************/
/*** Version ***/
#define LL_VER_BT_CORE_SPEC_4_0 0x06 /*!< Bluetooth core specification 4.0 */
#define LL_VER_BT_CORE_SPEC_4_1 0x07 /*!< Bluetooth core specification 4.1 */
#define LL_VER_BT_CORE_SPEC_4_2 0x08 /*!< Bluetooth core specification 4.2 */
#define LL_VER_BT_CORE_SPEC_5_0 0x09 /*!< Bluetooth core specification 5.0 */
#define LL_COMP_ID_ARM 0x005F /*!< ARM Ltd. company ID. */
/*** Common ***/
#define LL_RSSI_MIN -127 /*!< Minimum RSSI value. */
#define LL_RSSI_MAX 20 /*!< Maximum RSSI value. */
#define LL_RSSI_NOT_AVAIL 127 /*!< RSSI is not available. */
#define LL_CRC_LEN 3 /*!< CRC length. */
#define LL_AA_LEN 4 /*!< Access address length. */
#define LL_PREAMBLE_LEN_1M 1 /*!< Preamble length (LE 1M PHY). */
#define LL_PREAMBLE_LEN_2M 2 /*!< Preamble length (LE 2M PHY). */
#define LL_PREAMBLE_LEN_CODED_BITS 10 /*!< Preamble length (LE Coded PHY). */
#define LL_CI_LEN_BITS 2 /*!< Coding indicator length (LE Coded PHY). */
#define LL_TERM1_LEN_BITS 3 /*!< TERM1 length (LE Coded PHY). */
#define LL_TERM2_LEN_BITS 3 /*!< TERM2 length (LE Coded PHY). */
#define LL_RAND_ADDR_MSBS_MASK 0x03 /*!< Mask of 2 most significant bits of BD Random Address */
#define LL_RAND_ADDR_MSBS_POS 46 /*!< Position of 2 MSBs of BD Random Address */
#define LL_RAND_ADDR_MSBS_STATIC 0x03 /*!< 2 most significant bits of BD Random Address are '0b11', static random address */
#define LL_RAND_ADDR_MSBS_RPA 0x01 /*!< 2 most significant bits of BD Random Address are '0b01', resolvable private address */
#define LL_RAND_ADDR_MSBS_NRPA 0x00 /*!< 2 most significant bits of BD Random Address are '0b00', non-resolvable private address */
#define LL_RAND_ADDR_MSBS_IVLD 0x02 /*!< 2 most significant bits of BD Random Address are '0b10', invalid random address */
/*** Advertising PDU ***/
/*! \brief Advertising channel PDU types. */
enum
{
/* --- Core Spec 4.0 --- */
LL_PDU_ADV_IND = 0, /*!< Connectable undirected advertising PDU. */
LL_PDU_ADV_DIRECT_IND = 1, /*!< Connectable directed advertising PDU. */
LL_PDU_ADV_NONCONN_IND = 2, /*!< Non-connectable undirected advertising PDU. */
LL_PDU_SCAN_REQ = 3, /*!< Scan request PDU. */
LL_PDU_SCAN_RSP = 4, /*!< Scan response PDU. */
LL_PDU_CONNECT_IND = 5, /*!< Connect indication PDU. */
LL_PDU_ADV_SCAN_IND = 6, /*!< Scannable undirected advertising PDU. */
/* --- Core Spec 5.0 --- */
LL_PDU_AUX_SCAN_REQ = 3, /*!< Auxiliary scan request PDU. */
LL_PDU_AUX_CONNECT_REQ = 5, /*!< Auxiliary connect request PDU. */
LL_PDU_ADV_EXT_IND = 7, /*!< Extended advertising PDU. */
LL_PDU_AUX_ADV_IND = 7, /*!< Auxiliary advertising PDU. */
LL_PDU_AUX_SCAN_RSP = 7, /*!< Auxiliary scan response PDU. */
LL_PDU_AUX_SYNC_IND = 7, /*!< Auxiliary synchronize PDU. */
LL_PDU_AUX_CHAIN_IND = 7, /*!< Auxiliary chain PDU. */
LL_PDU_AUX_CONNECT_RSP = 8, /*!< Auxiliary connect response PDU. */
};
#define LL_SCAN_REQ_PDU_LEN 12 /*!< Size of a scan request PDU. */
#define LL_CONN_IND_PDU_LEN 34 /*!< Size of a connect indication PDU. */
#define LL_CHAN_ADV_MIN_IDX 37 /*!< Minimum advertising channel index. */
#define LL_CHAN_ADV_MAX_IDX 39 /*!< Maximum advertising channel index. */
#define LL_NUM_CHAN_ADV 3 /*!< Total number of advertising channels. */
#define LL_ADVBU_MAX_LEN 31 /*!< Maximum advertising channel host data length. */
#define LL_ADVB_MAX_LEN 39 /*!< Maximum advertising channel PDU length. */
#define LL_ADVB_MIN_LEN (LL_ADVB_MAX_LEN - LL_ADVBU_MAX_LEN) /*!< Minimum advertising channel packet length. */
#define LL_ADVB_MAX_TIME_1M ((LL_BLE_US_PER_BYTE_1M * (LL_ADVB_MAX_LEN - LL_ADV_HDR_LEN)) + LL_MIN_PKT_TIME_US_1M)
/*!< Maximum time for a 1M advertising channel PDU. */
#define LL_ADVB_MAX_TIME_2M ((LL_BLE_US_PER_BYTE_2M * (LL_ADVB_MAX_LEN - LL_ADV_HDR_LEN)) + LL_MIN_PKT_TIME_US_2M)
/*!< Maximum time for a 2M advertising channel PDU. */
#define LL_ADVB_MAX_TIME_S2 ((LL_BLE_US_PER_BYTE_CODED_S2 * (LL_ADVB_MAX_LEN - LL_ADV_HDR_LEN)) + LL_MIN_PKT_TIME_US_CODED_S2)
/*!< Maximum time for a Coded S2 advertising channel PDU. */
#define LL_ADVB_MAX_TIME_S8 ((LL_BLE_US_PER_BYTE_CODED_S8 * (LL_ADVB_MAX_LEN - LL_ADV_HDR_LEN)) + LL_MIN_PKT_TIME_US_CODED_S8)
/*!< Maximum time for a Coded S8 advertising channel PDU. */
#define LL_ADV_PKT_MAX_USEC LL_ADVB_MAX_TIME_1M /*!< Maximum time in microseconds for an advertising packet. */
#define LL_SCAN_REQ_MAX_USEC ((8 * (LL_ADV_PREFIX_LEN + LL_SCAN_PREFIX_LEN)) + LL_MIN_PKT_TIME_US_1M)
/*!< Maximum time in microseconds for a scan request packet. */
#define LL_SCAN_RSP_MAX_USEC LL_ADVB_MAX_TIME_1M /*!< Maximum time in microseconds for a scan response packet. */
#define LL_ADV_HDR_LEN 2 /*!< Advertising channel header length. */
#define LL_ADV_HDR_TYPE_OFFS 0 /*!< Advertising header type offset. */
#define LL_ADV_HDR_TYPE_MSK 0x0F /*!< Advertising header type mask. */
#define LL_ADV_HDR_LEN_OFFS 1 /*!< Advertising header length offset. */
#define LL_ADV_HDR_LEN_MSK 0x3F /*!< Advertising header length mask for 4.2. */
#define LL_ADV_EXT_HDR_LEN_MSK 0xFF /*!< Advertising extension header length mask for 5.0. */
#define LL_ADV_PREFIX_LEN 6 /*!< Advertising PDU payload prefix length (AdvA). */
#define LL_SCAN_PREFIX_LEN 6 /*!< Scan request/response PDU payload prefix length (AdvA). */
#define LL_ADV_ACCESS_ADDR UINT32_C(0x8E89BED6) /*!< Advertising channel access address. */
#define LL_ADV_CRC_INIT UINT32_C(0x555555) /*!< Advertising CRC initial value. */
#define LL_DIR_ADV_INTER_TICKS 6 /*!< Advertising interval between directed advertising events (3.75 ms). */
#define LL_DIR_ADV_DUR_TICKS 2048 /*!< Maximum high duty cycle directed advertising duration (1.28 seconds). */
enum
{
LL_EXT_HDR_ADV_ADDR_BIT = (1 << 0), /*!< Extended header AdvA bit. */
LL_EXT_HDR_TGT_ADDR_BIT = (1 << 1), /*!< Extended header TargetA bit. */
LL_EXT_HDR_SUPP_INFO_BIT = (1 << 2), /*!< Extended header SuppInfo bit. */
LL_EXT_HDR_ADI_BIT = (1 << 3), /*!< Extended header AdvDataInfo bit. */
LL_EXT_HDR_AUX_PTR_BIT = (1 << 4), /*!< Extended header AuxPtr bit. */
LL_EXT_HDR_SYNC_INFO_BIT = (1 << 5), /*!< Extended header SyncInfo bit. */
LL_EXT_HDR_TX_PWR_BIT = (1 << 6), /*!< Extended header TxPower bit. */
};
#define LL_MAX_ADV_HANDEL 0xEF /*!< Maximum advertising handle. */
#define LL_MAX_ADV_SID 0x0F /*!< Maximum advertising SID */
#define LL_EXT_ADV_HDR_MIN_LEN 1 /*!< Minimum extended advertising header length (+1 for ExtHdrLen and AdvMode fields). */
#define LL_EXT_ADV_HDR_MAX_LEN 64 /*!< Maximum extended advertising header length (+1 for ExtHdrLen and AdvMode fields). */
#define LL_EXT_ADVBU_MAX_LEN 251 /*!< Maximum extended advertising channel PDU host data length. */
#define LL_EXT_ADVB_MAX_LEN 257 /*!< Maximum extended advertising channel PDU length. */
#define LL_AUX_PTR_MAX_USEC 2457600 /*!< Maximum AuxPtr offset value in microseconds. */
#define LL_SYNC_MIN_TIMEOUT 0x000A /*!< Minimum synchronization timeout. */
#define LL_SYNC_MAX_TIMEOUT 0x4000 /*!< Maximum synchronization timeout. */
#define LL_SYNC_MAX_SKIP 0x01F3 /*!< Maximum synchronization skip. */
#define LL_SYNC_MAX_HANDLE 0x0EFF /*!< Maximum synchronization handle. */
#define LL_PER_ADV_INT_MIN 0x0006 /*!< Minimum periodic advertising interval. */
/*** Data PDU ***/
/*! \brief Data channel LL Control PDU types. */
enum
{
/* --- Core Spec 4.0 --- */
LL_PDU_CONN_UPDATE_IND = 0x00, /*!< Connection update indication PDU. */
LL_PDU_CHANNEL_MAP_IND = 0x01, /*!< Channel map indication PDU. */
LL_PDU_TERMINATE_IND = 0x02, /*!< Terminate indication PDU. */
LL_PDU_ENC_REQ = 0x03, /*!< Encryption request PDU. */
LL_PDU_ENC_RSP = 0x04, /*!< Encryption response PDU. */
LL_PDU_START_ENC_REQ = 0x05, /*!< Start encryption request PDU. */
LL_PDU_START_ENC_RSP = 0x06, /*!< Start encryption response PDU. */
LL_PDU_UNKNOWN_RSP = 0x07, /*!< Unknown response PDU. */
LL_PDU_FEATURE_REQ = 0x08, /*!< Feature request PDU. */
LL_PDU_FEATURE_RSP = 0x09, /*!< Feature response PDU. */
LL_PDU_PAUSE_ENC_REQ = 0x0A, /*!< Pause encryption request PDU. */
LL_PDU_PAUSE_ENC_RSP = 0x0B, /*!< Pause encryption response PDU. */
LL_PDU_VERSION_IND = 0x0C, /*!< Version indication PDU. */
LL_PDU_REJECT_IND = 0x0D, /*!< Reject indication PDU. */
/* --- Core Spec 4.2 --- */
LL_PDU_SLV_FEATURE_REQ = 0x0E, /*!< Slave feature request PDU. */
LL_PDU_CONN_PARAM_REQ = 0x0F, /*!< Connection parameter request PDU. */
LL_PDU_CONN_PARAM_RSP = 0x10, /*!< Connection parameter response PDU. */
LL_PDU_REJECT_EXT_IND = 0x11, /*!< Reject extended indication PDU. */
LL_PDU_PING_REQ = 0x12, /*!< Ping request PDU. */
LL_PDU_PING_RSP = 0x13, /*!< Ping response PDU. */
LL_PDU_LENGTH_REQ = 0x14, /*!< Data length request PDU. */
LL_PDU_LENGTH_RSP = 0x15, /*!< Data length response PDU. */
/* --- Core Spec 5.0 --- */
LL_PDU_PHY_REQ = 0x16, /*!< PHY request PDU. */
LL_PDU_PHY_RSP = 0x17, /*!< PHY response PDU. */
LL_PDU_PHY_UPDATE_IND = 0x18, /*!< PHY update indication PDU. */
LL_PDU_MIN_USED_CHAN_IND = 0x19, /*!< Minimum used channels indication PDU. */
LL_PDU_UNSPECIFIED = 0xFF /*!< Unspecified PDU. */
};
/* Data PDU length */
/* --- Core Spec 4.0 --- */
#define LL_CONN_UPD_IND_PDU_LEN 12 /*!< Connection update indication PDU length. */
#define LL_CHAN_MAP_IND_PDU_LEN 8 /*!< Channel map indication PDU length. */
#define LL_TERMINATE_IND_PDU_LEN 2 /*!< Terminate indication PDU length. */
#define LL_ENC_REQ_LEN 23 /*!< Encryption request PDU length. */
#define LL_ENC_RSP_LEN 13 /*!< Encryption response PDU length. */
#define LL_START_ENC_LEN 1 /*!< Start encryption request/response PDU length. */
#define LL_UNKNOWN_RSP_LEN 2 /*!< Unknown response PDU length. */
#define LL_FEATURE_PDU_LEN 9 /*!< Feature request/response PDU length. */
#define LL_PAUSE_ENC_LEN 1 /*!< Pause encryption request/response PDU length. */
#define LL_VERSION_IND_PDU_LEN 6 /*!< Version indication PDU length. */
#define LL_REJECT_IND_PDU_LEN 2 /*!< Reject indication PDU length. */
/* --- Core Spec 4.2 --- */
#define LL_CONN_PARAM_PDU_LEN 24 /*!< Connection parameter request or response PDU length. */
#define LL_REJECT_EXT_IND_PDU_LEN 3 /*!< Reject extended indication PDU length. */
#define LL_PING_PDU_LEN 1 /*!< Ping request/response PDU length. */
#define LL_DATA_LEN_PDU_LEN 9 /*!< Data length request or response PDU length. */
/* --- Core Spec 5.0 --- */
#define LL_PHY_PDU_LEN 3 /*!< PHY request/response PDU length. */
#define LL_PHY_UPD_IND_PDU_LEN 5 /*!< PHY update indication PDU length. */
#define LL_MIN_USED_CHAN_PDU_LEN 3 /*!< Minimum used channels indication PDU length. */
#define LL_EMPTY_PDU_LEN 2 /*!< Length of an empty data PDU. */
#define LL_DATA_HDR_LEN 2 /*!< Data channel header length. */
#define LL_DATA_MIC_LEN 4 /*!< Data channel PDU MIC length. */
#define LL_DATA_HDR_LLID_MSK 0x03 /*!< Data PDU LLID mask. */
#define LL_DATA_HDR_LEN_MSK 0xFF /*!< Data header length mask. BLE 4.2 data len extension allows 8 bits. */
#define LL_MAX_NUM_CHAN_DATA 37 /*!< Maximum number of used data channels. */
#define LL_MIN_NUM_CHAN_DATA 2 /*!< Minimum number of used data channels. */
/*! \brief Data PDU LLID types. */
enum
{
LL_LLID_VS_PDU = 0x00, /*!< Vendor specific PDU. */
/* N.B. next two enumerations intentionally use identical values. */
LL_LLID_EMPTY_PDU = 0x01, /*!< Empty PDU. */
LL_LLID_CONT_PDU = 0x01, /*!< Data PDU: continuation fragment of an L2CAP message. */
LL_LLID_START_PDU = 0x02, /*!< Data PDU: start of an L2CAP message or a complete L2CAP message with no fragmentation. */
LL_LLID_CTRL_PDU = 0x03, /*!< Control PDU. */
};
/*** Encryption ***/
#define LL_ECC_KEY_LEN 32 /*!< ECC key length. */
#define LL_DEF_RES_ADDR_TO_SEC 900 /*!< Default resolvable address timeout in seconds. */
#define LL_RAND_LEN 8 /*!< Length of random number */
#define LL_KEY_LEN 16 /*!< Encryption key length. */
#define LL_SKD_LEN LL_KEY_LEN /*!< Session key diversifier length. */
#define LL_IV_LEN 8 /*!< Initialization vector length. */
#define LL_DEF_AUTH_TO_MS 30000 /*!< Default authentication timeout in milliseconds. */
/*** LLCP ***/
#define LL_DATA_LEN_TO_TIME_1M(len) ((LL_BLE_US_PER_BYTE_1M * ((len) + LL_DATA_MIC_LEN)) + LL_MIN_PKT_TIME_US_1M)
/*!< Convert data length to time. */
#define LL_DATA_LEN_TO_TIME_2M(len) ((LL_BLE_US_PER_BYTE_2M * ((len) + LL_DATA_MIC_LEN)) + LL_MIN_PKT_TIME_US_2M)
/*!< Convert data length to time. */
#define LL_DATA_LEN_TO_TIME_CODED_S8(len) ((LL_BLE_US_PER_BYTE_CODED_S8 * ((len) + LL_DATA_MIC_LEN)) + LL_MIN_PKT_TIME_US_CODED_S8)
/*!< Convert data length to time. */
#define LL_DATA_LEN_TO_TIME_CODED_S2(len) ((LL_BLE_US_PER_BYTE_CODED_S2 * ((len) + LL_DATA_MIC_LEN)) + LL_MIN_PKT_TIME_US_CODED_S2)
/*!< Convert data length to time. */
#define LL_MIN_INSTANT 6 /*!< Minimum number of CE to apply a CONN_UPD or CHAN_MAP. */
#define LL_MAX_DATA_LEN_MIN 27 /*!< Minimum value for maximum Data PDU length */
#define LL_MAX_DATA_LEN_ABS_MAX 251 /*!< Absolute maximum limit for maximum Data PDU length */
#define LL_MAX_DATA_TIME_MIN 328 /*!< Minimum value for maximum Data PDU time */
#define LL_MAX_DATA_TIME_ABS_MAX 17040 /*!< Absolute maximum limit for maximum Data PDU time */
#define LL_MAX_DATA_TIME_ABS_MAX_1M 2120 /*!< Absolute maximum limit for maximum Data PDU time (LE 1M PHY) */
#define LL_T_PRT_SEC 40 /*!< LLCP procedure response timeout in seconds. */
#define LL_MAX_ADV_DLY_MS 10 /*!< Maximum advertising delay in milliseconds. */
#define LL_MIN_CONN_INTERVAL 6 /*!< Minimum value for connection interval. */
#define LL_MAX_CONN_INTERVAL 3200 /*!< Maximum value for connection interval. */
#define LL_MIN_TX_WIN_SIZE 1 /*!< Minimum value for transmit window size. */
#define LL_MAX_TX_WIN_SIZE 8 /*!< Maximum value for transmit window size. */
#define LL_MAX_CONN_LATENCY 499 /*!< Maximum value for connection slave latency. */
#define LL_MIN_SUP_TIMEOUT 10 /*!< Minimum value for connection supervision timeout. */
#define LL_MAX_SUP_TIMEOUT 3200 /*!< Maximum value for connection supervision timeout. */
#define LL_MIN_POWER_THRESHOLD -128 /*!< Minimum value for power threshold. */
#define LL_MAX_POWER_THRESHOLD 127 /*!< Maximum value for power threshold. */
#define LL_ALL_PHYS_MSK 0x7 /*!< All supported LE PHYs mask. */
/*** DTM ***/
#define LL_DTM_HDR_LEN 2 /*!< Direct Test Mode PDU header length. */
#define LL_DTM_SYNC_WORD UINT32_C(0x71764129) /*!< Direct Test Mode sync word. */
#define LL_DTM_CRC_INIT UINT32_C(0x555555) /*!< Direct Test Mode CRC initial value. */
#define LL_DTM_MAX_INT_US 12500 /*!< Maximum time interval between packets in microseconds. */
#define LL_DTM_PDU_ABS_MAX_LEN 255 /*!< Absolute maximum DTM PDU length. */
#define LL_DTM_MAX_CHAN_IDX 39 /*!< Maximum channel index. */
/*** Baseband ***/
#define LL_CHAN_DATA_MIN_IDX 0 /*!< Minimum data channel index. */
#define LL_CHAN_DATA_MAX_IDX 36 /*!< Maximum data channel index. */
#define LL_CHAN_DATA_ALL UINT64_C(0x0000001FFFFFFFFF) /*!< Maximum data channel index. */
#define LL_BLE_BIT_PER_US 1 /*!< BLE PHY rate. */
#define LL_BLE_US_PER_BYTE_1M 8 /*!< BLE PHY speed (LE 1M PHY). */
#define LL_BLE_US_PER_BYTE_2M 4 /*!< BLE PHY speed (LE 2M PHY). */
#define LL_BLE_US_PER_BYTE_CODED_S8 64 /*!< BLE PHY speed (LE Coded PHY, S=8). */
#define LL_BLE_US_PER_BIT_CODED_S8 8 /*!< BLE PHY speed (LE Coded PHY, S=8). */
#define LL_BLE_US_PER_BYTE_CODED_S2 16 /*!< BLE PHY speed (LE Coded PHY, S=2). */
#define LL_BLE_US_PER_BIT_CODED_S2 2 /*!< BLE PHY speed (LE Coded PHY, S=2). */
#define LL_BLE_TIFS_US 150 /*!< BLE inter-frame space. */
#define LL_BLE_MAFS_US 300 /*!< BLE minimum AUX frame space. */
#define LL_BLE_US_PER_TICK 625 /*!< Microseconds per BLE tick. */
#define LL_MIN_PKT_TIME_US_1M 80 /*!< Minimum packet time (i.e. empty PDU) on LE 1M PHY. */
#define LL_MIN_PKT_TIME_US_2M 44 /*!< Minimum packet time (i.e. empty PDU) on LE 2M PHY. */
#define LL_MIN_PKT_TIME_US_CODED_S8 720 /*!< Minimum packet time (i.e. empty PDU) on LE Coded PHY, S=8. */
#define LL_MIN_PKT_TIME_US_CODED_S2 462 /*!< Minimum packet time (i.e. empty PDU) on LE Coded PHY, S=2. */
#define LL_MIN_ADV_TX_PWR_LVL -20 /*!< Minimum Tx power level for advertising. */
#define LL_MAX_ADV_TX_PWR_LVL 10 /*!< Maximum Tx power level for advertising. */
#define LL_MIN_TX_PWR_LVL -30 /*!< Minimum Tx power level for connections. */
#define LL_MAX_TX_PWR_LVL 20 /*!< Maximum Tx power level for connections. */
#define LL_MAX_TIFS_DEVIATION 2 /*!< Maximum TIFS deviation in microseconds. */
#ifdef __cplusplus
};
#endif
#endif /* LL_DEFS_H */
ambiq-hal-sys/ambiq-sparkfun-sdk/third_party/exactle/wsf/include/wsf_buf.h
Vendored
+196
View File
@@ -0,0 +1,196 @@
/*************************************************************************************************/
/*!
* \file wsf_buf.h
*
* \brief Buffer pool service.
*
* $Date: 2017-03-04 13:45:34 -0600 (Sat, 04 Mar 2017) $
* $Revision: 11379 $
*
* Copyright (c) 2009-2017 ARM Ltd., all rights reserved.
* ARM Ltd. confidential and proprietary.
*
* IMPORTANT. Your use of this file is governed by a Software License Agreement
* ("Agreement") that must be accepted in order to download or otherwise receive a
* copy of this file. You may not use or copy this file for any purpose other than
* as described in the Agreement. If you do not agree to all of the terms of the
* Agreement do not use this file and delete all copies in your possession or control;
* if you do not have a copy of the Agreement, you must contact ARM Ltd. prior
* to any use, copying or further distribution of this software.
*/
/*************************************************************************************************/
#ifndef WSF_BUF_H
#define WSF_BUF_H
#ifdef __cplusplus
extern "C" {
#endif
/**************************************************************************************************
Macros
**************************************************************************************************/
/*! Length of the buffer statistics array */
#define WSF_BUF_STATS_MAX_LEN 128
/*! Failure Codes */
#define WSF_BUF_ALLOC_FAILED 0x01
/**************************************************************************************************
Data Types
**************************************************************************************************/
/*! Buffer pool descriptor structure */
typedef struct
{
uint16_t len; /*! length of buffers in pool */
uint8_t num; /*! number of buffers in pool */
} wsfBufPoolDesc_t;
/*! Pool statistics */
typedef struct
{
uint16_t bufSize; /*!< Pool buffer size. */
uint8_t numBuf; /*!< Total number of buffers. */
uint8_t numAlloc; /*!< Number of outstanding allocations. */
uint8_t maxAlloc; /*!< High allocation watermark. */
uint16_t maxReqLen; /*!< Maximum requested buffer length. */
} WsfBufPoolStat_t;
/*! WSF buffer diagnostics - buffer allocation failure */
typedef struct
{
uint8_t taskId; /*! Task handler ID where failure occured */
uint16_t len; /*! Length of buffer being allocated */
} wsfBufDiagAllocFail_t;
/*! WSF buffer diagnostics message */
typedef struct
{
union
{
wsfBufDiagAllocFail_t alloc; /*! Buffer allocation failure */
} param;
uint8_t type; /*! Type of error */
} WsfBufDiag_t;
/**************************************************************************************************
Callback Function Datatypes
**************************************************************************************************/
/*************************************************************************************************/
/*!
* \fn wsfBufDiagCback_t
*
* \brief Callback providing WSF buffer diagnostic messages.
*
* \param pInfo Diagnostics message
*
* \return None.
*/
/*************************************************************************************************/
typedef void (*wsfBufDiagCback_t)(WsfBufDiag_t *pInfo);
/**************************************************************************************************
Function Declarations
**************************************************************************************************/
/*************************************************************************************************/
/*!
* \fn WsfBufInit
*
* \brief Initialize the buffer pool service. This function should only be called once
* upon system initialization.
*
* \param bufMemLen Length in bytes of memory pointed to by pBufMem.
* \param pBufMem Memory in which to store the pools used by the buffer pool service.
* \param numPools Number of buffer pools.
* \param pDesc Array of buffer pool descriptors, one for each pool.
*
* \return Amount of pBufMem used or 0 for failures.
*/
/*************************************************************************************************/
uint16_t WsfBufInit(uint16_t bufMemLen, uint8_t *pBufMem, uint8_t numPools, wsfBufPoolDesc_t *pDesc);
/*************************************************************************************************/
/*!
* \fn WsfBufAlloc
*
* \brief Allocate a buffer.
*
* \param len Length of buffer to allocate.
*
* \return Pointer to allocated buffer or NULL if allocation fails.
*/
/*************************************************************************************************/
void *WsfBufAlloc(uint16_t len);
/*************************************************************************************************/
/*!
* \fn WsfBufFree
*
* \brief Free a buffer.
*
* \param pBuf Buffer to free.
*
* \return None.
*/
/*************************************************************************************************/
void WsfBufFree(void *pBuf);
/*************************************************************************************************/
/*!
* \fn WsfBufGetAllocStats
*
* \brief Diagnostic function to get the buffer allocation statistics.
*
* \return Buffer allocation statistics array.
*/
/*************************************************************************************************/
uint8_t *WsfBufGetAllocStats(void);
/*************************************************************************************************/
/*!
* \fn WsfBufGetNumPool
*
* \brief Get number of pools.
*
* \return Number of pools.
*/
/*************************************************************************************************/
uint8_t WsfBufGetNumPool(void);
/*************************************************************************************************/
/*!
* \fn WsfBufGetPoolStats
*
* \brief Get statistics for each pool.
*
* \param pStat Buffer to store the statistics.
* \param numPool Number of pool elements.
*
* \return Pool statistics.
*/
/*************************************************************************************************/
void WsfBufGetPoolStats(WsfBufPoolStat_t *pStat, uint8_t numPool);
/*************************************************************************************************/
/*!
* \fn WsfBufDiagRegister
*
* \brief Called to register the buffer diagnostics callback function.
*
* \param pCallback Pointer to the callback function.
*
* \return None.
*/
/*************************************************************************************************/
void WsfBufDiagRegister(wsfBufDiagCback_t callback);
#ifdef __cplusplus
};
#endif
#endif /* WSF_BUF_H */
ambiq-hal-sys/ambiq-sparkfun-sdk/third_party/exactle/wsf/include/wsf_bufio.h
Vendored
+95
View File
@@ -0,0 +1,95 @@
/*************************************************************************************************/
/*!
* \file wsf_bufio.h
*
* \brief Buffer I/O service.
*
* Copyright (c) 2009-2018 Arm Ltd.
*
* Copyright (c) 2019 Packetcraft, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*************************************************************************************************/
#ifndef WSF_BUF_IO_H
#define WSF_BUF_IO_H
#ifdef __cplusplus
extern "C" {
#endif
/*! \addtogroup WSF_BUF_IO_API
* \{ */
/**************************************************************************************************
Macros
**************************************************************************************************/
/**************************************************************************************************
Data Types
**************************************************************************************************/
/**************************************************************************************************
Callback Function Datatypes
**************************************************************************************************/
/*! \brief Buffer IO UART Rx callback. */
typedef void (*WsfBufIoUartRxCback_t)(uint8_t rxByte);
/**************************************************************************************************
Function Declarations
**************************************************************************************************/
/*************************************************************************************************/
/*!
* \brief Initialize the platform UART.
*
* \param pBuf Tx Buffer pointer.
* \param size Length of buffer.
*
* \return memory used.
*/
/*************************************************************************************************/
uint32_t WsfBufIoUartInit(void *pBuf, uint32_t size);
/*************************************************************************************************/
/*!
* \brief Register the platform UART RX callback.
*
* \param[in] Callback function for UART RX.
*
* \return None.
*/
/*************************************************************************************************/
void WsfBufIoUartRegister(WsfBufIoUartRxCback_t rxCback);
/*************************************************************************************************/
/*!
* \brief Transmit buffer on platform UART.
*
* \param pBuf Buffer to transmit.
* \param len Length of buffer in octets.
*
* \return None.
*/
/*************************************************************************************************/
bool_t WsfBufIoWrite(const uint8_t *pBuf, uint32_t len);
/*! \} */ /* WSF_BUF_IO_API */
#ifdef __cplusplus
};
#endif
#endif /* WSF_BUF_IO_H */
ambiq-hal-sys/ambiq-sparkfun-sdk/third_party/exactle/wsf/include/wsf_efs.h
Vendored
+449
View File
@@ -0,0 +1,449 @@
/*************************************************************************************************/
/*!
* \file wsf_efs.h
*
* \brief Embedded File System service.
*
* $Date: 2017-03-09 12:18:38 -0600 (Thu, 09 Mar 2017) $
* $Revision: 11460 $
*
* Copyright (c) 2014-2017 ARM Ltd., all rights reserved.
* ARM Ltd. confidential and proprietary.
*
* IMPORTANT. Your use of this file is governed by a Software License Agreement
* ("Agreement") that must be accepted in order to download or otherwise receive a
* copy of this file. You may not use or copy this file for any purpose other than
* as described in the Agreement. If you do not agree to all of the terms of the
* Agreement do not use this file and delete all copies in your possession or control;
* if you do not have a copy of the Agreement, you must contact ARM Ltd. prior
* to any use, copying or further distribution of this software.
*/
/*************************************************************************************************/
#ifndef WSF_EFS_H
#define WSF_EFS_H
#ifdef __cplusplus
extern "C" {
#endif
/**************************************************************************************************
Macros
**************************************************************************************************/
/* Max Number of Files and Media */
#ifndef WSF_EFS_MAX_FILES
#define WSF_EFS_MAX_FILES 6
#endif
/* Max Number of Media */
#ifndef WSF_EFS_MAX_MEDIA
#define WSF_EFS_MAX_MEDIA 4
#endif
/* Status codes */
#define WSF_EFS_SUCCESS 0 /*! Success */
#define WSF_EFS_FAILURE 1 /*! Failure */
#define WSF_EFS_GET_FAILED 0xFFFF /*! Get operation failure */
#define WSF_EFS_PUT_FAILED 0xFFFF /*! PUT operation failure */
/* Invalid parameter Identifiers */
#define WSF_EFS_INVALID_HANDLE 0xFFFF /*! Invalid Handle */
#define WSF_EFS_INVALID_OFFSET 0xFFFFFFFF /*! Invalid Offset */
#define WSF_EFS_INVALID_SIZE 0xFFFFFFFF /*! Invalid Size */
#define WSF_EFS_INVALID_MEDIA 0xFF /*! Invalid Media */
/* File Types */
#define WSF_EFS_FILE_TYPE_BULK 0 /*! Bulk File Type */
#define WSF_EFS_FILE_TYPE_STREAM 1 /*! Stream File Type */
/* Offset to WsfEfsAddFile indicating any file offset can be used */
#define WSF_EFS_FILE_OFFSET_ANY 0xFFFFFFFF
/* File Permissions */
#define WSF_EFS_REMOTE_PERMISSIONS_MASK 0xFF /*! Remote Permissions */
#define WSF_EFS_REMOTE_GET_PERMITTED 0x01 /*! Remote Get Permitted */
#define WSF_EFS_REMOTE_PUT_PERMITTED 0x02 /*! Remote Put Permitted */
#define WSF_EFS_REMOTE_ERASE_PERMITTED 0x04 /*! Remote Erase Permitted */
#define WSF_EFS_REMOTE_VERIFY_PERMITTED 0x08 /*! Remote Verify Permitted */
#define WSF_EFS_LOCAL_GET_PERMITTED 0x0100 /*! Local Get Permitted */
#define WSF_EFS_LOCAL_PUT_PERMITTED 0x0200 /*! Local Put Permitted */
#define WSF_EFS_LOCAL_ERASE_PERMITTED 0x0400 /*! Local Erase Permitted */
#define WSF_EFS_REMOTE_VISIBLE 0x0800 /*! File Visible via Remote WDXS */
/* File name length in bytes */
#define WSF_EFS_NAME_LEN 16
/* File version length in bytes */
#define WSF_EFS_VERSION_LEN 16
/* Standard Media Specific Command Identifiers */
#define WSF_EFS_WDXS_PUT_COMPLETE_CMD 0x00 /*! Put Complete */
#define WSF_EFS_VALIDATE_CMD 0x01 /*! Validate Req for the file */
/* Media Specific Command Identifiers reserved for applications begin at 0x80 */
#define WSF_EFS_USER_CMD 0x80
/**************************************************************************************************
Data Types
**************************************************************************************************/
/* File handle data type */
typedef uint16_t wsfEfsHandle_t;
/* File attributes data type */
typedef struct
{
char name[WSF_EFS_NAME_LEN];
char version[WSF_EFS_VERSION_LEN];
uint16_t permissions;
uint8_t type;
} wsfEsfAttributes_t;
/* File control block data type */
typedef struct
{
uint32_t maxSize;
uint32_t address;
uint8_t media;
uint32_t size;
wsfEsfAttributes_t attributes;
} wsfEfsControl_t;
/* File Listing Information */
typedef struct
{
wsfEfsHandle_t handle;
uint32_t size;
wsfEsfAttributes_t attributes;
} wsfEfsFileInfo_t;
/*************************************************************************************************/
/*!
* \fn wsfMediaInitFunc_t
*
* \brief Media Init function, called when media is registered.
*
* \param none.
*
* \return Status of the operation.
*/
/*************************************************************************************************/
typedef uint8_t wsfMediaInitFunc_t(void);
/*************************************************************************************************/
/*!
* \fn wsfMediaEraseFunc_t
*
* \brief Media Erase function.
*
* \param address Address in media to start erasing.
* \param size Number of bytes to erase.
*
* \return Status of the operation.
*/
/*************************************************************************************************/
typedef uint8_t wsfMediaEraseFunc_t(uint32_t address, uint32_t size);
/*************************************************************************************************/
/*!
* \fn wsfMediaReadFunc_t
*
* \brief Media Read function.
*
* \param pBuf Buffer to hold data.
* \param address Address in media to read from.
* \param size Size of pBuf in bytes.
*
* \return Status of the operation.
*/
/*************************************************************************************************/
typedef uint8_t wsfMediaReadFunc_t(uint8_t *pBuf, uint32_t address, uint32_t size);
/*************************************************************************************************/
/*!
* \fn wsfMediaWriteFunc_t
*
* \brief Media Write function.
*
* \param pBuf Buffer with data to be written.
* \param address Address in media to write to.
* \param size Size of pBuf in bytes.
*
* \return Status of the operation.
*/
/*************************************************************************************************/
typedef uint8_t wsfMediaWriteFunc_t(const uint8_t *pBuf, uint32_t address, uint32_t size);
/*************************************************************************************************/
/*!
* \fn wsfMediaHandleCmdFunc_t
*
* \brief Media Specific Command handler.
*
* \param cmd Identifier of the media specific command.
* \param param Optional Parameter to the command.
*
* \return Status of the operation.
*/
/*************************************************************************************************/
typedef uint8_t wsfMediaHandleCmdFunc_t(uint8_t cmd, uint32_t param);
/* Media Control data type */
typedef struct
{
uint32_t startAddress;
uint32_t endAddress;
uint32_t pageSize;
wsfMediaInitFunc_t *init;
wsfMediaEraseFunc_t *erase;
wsfMediaReadFunc_t *read;
wsfMediaWriteFunc_t *write;
wsfMediaHandleCmdFunc_t *handleCmd;
} wsfEfsMedia_t;
/* Pointer to Media Control data type */
typedef const wsfEfsMedia_t *pWsfEfsMedia_t;
/**************************************************************************************************
Function Declarations
**************************************************************************************************/
/*************************************************************************************************/
/*!
* \fn WsfEfsInit
*
* \brief Initialise the embedded file system.
*
* \return none.
*/
/*************************************************************************************************/
void WsfEfsInit(void);
/*************************************************************************************************/
/*!
* \fn WsfEfsAddFile
*
* \brief Create a file in the embedded file system.
*
* \param maxSize Max length in bytes of of the file.
* \param media Identifier of the media where the file is stored.
* \param pAttr Attributes of the file
* \param offset Offset address of the file in the memory space.
*
* \return File Handle, or WSF_EFS_INVALID_HANDLE.
*/
/*************************************************************************************************/
wsfEfsHandle_t WsfEfsAddFile(uint32_t maxSize, uint8_t media, wsfEsfAttributes_t *pAttr, uint32_t offset);
/*************************************************************************************************/
/*!
* \fn WsfEfsRemoveFile
*
* \brief Deletes a file in the embedded file system.
*
* \param handle Handle identifying the file.
*
* \return WSF_EFS_SUCCESS or WSF_EFS_FAILURE.
*/
/*************************************************************************************************/
uint8_t WsfEfsRemoveFile(wsfEfsHandle_t handle);
/*************************************************************************************************/
/*!
* \fn WsfEfsErase
*
* \brief Clears the contents of a file without deleting the file.
*
* \param handle Handle identifying the file.
*
* \return WSF_EFS_SUCCESS or WSF_EFS_FAILURE.
*/
/*************************************************************************************************/
uint8_t WsfEfsErase(wsfEfsHandle_t handle);
/*************************************************************************************************/
/*!
* \fn WsfEfsGetAttributes
*
* \brief Gets the attributes of a file.
*
* \param handle Handle identifying the file.
* \param pAttr Pointer to memory to store the attributes.
*
* \return WSF_EFS_SUCCESS or WSF_EFS_FAILURE.
*/
/*************************************************************************************************/
uint8_t WsfEfsGetAttributes(wsfEfsHandle_t handle, wsfEsfAttributes_t *pAttr);
/*************************************************************************************************/
/*!
* \fn WsfEfsSetAttributes
*
* \brief Updates the attributes of a file.
*
* \param handle Handle identifying the file.
* \param pAttr Pointer to memory to with the updated attributes.
*
* \return WSF_EFS_SUCCESS or WSF_EFS_FAILURE.
*/
/*************************************************************************************************/
uint8_t WsfEfsSetAttributes(wsfEfsHandle_t handle, wsfEsfAttributes_t *pInfo);
/*************************************************************************************************/
/*!
* \fn WsfEfsGet
*
* \brief Copies data from a file.
*
* \param handle Handle identifying the file.
* \param offset Offset into the file to begin copying from.
* \param pBuffer Location to copy the data to.
* \param len Number of bytes to copy into pBuffer.
*
* \return The number of bytes read from the file
*/
/*************************************************************************************************/
uint16_t WsfEfsGet(wsfEfsHandle_t handle, uint32_t offset, uint8_t *pBuffer, uint16_t len);
/*************************************************************************************************/
/*!
* \fn WsfEfsPut
*
* \brief Writes data to a file.
*
* \param handle Handle identifying the file.
* \param offset Offset into the file to begin writing to.
* \param pBuffer Data to write to the file.
* \param len Number of bytes to write to the file.
*
* \return The number of bytes written to the file
*/
/*************************************************************************************************/
uint16_t WsfEfsPut(wsfEfsHandle_t handle, uint32_t offset, const uint8_t *pBuffer, uint16_t len);
/*************************************************************************************************/
/*!
* \fn WsfEfsRegisterMedia
*
* \brief Registers a File Storage Medium with the Embedded File System.
*
* \param pMedia Pointer to the media control structure.
* \param mediaID User specified identifier of the media.
*
* \return WSF_EFS_SUCCESS or WSF_EFS_FAILURE.
*/
/*************************************************************************************************/
uint8_t WsfEfsRegisterMedia(const wsfEfsMedia_t *pMediaCtrl, uint8_t mediaID);
/*************************************************************************************************/
/*!
* \fn wsfEfsGetFileByHandle
*
* \brief Returns the file control block for the given handle.
*
* \param handle Handle of the file
*
* \return File control block, or NULL.
*/
/*************************************************************************************************/
wsfEfsControl_t *WsfEfsGetFileByHandle(wsfEfsHandle_t handle);
/*************************************************************************************************/
/*!
* \fn WsfEfsGetFileName
*
* \brief Get the name of a file.
*
* \param handle File Handle.
*
* \return Filename string of a file.
*/
/*************************************************************************************************/
char *WsfEfsGetFileName(wsfEfsHandle_t handle);
/*************************************************************************************************/
/*!
* \fn WsfEfsGetFileVersion
*
* \brief Get the version of a file.
*
* \param handle File Handle.
*
* \return Version string of a file.
*/
/*************************************************************************************************/
char *WsfEfsGetFileVersion(wsfEfsHandle_t handle);
/*************************************************************************************************/
/*!
* \fn WsfEfsGetFileSize
*
* \brief Get the size of a file.
*
* \param handle File Handle.
*
* \return Size of the file.
*/
/*************************************************************************************************/
uint32_t WsfEfsGetFileSize(wsfEfsHandle_t handle);
/*************************************************************************************************/
/*!
* \fn WsfEfsGetFileMaxSize
*
* \brief Get the number of bytes of memory reserved for use by a file.
*
* \param handle File Handle.
*
* \return Max size of the file.
*/
/*************************************************************************************************/
uint32_t WsfEfsGetFileMaxSize(wsfEfsHandle_t handle);
/*************************************************************************************************/
/*!
* \fn WsfEfsGetFileType
*
* \brief Get the type of a file.
*
* \param handle File Handle.
*
* \return Type of file (bulk or stream).
*/
/*************************************************************************************************/
uint8_t WsfEfsGetFileType(wsfEfsHandle_t handle);
/*************************************************************************************************/
/*!
* \fn WsfEfsGetFilePermissions
*
* \brief Get the permissions of a file.
*
* \param handle File Handle.
*
* \return Permissions of the file.
*/
/*************************************************************************************************/
uint16_t WsfEfsGetFilePermissions(wsfEfsHandle_t handle);
/*************************************************************************************************/
/*!
* \fn WsfEfsMediaSpecificCommand
*
* \brief Execute a media specific command on a file.
*
* \param handle File Handle.
* \param cmd Media specific command identifier.
* \param param Command specific parameter.
*
* \return Status of the operation.
*/
/*************************************************************************************************/
uint8_t WsfEfsMediaSpecificCommand(wsfEfsHandle_t handle, uint8_t cmd, uint32_t param);
#ifdef __cplusplus
}
#endif
#endif /* WSF_EFS_H */
ambiq-hal-sys/ambiq-sparkfun-sdk/third_party/exactle/wsf/include/wsf_math.h
Vendored
+45
View File
@@ -0,0 +1,45 @@
/*************************************************************************************************/
/*!
* \file wsf_math.h
*
* \brief Common math utilities.
*
* $Date: 2016-12-28 16:12:14 -0600 (Wed, 28 Dec 2016) $
* $Revision: 10805 $
*
* Copyright (c) 2013-2017 ARM Ltd., all rights reserved.
* ARM Ltd. confidential and proprietary.
*
* IMPORTANT. Your use of this file is governed by a Software License Agreement
* ("Agreement") that must be accepted in order to download or otherwise receive a
* copy of this file. You may not use or copy this file for any purpose other than
* as described in the Agreement. If you do not agree to all of the terms of the
* Agreement do not use this file and delete all copies in your possession or control;
* if you do not have a copy of the Agreement, you must contact ARM Ltd. prior
* to any use, copying or further distribution of this software.
*/
/*************************************************************************************************/
#ifndef WSF_MATH_H
#define WSF_MATH_H
#include "wsf_types.h"
#ifdef __cplusplus
extern "C" {
#endif
/**************************************************************************************************
Macros
**************************************************************************************************/
/*! \brief Returns the minimum of two values. */
#define WSF_MIN(a,b) ((a) < (b) ? (a) : (b))
/*! \brief Returns the maximum of two values. */
#define WSF_MAX(a,b) ((a) > (b) ? (a) : (b))
#ifdef __cplusplus
};
#endif
#endif /* WSF_MATH_H */
ambiq-hal-sys/ambiq-sparkfun-sdk/third_party/exactle/wsf/include/wsf_msg.h
Vendored
+137
View File
@@ -0,0 +1,137 @@
/*************************************************************************************************/
/*!
* \file wsf_msg.h
*
* \brief Message passing service.
*
* $Date: 2017-03-10 14:08:37 -0600 (Fri, 10 Mar 2017) $
* $Revision: 11501 $
*
* Copyright (c) 2009-2017 ARM Ltd., all rights reserved.
* ARM Ltd. confidential and proprietary.
*
* IMPORTANT. Your use of this file is governed by a Software License Agreement
* ("Agreement") that must be accepted in order to download or otherwise receive a
* copy of this file. You may not use or copy this file for any purpose other than
* as described in the Agreement. If you do not agree to all of the terms of the
* Agreement do not use this file and delete all copies in your possession or control;
* if you do not have a copy of the Agreement, you must contact ARM Ltd. prior
* to any use, copying or further distribution of this software.
*/
/*************************************************************************************************/
#ifndef WSF_MSG_H
#define WSF_MSG_H
#include "wsf_queue.h"
#include "wsf_os.h"
#ifdef __cplusplus
extern "C" {
#endif
/**************************************************************************************************
Function Declarations
**************************************************************************************************/
/*************************************************************************************************/
/*!
* \fn WsfMsgDataAlloc
*
* \brief Allocate a data message buffer to be sent with WsfMsgSend().
*
* \param len Message length in bytes.
* \param tailroom Tailroom length in bytes.
*
* \return Pointer to data message buffer or NULL if allocation failed.
*/
/*************************************************************************************************/
void *WsfMsgDataAlloc(uint16_t len, uint8_t tailroom);
/*************************************************************************************************/
/*!
* \fn WsfMsgAlloc
*
* \brief Allocate a message buffer to be sent with WsfMsgSend().
*
* \param len Message length in bytes.
*
* \return Pointer to message buffer or NULL if allocation failed.
*/
/*************************************************************************************************/
void *WsfMsgAlloc(uint16_t len);
/*************************************************************************************************/
/*!
* \fn WsfMsgFree
*
* \brief Free a message buffer allocated with WsfMsgAlloc().
*
* \param pMsg Pointer to message buffer.
*
* \return None.
*/
/*************************************************************************************************/
void WsfMsgFree(void *pMsg);
/*************************************************************************************************/
/*!
* \fn WsfMsgSend
*
* \brief Send a message to an event handler.
*
* \param handlerId Event handler ID.
* \param pMsg Pointer to message buffer.
*
* \return None.
*/
/*************************************************************************************************/
void WsfMsgSend(wsfHandlerId_t handlerId, void *pMsg);
/*************************************************************************************************/
/*!
* \fn WsfMsgEnq
*
* \brief Enqueue a message.
*
* \param pQueue Pointer to queue.
* \param handerId Set message handler ID to this value.
* \param pElem Pointer to message buffer.
*
* \return None.
*/
/*************************************************************************************************/
void WsfMsgEnq(wsfQueue_t *pQueue, wsfHandlerId_t handlerId, void *pMsg);
/*************************************************************************************************/
/*!
* \fn WsfMsgDeq
*
* \brief Dequeue a message.
*
* \param pQueue Pointer to queue.
* \param pHandlerId Handler ID of returned message; this is a return parameter.
*
* \return Pointer to message that has been dequeued or NULL if queue is empty.
*/
/*************************************************************************************************/
void *WsfMsgDeq(wsfQueue_t *pQueue, wsfHandlerId_t *pHandlerId);
/*************************************************************************************************/
/*!
* \fn WsfMsgPeek
*
* \brief Get the next message without removing it from the queue.
*
* \param pQueue Pointer to queue.
* \param pHandlerId Handler ID of returned message; this is a return parameter.
*
* \return Pointer to the next message on the queue or NULL if queue is empty.
*/
/*************************************************************************************************/
void *WsfMsgPeek(wsfQueue_t *pQueue, wsfHandlerId_t *pHandlerId);
#ifdef __cplusplus
};
#endif
#endif /* WSF_MSG_H */
ambiq-hal-sys/ambiq-sparkfun-sdk/third_party/exactle/wsf/include/wsf_os.h
Vendored
+191
View File
@@ -0,0 +1,191 @@
/*************************************************************************************************/
/*!
* \file wsf_os.h
*
* \brief Software foundation OS API.
*
* $Date: 2017-03-02 16:50:43 -0600 (Thu, 02 Mar 2017) $
* $Revision: 11350 $
*
* Copyright (c) 2009-2017 ARM Ltd., all rights reserved.
* ARM Ltd. confidential and proprietary.
*
* IMPORTANT. Your use of this file is governed by a Software License Agreement
* ("Agreement") that must be accepted in order to download or otherwise receive a
* copy of this file. You may not use or copy this file for any purpose other than
* as described in the Agreement. If you do not agree to all of the terms of the
* Agreement do not use this file and delete all copies in your possession or control;
* if you do not have a copy of the Agreement, you must contact ARM Ltd. prior
* to any use, copying or further distribution of this software.
*/
/*************************************************************************************************/
#ifndef WSF_OS_H
#define WSF_OS_H
#include "wsf_os_int.h"
#include "wsf_queue.h"
#ifdef __cplusplus
extern "C" {
#endif
/**************************************************************************************************
Configuration
**************************************************************************************************/
/* OS Diagnistics */
#ifndef WSF_OS_DIAG
#define WSF_OS_DIAG FALSE
#endif
/**************************************************************************************************
Macros
**************************************************************************************************/
/* Invalid Task Identifier */
#define WSF_INVALID_TASK_ID 0xFF
#if WSF_OS_DIAG == TRUE
#define WSF_OS_GET_ACTIVE_HANDLER_ID() WsfActiveHandler
#else
#define WSF_OS_GET_ACTIVE_HANDLER_ID() WSF_INVALID_TASK_ID
#endif /* WSF_OS_DIAG */
/**************************************************************************************************
External Variables
**************************************************************************************************/
/* Diagnistic Task Identifier */
extern wsfHandlerId_t WsfActiveHandler;
/**************************************************************************************************
Data Types
**************************************************************************************************/
/*! Common message structure passed to event handler */
typedef struct
{
uint16_t param; /*! General purpose parameter passed to event handler */
uint8_t event; /*! General purpose event value passed to event handler */
uint8_t status; /*! General purpose status value passed to event handler */
} wsfMsgHdr_t;
/**************************************************************************************************
Callback Function Types
**************************************************************************************************/
/*************************************************************************************************/
/*!
* \fn wsfEventHandler_t
*
* \brief Event handler callback function.
*
* \param event Mask of events set for the event handler.
* \param pMsg Pointer to message for the event handler.
*
* \return None.
*/
/*************************************************************************************************/
typedef void (*wsfEventHandler_t)(wsfEventMask_t event, wsfMsgHdr_t *pMsg);
/**************************************************************************************************
Function Declarations
**************************************************************************************************/
/*************************************************************************************************/
/*!
* \fn WsfSetEvent
*
* \brief Set an event for an event handler.
*
* \param handlerId Handler ID.
* \param event Event or events to set.
*
* \return None.
*/
/*************************************************************************************************/
void WsfSetEvent(wsfHandlerId_t handlerId, wsfEventMask_t event);
/*************************************************************************************************/
/*!
* \fn WsfTaskLock
*
* \brief Lock task scheduling.
*
* \return None.
*/
/*************************************************************************************************/
void WsfTaskLock(void);
/*************************************************************************************************/
/*!
* \fn WsfTaskUnlock
*
* \brief Unlock task scheduling.
*
* \return None.
*/
/*************************************************************************************************/
void WsfTaskUnlock(void);
/*************************************************************************************************/
/*!
* \fn WsfTaskSetReady
*
* \brief Set the task used by the given handler as ready to run.
*
* \param handlerId Event handler ID.
* \param event Task event mask.
*
* \return None.
*/
/*************************************************************************************************/
void WsfTaskSetReady(wsfHandlerId_t handlerId, wsfTaskEvent_t event);
/*************************************************************************************************/
/*!
* \fn WsfTaskMsgQueue
*
* \brief Return the task message queue used by the given handler.
*
* \param handlerId Event handler ID.
*
* \return Task message queue.
*/
/*************************************************************************************************/
wsfQueue_t *WsfTaskMsgQueue(wsfHandlerId_t handlerId);
/*************************************************************************************************/
/*!
* \fn WsfOsSetNextHandler
*
* \brief Set the next WSF handler function in the WSF OS handler array. This function
* should only be called as part of the OS initialization procedure.
*
* \param handler WSF handler function.
*
* \return WSF handler ID for this handler.
*/
/*************************************************************************************************/
wsfHandlerId_t WsfOsSetNextHandler(wsfEventHandler_t handler);
/*************************************************************************************************/
/*!
* \fn wsfOsSetEventObject
*
* \brief Pass RTOS event object to wsf OS scheduler. This function
* should only be called as part of the OS (RTOS) initialization procedure.
*
* \param event_object The pointer to an event object for RTOS.
*
* \return None
*/
/*************************************************************************************************/
void wsfOsSetEventObject(void *event_object);
#ifdef __cplusplus
};
#endif
#endif /* WSF_OS_H */
ambiq-hal-sys/ambiq-sparkfun-sdk/third_party/exactle/wsf/include/wsf_queue.h
Vendored
+155
View File
@@ -0,0 +1,155 @@
/*************************************************************************************************/
/*!
* \file wsf_queue.h
*
* \brief General purpose queue service.
*
* $Date: 2016-12-28 16:12:14 -0600 (Wed, 28 Dec 2016) $
* $Revision: 10805 $
*
* Copyright (c) 2009-2017 ARM Ltd., all rights reserved.
* ARM Ltd. confidential and proprietary.
*
* IMPORTANT. Your use of this file is governed by a Software License Agreement
* ("Agreement") that must be accepted in order to download or otherwise receive a
* copy of this file. You may not use or copy this file for any purpose other than
* as described in the Agreement. If you do not agree to all of the terms of the
* Agreement do not use this file and delete all copies in your possession or control;
* if you do not have a copy of the Agreement, you must contact ARM Ltd. prior
* to any use, copying or further distribution of this software.
*/
/*************************************************************************************************/
#ifndef WSF_QUEUE_H
#define WSF_QUEUE_H
#ifdef __cplusplus
extern "C" {
#endif
/**************************************************************************************************
Macros
**************************************************************************************************/
/*! Initialize a queue */
#define WSF_QUEUE_INIT(pQueue) {(pQueue)->pHead = NULL; (pQueue)->pTail = NULL;}
/**************************************************************************************************
Data Types
**************************************************************************************************/
/*! Queue structure */
typedef struct
{
void *pHead; /*! head of queue */
void *pTail; /*! tail of queue */
} wsfQueue_t;
/**************************************************************************************************
Function Declarations
**************************************************************************************************/
/*************************************************************************************************/
/*!
* \fn WsfQueueEnq
*
* \brief Enqueue an element to the tail of a queue.
*
* \param pQueue Pointer to queue.
* \param pElem Pointer to element.
*
* \return None.
*/
/*************************************************************************************************/
void WsfQueueEnq(wsfQueue_t *pQueue, void *pElem);
/*************************************************************************************************/
/*!
* \fn WsfQueueDeq
*
* \brief Dequeue an element from the head of a queue.
*
* \param pQueue Pointer to queue.
*
* \return Pointer to element that has been dequeued or NULL if queue is empty.
*/
/*************************************************************************************************/
void *WsfQueueDeq(wsfQueue_t *pQueue);
/*************************************************************************************************/
/*!
* \fn WsfQueuePush
*
* \brief Push an element to the head of a queue.
*
* \param pQueue Pointer to queue.
* \param pElem Pointer to element.
*
* \return None.
*/
/*************************************************************************************************/
void WsfQueuePush(wsfQueue_t *pQueue, void *pElem);
/*************************************************************************************************/
/*!
* \fn WsfQueueInsert
*
* \brief Insert an element into a queue. This function is typically used when iterating
* over a queue.
*
* \param pQueue Pointer to queue.
* \param pElem Pointer to element to be inserted.
* \param pPrev Pointer to previous element in the queue before element to be inserted.
* Note: set pPrev to NULL if pElem is first element in queue.
* \return None.
*/
/*************************************************************************************************/
void WsfQueueInsert(wsfQueue_t *pQueue, void *pElem, void *pPrev);
/*************************************************************************************************/
/*!
* \fn WsfQueueRemove
*
* \brief Remove an element from a queue. This function is typically used when iterating
* over a queue.
*
* \param pQueue Pointer to queue.
* \param pElem Pointer to element to be removed.
* \param pPrev Pointer to previous element in the queue before element to be removed.
*
* \return None.
*/
/*************************************************************************************************/
void WsfQueueRemove(wsfQueue_t *pQueue, void *pElem, void *pPrev);
/*************************************************************************************************/
/*!
* \fn WsfQueueCount
*
* \brief Count the number of elements in a queue.
*
* \param pQueue Pointer to queue.
*
* \return Number of elements in queue.
*/
/*************************************************************************************************/
uint16_t WsfQueueCount(wsfQueue_t *pQueue);
/*************************************************************************************************/
/*!
* \fn WsfQueueEmpty
*
* \brief Return TRUE if queue is empty.
*
* \param pQueue Pointer to queue.
*
* \return TRUE if queue is empty, FALSE otherwise.
*/
/*************************************************************************************************/
bool_t WsfQueueEmpty(wsfQueue_t *pQueue);
#ifdef __cplusplus
};
#endif
#endif /* WSF_QUEUE_H */
ambiq-hal-sys/ambiq-sparkfun-sdk/third_party/exactle/wsf/include/wsf_timer.h
Vendored
+168
View File
@@ -0,0 +1,168 @@
/*************************************************************************************************/
/*!
* \file wsf_timer.h
*
* \brief Timer service.
*
* $Date: 2016-12-28 16:12:14 -0600 (Wed, 28 Dec 2016) $
* $Revision: 10805 $
*
* Copyright (c) 2009-2017 ARM Ltd., all rights reserved.
* ARM Ltd. confidential and proprietary.
*
* IMPORTANT. Your use of this file is governed by a Software License Agreement
* ("Agreement") that must be accepted in order to download or otherwise receive a
* copy of this file. You may not use or copy this file for any purpose other than
* as described in the Agreement. If you do not agree to all of the terms of the
* Agreement do not use this file and delete all copies in your possession or control;
* if you do not have a copy of the Agreement, you must contact ARM Ltd. prior
* to any use, copying or further distribution of this software.
*/
/*************************************************************************************************/
#ifndef WSF_TIMER_H
#define WSF_TIMER_H
#include "wsf_os.h"
#ifdef __cplusplus
extern "C" {
#endif
/**************************************************************************************************
Macros
**************************************************************************************************/
#ifndef WSF_MS_PER_TICK
/*! Default milliseconds per tick rate */
#define WSF_MS_PER_TICK 10
#endif
/**************************************************************************************************
Data Types
**************************************************************************************************/
/*! Timer ticks data type */
typedef uint32_t wsfTimerTicks_t;
/*! Timer structure */
typedef struct wsfTimer_tag
{
struct wsfTimer_tag *pNext; /*! pointer to next timer in queue */
wsfTimerTicks_t ticks; /*! number of ticks until expiration */
wsfHandlerId_t handlerId; /*! event handler for this timer */
bool_t isStarted; /*! TRUE if timer has been started */
wsfMsgHdr_t msg; /*! application-defined timer event parameters */
} wsfTimer_t;
/**************************************************************************************************
Function Declarations
**************************************************************************************************/
/*************************************************************************************************/
/*!
* \fn WsfTimerInit
*
* \brief Initialize the timer service. This function should only be called once
* upon system initialization.
*
* \return None.
*/
/*************************************************************************************************/
void WsfTimerInit(void);
/*************************************************************************************************/
/*!
* \fn WsfTimerStartSec
*
* \brief Start a timer in units of seconds. Before this function is called parameter
* pTimer->handlerId must be set to the event handler for this timer and parameter
* pTimer->msg must be set to any application-defined timer event parameters.
*
* \param pTimer Pointer to timer.
* \param sec Seconds until expiration.
*
* \return None.
*/
/*************************************************************************************************/
void WsfTimerStartSec(wsfTimer_t *pTimer, wsfTimerTicks_t sec);
/*************************************************************************************************/
/*!
* \fn WsfTimerStartMs
*
* \brief Start a timer in units of milliseconds.
*
* \param pTimer Pointer to timer.
* \param ms Milliseconds until expiration.
*
* \return None.
*/
/*************************************************************************************************/
void WsfTimerStartMs(wsfTimer_t *pTimer, wsfTimerTicks_t ms);
/*************************************************************************************************/
/*!
* \fn WsfTimerStop
*
* \brief Stop a timer.
*
* \param pTimer Pointer to timer.
*
* \return None.
*/
/*************************************************************************************************/
void WsfTimerStop(wsfTimer_t *pTimer);
/*************************************************************************************************/
/*!
* \fn WsfTimerUpdate
*
* \brief Update the timer service with the number of elapsed ticks. This function is
* typically called only from timer porting code.
*
* \param ticks Number of ticks since last update.
*
* \return None.
*/
/*************************************************************************************************/
void WsfTimerUpdate(wsfTimerTicks_t ticks);
/*************************************************************************************************/
/*!
* \fn WsfTimerNextExpiration
*
* \brief Return the number of ticks until the next timer expiration. Note that this
* function can return zero even if a timer is running, indicating the timer
* has expired but has not yet been serviced.
*
* \param pTimerRunning Returns TRUE if a timer is running, FALSE if no timers running.
*
* \return The number of ticks until the next timer expiration.
*/
/*************************************************************************************************/
wsfTimerTicks_t WsfTimerNextExpiration(bool_t *pTimerRunning);
/*************************************************************************************************/
/*!
* \fn WsfTimerServiceExpired
*
* \brief Service expired timers for the given task. This function is typically called only
* WSF OS porting code.
*
* \param taskId OS Task ID of task servicing timers.
*
* \return Pointer to next expired timer or NULL if there are no expired timers.
*/
/*************************************************************************************************/
wsfTimer_t *WsfTimerServiceExpired(wsfTaskId_t taskId);
void WsfTimerUpdateTicks(void);
#ifdef __cplusplus
};
#endif
#endif /* WSF_TIMER_H */
ambiq-hal-sys/ambiq-sparkfun-sdk/third_party/exactle/wsf/sources/port/freertos/wsf_assert.c
Vendored
+53
View File
@@ -0,0 +1,53 @@
/*************************************************************************************************/
/*!
* \file wsf_assert.c
*
* \brief Assert implementation.
*
* $Date: 2014-04-17 16:13:59 -0700 (Thu, 17 Apr 2014) $
* $Revision: 1398 $
*
* Copyright (c) 2009 Wicentric, Inc., all rights reserved.
* Wicentric confidential and proprietary.
*
* IMPORTANT. Your use of this file is governed by a Software License Agreement
* ("Agreement") that must be accepted in order to download or otherwise receive a
* copy of this file. You may not use or copy this file for any purpose other than
* as described in the Agreement. If you do not agree to all of the terms of the
* Agreement do not use this file and delete all copies in your possession or control;
* if you do not have a copy of the Agreement, you must contact Wicentric, Inc. prior
* to any use, copying or further distribution of this software.
*/
/*************************************************************************************************/
#include "wsf_types.h"
#include "wsf_assert.h"
#include "wsf_os.h"
/*************************************************************************************************/
/*!
* \def WsfAssert
*
* \brief Perform an assert action.
*
* \param pFile Name of file originating assert.
* \param line Line number of assert statement.
*/
/*************************************************************************************************/
void WsfAssert(const char *pFile, uint16_t line)
{
volatile uint8_t escape=0;
/* spin forever if fatal error occurred */
for(;;)
{
/*
* However, you can exit with a debugger by setting variable 'escape'.
* Handy to see where the assert happened if you cannot view the call stack.
*/
if (escape)
{
break;
}
}
}
ambiq-hal-sys/ambiq-sparkfun-sdk/third_party/exactle/wsf/sources/port/freertos/wsf_assert.h
Vendored
+71
View File
@@ -0,0 +1,71 @@
/*************************************************************************************************/
/*!
* \file wsf_assert.h
*
* \brief Assert macro.
*
* $Date: 2011-10-14 21:35:03 -0700 (Fri, 14 Oct 2011) $
* $Revision: 191 $
*
* Copyright (c) 2009 Wicentric, Inc., all rights reserved.
* Wicentric confidential and proprietary.
*
* IMPORTANT. Your use of this file is governed by a Software License Agreement
* ("Agreement") that must be accepted in order to download or otherwise receive a
* copy of this file. You may not use or copy this file for any purpose other than
* as described in the Agreement. If you do not agree to all of the terms of the
* Agreement do not use this file and delete all copies in your possession or control;
* if you do not have a copy of the Agreement, you must contact Wicentric, Inc. prior
* to any use, copying or further distribution of this software.
*/
/*************************************************************************************************/
#ifndef WSF_ASSERT_H
#define WSF_ASSERT_H
#ifdef __cplusplus
extern "C" {
#endif
/**************************************************************************************************
Function Prototypes
**************************************************************************************************/
void WsfAssert(const char *pFile, uint16_t line);
/**************************************************************************************************
Macros
**************************************************************************************************/
/*************************************************************************************************/
/*!
* \def WSF_ASSERT
*
* \brief Run-time assert macro. The assert executes when the expression is FALSE.
*
* \param expr Boolean expression to be tested.
*/
/*************************************************************************************************/
#if WSF_ASSERT_ENABLED == TRUE
#define WSF_ASSERT(expr) if (!(expr)) {WsfAssert(__FILE__, (uint16_t) __LINE__);}
#else
#define WSF_ASSERT(expr)
#endif
/*************************************************************************************************/
/*!
* \def WSF_CT_ASSERT
*
* \brief Compile-time assert macro. This macro causes a compiler error when the
* expression is FALSE. Note that this macro is generally used at file scope to
* test constant expressions. Errors may result of it is used in executing code.
*
* \param expr Boolean expression to be tested.
*/
/*************************************************************************************************/
#define WSF_CT_ASSERT(expr) extern char wsf_ct_assert[(expr) ? 1 : -1]
#ifdef __cplusplus
};
#endif
#endif /* WSF_ASSERT_H */
ambiq-hal-sys/ambiq-sparkfun-sdk/third_party/exactle/wsf/sources/port/freertos/wsf_buf.c
Vendored
+484
View File
@@ -0,0 +1,484 @@
/*************************************************************************************************/
/*!
* \file wsf_buf.c
*
* \brief Buffer pool service.
*
* $Date: 2017-03-04 13:45:34 -0600 (Sat, 04 Mar 2017) $
* $Revision: 11379 $
*
* Copyright (c) 2009-2017 ARM Ltd., all rights reserved.
* ARM Ltd. confidential and proprietary.
*
* IMPORTANT. Your use of this file is governed by a Software License Agreement
* ("Agreement") that must be accepted in order to download or otherwise receive a
* copy of this file. You may not use or copy this file for any purpose other than
* as described in the Agreement. If you do not agree to all of the terms of the
* Agreement do not use this file and delete all copies in your possession or control;
* if you do not have a copy of the Agreement, you must contact ARM Ltd. prior
* to any use, copying or further distribution of this software.
*/
/*************************************************************************************************/
#include "wsf_types.h"
#include "wsf_buf.h"
#include "wsf_assert.h"
#include "wsf_math.h"
#include "wsf_trace.h"
#include "wsf_cs.h"
/**************************************************************************************************
Configuration
**************************************************************************************************/
/* check if trying to free a buffer that is already free */
#ifndef WSF_BUF_FREE_CHECK
#define WSF_BUF_FREE_CHECK TRUE
#endif
/* assert on best-fit buffer allocation failure */
#ifndef WSF_BUF_ALLOC_BEST_FIT_FAIL_ASSERT
#define WSF_BUF_ALLOC_BEST_FIT_FAIL_ASSERT FALSE
#endif
/* assert on buffer allocation failure */
#ifndef WSF_BUF_ALLOC_FAIL_ASSERT
#define WSF_BUF_ALLOC_FAIL_ASSERT TRUE
#endif
/* buffer allocation stats */
#ifndef WSF_BUF_STATS
#define WSF_BUF_STATS FALSE
#endif
/* buffer histogram stats */
#ifndef WSF_BUF_STATS_HIST
#define WSF_BUF_STATS_HIST FALSE
#endif
/**************************************************************************************************
Macros
**************************************************************************************************/
/* magic number used to check for free buffer */
#define WSF_BUF_FREE_NUM 0xFAABD00D
/**************************************************************************************************
Data Types
**************************************************************************************************/
/* Unit of memory storage-- a structure containing a pointer */
typedef struct wsfBufMem_tag
{
struct wsfBufMem_tag *pNext;
#if WSF_BUF_FREE_CHECK == TRUE
uint32_t free;
#endif
} wsfBufMem_t;
/* Internal buffer pool */
typedef struct
{
wsfBufPoolDesc_t desc; /* number of buffers and length */
wsfBufMem_t *pStart; /* start of pool */
wsfBufMem_t *pFree; /* first free buffer in pool */
#if WSF_BUF_STATS == TRUE
uint8_t numAlloc; /* number of buffers currently allocated from pool */
uint8_t maxAlloc; /* maximum buffers ever allocated from pool */
uint16_t maxReqLen; /* maximum request length from pool. */
#endif
} wsfBufPool_t;
/**************************************************************************************************
Global Variables
**************************************************************************************************/
/* Number of pools */
uint8_t wsfBufNumPools;
/* Memory used for pools */
wsfBufMem_t *wsfBufMem = NULL;
/* Currently use for debugging only */
uint16_t wsfBufMemLen;
#if WSF_BUF_STATS_HIST == TRUE
/* Buffer allocation counter */
uint8_t wsfBufAllocCount[WSF_BUF_STATS_MAX_LEN];
#endif
#if WSF_OS_DIAG == TRUE
/* WSF buffer diagnostic callback function */
static wsfBufDiagCback_t wsfBufDiagCback = NULL;
#endif
/*************************************************************************************************/
/*!
* \fn WsfBufInit
*
* \brief Initialize the buffer pool service. This function should only be called once
* upon system initialization.
*
* \param bufMemLen Length of free memory
* \param pBufMem Free memory buffer for building buffer pools
* \param numPools Number of buffer pools.
* \param pDesc Array of buffer pool descriptors, one for each pool.
*
* \return Amount of pBufMem used or 0 for failures.
*/
/*************************************************************************************************/
uint16_t WsfBufInit(uint16_t bufMemLen, uint8_t *pBufMem, uint8_t numPools, wsfBufPoolDesc_t *pDesc)
{
wsfBufPool_t *pPool;
wsfBufMem_t *pStart;
uint16_t len;
uint8_t i;
wsfBufMem = (wsfBufMem_t *) pBufMem;
pPool = (wsfBufPool_t *) wsfBufMem;
/* buffer storage starts after the pool structs */
pStart = (wsfBufMem_t *) (pPool + numPools);
wsfBufNumPools = numPools;
/* create each pool; see loop exit condition below */
while (TRUE)
{
/* verify we didn't overrun memory; if we did, abort */
if (pStart > &wsfBufMem[bufMemLen / sizeof(wsfBufMem_t)])
{
WSF_ASSERT(FALSE);
return 0;
}
/* exit loop after verification check */
if (numPools-- == 0)
{
break;
}
/* adjust pool lengths for minimum size and alignment */
if (pDesc->len < sizeof(wsfBufMem_t))
{
pPool->desc.len = sizeof(wsfBufMem_t);
}
else if ((pDesc->len % sizeof(wsfBufMem_t)) != 0)
{
pPool->desc.len = pDesc->len + sizeof(wsfBufMem_t) - (pDesc->len % sizeof(wsfBufMem_t));
}
else
{
pPool->desc.len = pDesc->len;
}
pPool->desc.num = pDesc->num;
pDesc++;
pPool->pStart = pStart;
pPool->pFree = pStart;
#if WSF_BUF_STATS == TRUE
pPool->numAlloc = 0;
pPool->maxAlloc = 0;
pPool->maxReqLen = 0;
#endif
WSF_TRACE_INFO2("Creating pool len=%u num=%u", pPool->desc.len, pPool->desc.num);
WSF_TRACE_INFO1(" pStart=0x%x", (uint32_t)pPool->pStart);
/* initialize free list */
len = pPool->desc.len / sizeof(wsfBufMem_t);
for (i = pPool->desc.num; i > 1; i--)
{
/* verify we didn't overrun memory; if we did, abort */
if (pStart > &wsfBufMem[bufMemLen / sizeof(wsfBufMem_t)])
{
WSF_ASSERT(FALSE);
return 0;
}
/* pointer to the next free buffer is stored in the buffer itself */
pStart->pNext = pStart + len;
pStart += len;
}
/* verify we didn't overrun memory; if we did, abort */
if (pStart > &wsfBufMem[bufMemLen / sizeof(wsfBufMem_t)])
{
WSF_ASSERT(FALSE);
return 0;
}
/* last one in list points to NULL */
pStart->pNext = NULL;
pStart += len;
/* next pool */
pPool++;
}
wsfBufMemLen = (uint8_t *) pStart - (uint8_t *) wsfBufMem;
WSF_TRACE_INFO1("Created buffer pools; using %u bytes", wsfBufMemLen);
return wsfBufMemLen;
}
/*************************************************************************************************/
/*!
* \fn WsfBufAlloc
*
* \brief Allocate a buffer.
*
* \param len Length of buffer to allocate.
*
* \return Pointer to allocated buffer or NULL if allocation fails.
*/
/*************************************************************************************************/
void *WsfBufAlloc(uint16_t len)
{
wsfBufPool_t *pPool;
wsfBufMem_t *pBuf;
uint8_t i;
WSF_CS_INIT(cs);
WSF_ASSERT(len > 0);
pPool = (wsfBufPool_t *) wsfBufMem;
for (i = wsfBufNumPools; i > 0; i--, pPool++)
{
/* if buffer is big enough */
if (len <= pPool->desc.len)
{
/* enter critical section */
WSF_CS_ENTER(cs);
/* if buffers available */
if (pPool->pFree != NULL)
{
/* allocation succeeded */
pBuf = pPool->pFree;
/* next free buffer is stored inside current free buffer */
pPool->pFree = pBuf->pNext;
#if WSF_BUF_FREE_CHECK == TRUE
pBuf->free = 0;
#endif
#if WSF_BUF_STATS_HIST == TRUE
/* increment count for buffers of this length */
if (len < WSF_BUF_STATS_MAX_LEN)
{
wsfBufAllocCount[len]++;
}
else
{
wsfBufAllocCount[0]++;
}
#endif
#if WSF_BUF_STATS == TRUE
if (++pPool->numAlloc > pPool->maxAlloc)
{
pPool->maxAlloc = pPool->numAlloc;
}
pPool->maxReqLen = WSF_MAX(pPool->maxReqLen, len);
#endif
/* exit critical section */
WSF_CS_EXIT(cs);
WSF_TRACE_ALLOC2("WsfBufAlloc len:%u pBuf:%08x", pPool->desc.len, pBuf);
return pBuf;
}
/* exit critical section */
WSF_CS_EXIT(cs);
#if WSF_BUF_ALLOC_BEST_FIT_FAIL_ASSERT == TRUE
WSF_ASSERT(FALSE);
#endif
}
}
/* allocation failed */
#if WSF_OS_DIAG == TRUE
if (wsfBufDiagCback != NULL)
{
WsfBufDiag_t info;
info.type = WSF_BUF_ALLOC_FAILED;
info.param.alloc.taskId = WSF_OS_GET_ACTIVE_HANDLER_ID();
info.param.alloc.len = len;
wsfBufDiagCback(&info);
}
else
{
WSF_TRACE_WARN2("WsfBufAlloc failed len:%u - task:%u", len, WSF_OS_GET_ACTIVE_HANDLER_ID());
}
#else
WSF_TRACE_WARN1("WsfBufAlloc failed len:%u", len);
#endif
#if WSF_BUF_ALLOC_FAIL_ASSERT == TRUE
WSF_ASSERT(FALSE);
#endif
return NULL;
}
/*************************************************************************************************/
/*!
* \fn WsfBufFree
*
* \brief Free a buffer.
*
* \param pBuf Buffer to free.
*
* \return None.
*/
/*************************************************************************************************/
void WsfBufFree(void *pBuf)
{
wsfBufPool_t *pPool;
wsfBufMem_t *p = pBuf;
WSF_CS_INIT(cs);
/* verify pointer is within range */
#if WSF_BUF_FREE_CHECK == TRUE
WSF_ASSERT(p >= ((wsfBufPool_t *) wsfBufMem)->pStart);
WSF_ASSERT(p < (wsfBufMem_t *)(((uint8_t *) wsfBufMem) + wsfBufMemLen));
#endif
/* iterate over pools starting from last pool */
pPool = (wsfBufPool_t *) wsfBufMem + (wsfBufNumPools - 1);
while (pPool >= (wsfBufPool_t *) wsfBufMem)
{
/* if the buffer memory is located inside this pool */
if (p >= pPool->pStart)
{
/* enter critical section */
WSF_CS_ENTER(cs);
#if WSF_BUF_FREE_CHECK == TRUE
WSF_ASSERT(p->free != WSF_BUF_FREE_NUM);
p->free = WSF_BUF_FREE_NUM;
#endif
#if WSF_BUF_STATS == TRUE
pPool->numAlloc--;
#endif
/* pool found; put buffer back in free list */
p->pNext = pPool->pFree;
pPool->pFree = p;
/* exit critical section */
WSF_CS_EXIT(cs);
WSF_TRACE_FREE2("WsfBufFree len:%u pBuf:%08x", pPool->desc.len, pBuf);
return;
}
/* next pool */
pPool--;
}
/* should never get here */
WSF_ASSERT(FALSE);
return;
}
/*************************************************************************************************/
/*!
* \fn WsfBufGetAllocStats
*
* \brief Diagnostic function to get the buffer allocation statistics.
*
* \return Buffer allocation statistics array.
*/
/*************************************************************************************************/
uint8_t *WsfBufGetAllocStats(void)
{
#if WSF_BUF_STATS_HIST == TRUE
return wsfBufAllocCount;
#else
return NULL;
#endif
}
/*************************************************************************************************/
/*!
* \fn WsfBufGetNumPool
*
* \brief Get number of pools.
*
* \return Number of pools.
*/
/*************************************************************************************************/
uint8_t WsfBufGetNumPool(void)
{
return wsfBufNumPools;
}
/*************************************************************************************************/
/*!
* \fn WsfBufGetPoolStats
*
* \brief Get statistics for each pool.
*
* \param pBuf Buffer to store the statistics.
* \param poolId Pool ID.
*
* \return None.
*/
/*************************************************************************************************/
void WsfBufGetPoolStats(WsfBufPoolStat_t *pStat, uint8_t poolId)
{
wsfBufPool_t *pPool;
if (poolId >= wsfBufNumPools)
{
pStat->bufSize = 0;
return;
}
WSF_CS_INIT(cs);
WSF_CS_ENTER(cs);
pPool = (wsfBufPool_t *) wsfBufMem;
pStat->bufSize = pPool[poolId].desc.len;
pStat->numBuf = pPool[poolId].desc.num;
#if WSF_BUF_STATS == TRUE
pStat->numAlloc = pPool[poolId].numAlloc;
pStat->maxAlloc = pPool[poolId].maxAlloc;
pStat->maxReqLen = pPool[poolId].maxReqLen;
#else
pStat->numAlloc = 0;
pStat->maxAlloc = 0;
pStat->maxReqLen = 0;
#endif
/* exit critical section */
WSF_CS_EXIT(cs);
}
/*************************************************************************************************/
/*!
* \fn WsfBufDiagRegister
*
* \brief Called to register the buffer diagnostics callback function.
*
* \param pCallback Pointer to the callback function.
*
* \return None.
*/
/*************************************************************************************************/
void WsfBufDiagRegister(wsfBufDiagCback_t callback)
{
#if WSF_OS_DIAG == TRUE
wsfBufDiagCback = callback;
#endif
}
ambiq-hal-sys/ambiq-sparkfun-sdk/third_party/exactle/wsf/sources/port/freertos/wsf_cs.h
Vendored
+78
View File
@@ -0,0 +1,78 @@
/*************************************************************************************************/
/*!
* \file wsf_cs.h
*
* \brief Critical section macros.
*
* $Date: 2012-11-20 00:27:38 -0800 (Tue, 20 Nov 2012) $
* $Revision: 377 $
*
* Copyright (c) 2009 Wicentric, Inc., all rights reserved.
* Wicentric confidential and proprietary.
*
* IMPORTANT. Your use of this file is governed by a Software License Agreement
* ("Agreement") that must be accepted in order to download or otherwise receive a
* copy of this file. You may not use or copy this file for any purpose other than
* as described in the Agreement. If you do not agree to all of the terms of the
* Agreement do not use this file and delete all copies in your possession or control;
* if you do not have a copy of the Agreement, you must contact Wicentric, Inc. prior
* to any use, copying or further distribution of this software.
*/
/*************************************************************************************************/
#ifndef WSF_CS_H
#define WSF_CS_H
#include "wsf_os.h"
#ifdef __cplusplus
extern "C" {
#endif
/**************************************************************************************************
Macros
**************************************************************************************************/
/*************************************************************************************************/
/*!
* \def WSF_CS_INIT
*
* \brief Initialize critical section. This macro may define a variable.
*
* \param cs Critical section variable to be defined.
*/
/*************************************************************************************************/
#define WSF_CS_INIT(cs)
/*************************************************************************************************/
/*!
* \def WSF_CS_ENTER
*
* \brief Enter a critical section.
*
* \param cs Critical section variable.
*/
/*************************************************************************************************/
#define WSF_CS_ENTER(cs) WsfCsEnter()
/*************************************************************************************************/
/*!
* \def WSF_CS_EXIT
*
* \brief Exit a critical section.
*
* \param cs Critical section variable.
*/
/*************************************************************************************************/
#define WSF_CS_EXIT(cs) WsfCsExit()
/**************************************************************************************************
Function Declarations
**************************************************************************************************/
void WsfCsEnter(void);
void WsfCsExit(void);
#ifdef __cplusplus
};
#endif
#endif /* WSF_CS_H */
ambiq-hal-sys/ambiq-sparkfun-sdk/third_party/exactle/wsf/sources/port/freertos/wsf_efs.c
Vendored
+681
View File
@@ -0,0 +1,681 @@
/*************************************************************************************************/
/*!
* \file wsf_efs.c
*
* \brief Embedded File System service.
*
* $Date: 2017-03-09 12:18:38 -0600 (Thu, 09 Mar 2017) $
* $Revision: 11460 $
*
* Copyright (c) 2014-2017 ARM Ltd., all rights reserved.
* ARM Ltd. confidential and proprietary.
*
* IMPORTANT. Your use of this file is governed by a Software License Agreement
* ("Agreement") that must be accepted in order to download or otherwise receive a
* copy of this file. You may not use or copy this file for any purpose other than
* as described in the Agreement. If you do not agree to all of the terms of the
* Agreement do not use this file and delete all copies in your possession or control;
* if you do not have a copy of the Agreement, you must contact ARM Ltd. prior
* to any use, copying or further distribution of this software.
*/
/*************************************************************************************************/
#include <string.h>
#include "wsf_types.h"
#include "wsf_efs.h"
#include "wsf_assert.h"
#include "wsf_trace.h"
#include "wsf_cs.h"
#include "bstream.h"
/* Media Control Block */
static pWsfEfsMedia_t wsfEfsMediaTbl[WSF_EFS_MAX_MEDIA];
/* File Control Block */
static wsfEfsControl_t wsfEfsFileTbl[WSF_EFS_MAX_FILES];
/*************************************************************************************************/
/*!
* \fn wsfEfsMediaValid
*
* \brief Checks if the given physical media identifier has been registered with the file system.
*
* \param media The physical media identifier
*
* \return TRUE if valid, else FALSE.
*/
/*************************************************************************************************/
static bool_t wsfEfsMediaValid(uint8_t media)
{
if (media < WSF_EFS_MAX_MEDIA && wsfEfsMediaTbl[media])
{
return TRUE;
}
return FALSE;
}
/*************************************************************************************************/
/*!
* \fn WsfEfsGetFileByHandle
*
* \brief Returns the file control block for the given handle.
*
* \param handle Handle of the file
*
* \return File control block, or NULL.
*/
/*************************************************************************************************/
wsfEfsControl_t *WsfEfsGetFileByHandle(wsfEfsHandle_t handle)
{
if ((handle < WSF_EFS_MAX_FILES) &&
(wsfEfsFileTbl[handle].maxSize != WSF_EFS_INVALID_SIZE))
{
return &wsfEfsFileTbl[handle];
}
return NULL;
}
/*************************************************************************************************/
/*!
* \fn wsfEfsFileOverlap
*
* \brief Checks if the given offset and size overlaps with a given file.
*
* \param handle The handle of the file to check against
* \param media The physical medium the new file will be in
* \param address The starting address in the physical medium
* \param size The max size of the file
*
* \return TRUE if overlap, else FALSE.
*/
/*************************************************************************************************/
static bool_t wsfEfsFileOverlap(wsfEfsHandle_t handle, uint8_t media, uint32_t address, uint32_t size)
{
if (wsfEfsMediaValid(media))
{
/* Check if the table entry is in use and the physical media are the same */
if (size && (wsfEfsFileTbl[handle].maxSize) &&
(wsfEfsFileTbl[handle].maxSize != WSF_EFS_INVALID_SIZE) &&
(wsfEfsFileTbl[handle].media == media))
{
/* Calculate the top and bottom addresses of the files */
uint32_t top1 = wsfEfsFileTbl[handle].address;
uint32_t bottom1 = wsfEfsFileTbl[handle].address + wsfEfsFileTbl[handle].maxSize - 1;
uint32_t top2 = address;
uint32_t bottom2 = address + size - 1;
/* Check for overlap */
if ((top2 >= top1) && (top2 <= bottom1))
return TRUE;
if ((bottom2 >= top1) && (bottom2 <= bottom1))
return TRUE;
}
}
return FALSE;
}
/*************************************************************************************************/
/*!
* \fn wsfEfsFindAvailableOffset
*
* \brief Finds the offset of an unused area of the physical media big enough for a file
* of the given size.
*
* \param media The physical medium
* \param size The max size of the file
*
* \return The next available offset.
*/
/*************************************************************************************************/
static uint32_t wsfEfsFindAvailableOffset(uint8_t media, uint32_t size)
{
if (wsfEfsMediaValid(media))
{
int8_t i;
uint32_t address = wsfEfsMediaTbl[media]->startAddress;
for (i=0; i<WSF_EFS_MAX_FILES; i++)
{
if (wsfEfsFileOverlap(i, media, address, size))
{
/* The offset overlaps another file. Move the offset to the end of the overlapping */
/* file and retest. */
address = wsfEfsFileTbl[i].address + wsfEfsFileTbl[i].maxSize;
address += address % wsfEfsMediaTbl[media]->pageSize;
i = -1;
if (address + size > wsfEfsMediaTbl[media]->endAddress)
return WSF_EFS_INVALID_OFFSET;
}
}
return address;
}
return WSF_EFS_INVALID_OFFSET;
}
/*************************************************************************************************/
/*!
* \fn WsfEfsInit
*
* \brief Initialize the embedded file system.
*
* \return none.
*/
/*************************************************************************************************/
void WsfEfsInit(void)
{
int8_t i;
/* Clear control structures */
memset((void *) wsfEfsMediaTbl, 0, sizeof(wsfEfsMediaTbl));
/* Set maxSize to invalid indicating file is unused */
for (i=0; i<WSF_EFS_MAX_FILES; i++)
{
wsfEfsFileTbl[i].maxSize = WSF_EFS_INVALID_SIZE;
}
}
/*************************************************************************************************/
/*!
* \fn WsfEfsAddFile
*
* \brief Create a file in the embedded file system.
*
* \param maxSize Number of bytes to reserve for the file.
* \param media Identifier of the media where the file is stored.
* \param pAttr Attributes of the file
* \param offset Offset address of the file in the memory space.
*
* \return File Handle, or WSF_EFS_INVALID_HANDLE if the operation failed.
*/
/*************************************************************************************************/
wsfEfsHandle_t WsfEfsAddFile(uint32_t maxSize, uint8_t media, wsfEsfAttributes_t *pAttr, uint32_t offset)
{
wsfEfsHandle_t handle;
uint32_t address = offset;
wsfEfsControl_t *pFile = NULL;
if (wsfEfsMediaValid(media))
{
/* Find an available slot in the file table (wsfEfsFileTbl) */
for (handle = 0; handle < WSF_EFS_MAX_FILES; handle++)
{
if (wsfEfsFileTbl[handle].maxSize == WSF_EFS_INVALID_SIZE)
{
pFile = &wsfEfsFileTbl[handle];
break;
}
}
if (pFile)
{
if (address == WSF_EFS_FILE_OFFSET_ANY)
{
address = wsfEfsFindAvailableOffset(media, maxSize);
if (address == WSF_EFS_INVALID_OFFSET)
return WSF_EFS_INVALID_HANDLE;
}
else
{
int i;
/* The user specifies a zero based offset when adding a file */
/* This offset must be incremented by the media StartAddress */
/* to become the file's address in the wsfEfsMediaTbl. */
address += wsfEfsMediaTbl[media]->startAddress;
/* Increment the address to a page boundry */
if (wsfEfsMediaTbl[media]->pageSize)
{
address += address % wsfEfsMediaTbl[media]->pageSize;
}
/* Verify the given offset doesn't overlap another file */
for (i=0; i<WSF_EFS_MAX_FILES; i++)
{
if (wsfEfsFileOverlap(i, media, address, maxSize) == TRUE)
return WSF_EFS_INVALID_HANDLE;
}
}
/* Fill in the file control structure */
pFile->size = 0;
pFile->media = media;
pFile->address = address;
memcpy(&pFile->attributes, pAttr, sizeof(wsfEsfAttributes_t));
/* Set the maxSize, and increment the maxSize such that it */
/* occupies a full page in the physical medium */
pFile->maxSize = maxSize;
if (wsfEfsMediaTbl[media]->pageSize)
{
pFile->maxSize += maxSize % wsfEfsMediaTbl[media]->pageSize;
}
return handle;
}
}
return WSF_EFS_INVALID_HANDLE;
}
/*************************************************************************************************/
/*!
* \fn WsfEfsRemoveFile
*
* \brief Deletes a file in the embedded file system.
*
* \param handle Handle identifying the file.
*
* \return WSF_EFS_SUCCESS or WSF_EFS_FAILURE.
*/
/*************************************************************************************************/
uint8_t WsfEfsRemoveFile(wsfEfsHandle_t handle)
{
if (handle < WSF_EFS_MAX_FILES)
{
wsfEfsFileTbl[handle].maxSize = WSF_EFS_INVALID_SIZE;
return WSF_EFS_SUCCESS;
}
return WSF_EFS_FAILURE;
}
/*************************************************************************************************/
/*!
* \fn WsfEfsErase
*
* \brief Clears the contents of a file without deleting the file.
*
* \param handle Handle identifying the file.
*
* \return WSF_EFS_SUCCESS or WSF_EFS_FAILURE.
*/
/*************************************************************************************************/
uint8_t WsfEfsErase(wsfEfsHandle_t handle)
{
uint8_t status = WSF_EFS_FAILURE;
wsfEfsControl_t *pFile;
if ((pFile = WsfEfsGetFileByHandle(handle)) != NULL)
{
if (pFile->attributes.permissions & (WSF_EFS_REMOTE_ERASE_PERMITTED | WSF_EFS_LOCAL_ERASE_PERMITTED))
{
uint8_t media = pFile->media;
if (wsfEfsMediaTbl[media]->erase)
{
uint32_t address = pFile->address;
uint32_t size = pFile->maxSize;
status = wsfEfsMediaTbl[media]->erase(address, size);
pFile->size = 0;
}
}
}
return status;
}
/*************************************************************************************************/
/*!
* \fn WsfEfsGetAttributes
*
* \brief Gets the attributes of a file.
*
* \param handle Handle identifying the file.
* \param pAttr Pointer to memory to store the attributes.
*
* \return WSF_EFS_SUCCESS or WSF_EFS_FAILURE.
*/
/*************************************************************************************************/
uint8_t WsfEfsGetAttributes(wsfEfsHandle_t handle, wsfEsfAttributes_t *pAttr)
{
wsfEfsControl_t *pFile;
if (((pFile = WsfEfsGetFileByHandle(handle)) != NULL) && pAttr)
{
memcpy(pAttr, &pFile->attributes, sizeof(wsfEsfAttributes_t));
return WSF_EFS_SUCCESS;
}
return WSF_EFS_FAILURE;
}
/*************************************************************************************************/
/*!
* \fn WsfEfsSetAttributes
*
* \brief Updates the attributes of a file.
*
* \param handle Handle identifying the file.
* \param pAttr Pointer to memory to with the new attributes.
*
* \return WSF_EFS_SUCCESS or WSF_EFS_FAILURE.
*/
/*************************************************************************************************/
uint8_t WsfEfsSetAttributes(wsfEfsHandle_t handle, wsfEsfAttributes_t *pAttr)
{
wsfEfsControl_t *pFile;
if (((pFile = WsfEfsGetFileByHandle(handle)) != NULL) && pAttr)
{
memcpy(&pFile->attributes, pAttr, sizeof(wsfEsfAttributes_t));
return WSF_EFS_SUCCESS;
}
return WSF_EFS_FAILURE;
}
/*************************************************************************************************/
/*!
* \fn WsfEfsGet
*
* \brief Copies data from a file.
*
* \param handle Handle identifying the file.
* \param offset Offset into the file to begin copying from.
* \param pBuffer Location to copy the data to.
* \param len Number of bytes to copy into pBuffer.
*
* \return The number of bytes read from the file.
*/
/*************************************************************************************************/
uint16_t WsfEfsGet(wsfEfsHandle_t handle, uint32_t offset, uint8_t *pBuffer, uint16_t len)
{
wsfEfsControl_t *pFile;
if (((pFile = WsfEfsGetFileByHandle(handle)) != NULL) && pBuffer)
{
if (pFile->attributes.permissions & (WSF_EFS_REMOTE_GET_PERMITTED | WSF_EFS_LOCAL_GET_PERMITTED))
{
uint8_t media = pFile->media;
if (wsfEfsMediaTbl[media]->read)
{
if (pFile->attributes.type == WSF_EFS_FILE_TYPE_STREAM)
{
wsfEfsMediaTbl[media]->read(pBuffer, 0, len);
return len;
}
else if (offset < pFile->size)
{
uint32_t address = pFile->address + offset;
if (offset + len > pFile->size)
{
len = (uint16_t) (pFile->size - offset);
}
wsfEfsMediaTbl[media]->read(pBuffer, address, len);
return len;
}
}
}
}
return 0;
}
/*************************************************************************************************/
/*!
* \fn WsfEfsPut
*
* \brief Writes data to a file.
*
* \param handle Handle identifying the file.
* \param offset Offset into the file to begin writing to.
* \param pBuffer Data to write to the file.
* \param len Number of bytes to write to the file.
*
* \return The number of bytes written to the file
*/
/*************************************************************************************************/
uint16_t WsfEfsPut(wsfEfsHandle_t handle, uint32_t offset, const uint8_t *pBuffer, uint16_t len)
{
wsfEfsControl_t *pFile;
if (((pFile = WsfEfsGetFileByHandle(handle)) != NULL) && pBuffer)
{
if (pFile->attributes.permissions & (WSF_EFS_REMOTE_PUT_PERMITTED | WSF_EFS_LOCAL_PUT_PERMITTED))
{
uint8_t media = pFile->media;
if (wsfEfsMediaTbl[media]->write)
{
if (pFile->attributes.type == WSF_EFS_FILE_TYPE_STREAM)
{
wsfEfsMediaTbl[media]->write(pBuffer, 0, len);
return len;
}
else if (offset < pFile->maxSize)
{
uint32_t address = pFile->address + offset;
if (offset + len > pFile->maxSize)
{
len = (uint16_t) (pFile->maxSize - offset);
}
wsfEfsMediaTbl[media]->write(pBuffer, address, len);
/* If writing to the end of the file, update the file size */
if (offset + len > pFile->size)
{
pFile->size = offset + len;
}
return len;
}
}
}
}
return 0;
}
/*************************************************************************************************/
/*!
* \fn WsfEfsGetFileName
*
* \brief Get the name of a file.
*
* \param handle File Handle.
*
* \return Filename string of a file.
*/
/*************************************************************************************************/
char *WsfEfsGetFileName(wsfEfsHandle_t handle)
{
wsfEfsControl_t *pFile;
if (((pFile = WsfEfsGetFileByHandle(handle)) != NULL))
{
return pFile->attributes.name;
}
return "Unknown";
}
/*************************************************************************************************/
/*!
* \fn WsfEfsGetFileVersion
*
* \brief Get the version of a file.
*
* \param handle File Handle.
*
* \return Version string of a file.
*/
/*************************************************************************************************/
char *WsfEfsGetFileVersion(wsfEfsHandle_t handle)
{
wsfEfsControl_t *pFile;
if (((pFile = WsfEfsGetFileByHandle(handle)) != NULL))
{
return pFile->attributes.version;
}
return "Unknown";
}
/*************************************************************************************************/
/*!
* \fn WsfEfsGetFileMaxSize
*
* \brief Get the number of bytes of memory reserved for use by a file.
*
* \param handle File Handle.
*
* \return Max size of the file.
*/
/*************************************************************************************************/
uint32_t WsfEfsGetFileMaxSize(wsfEfsHandle_t handle)
{
wsfEfsControl_t *pFile;
if (((pFile = WsfEfsGetFileByHandle(handle)) != NULL))
{
return pFile->maxSize;
}
return 0;
}
/*************************************************************************************************/
/*!
* \fn WsfEfsGetFileSize
*
* \brief Get the size of a file.
*
* \param handle File Handle.
*
* \return Size of the file.
*/
/*************************************************************************************************/
uint32_t WsfEfsGetFileSize(wsfEfsHandle_t handle)
{
wsfEfsControl_t *pFile;
if (((pFile = WsfEfsGetFileByHandle(handle)) != NULL))
{
return pFile->size;
}
return 0;
}
/*************************************************************************************************/
/*!
* \fn WsfEfsGetFileType
*
* \brief Get the type of a file.
*
* \param handle File Handle.
*
* \return Type of file (bulk or stream).
*/
/*************************************************************************************************/
uint8_t WsfEfsGetFileType(wsfEfsHandle_t handle)
{
wsfEfsControl_t *pFile;
if (((pFile = WsfEfsGetFileByHandle(handle)) != NULL))
{
return pFile->attributes.type;
}
return WSF_EFS_FILE_TYPE_BULK;
}
/*************************************************************************************************/
/*!
* \fn WsfEfsGetFilePermissions
*
* \brief Get the permissions of a file.
*
* \param handle File Handle.
*
* \return Permissions of the file.
*/
/*************************************************************************************************/
uint16_t WsfEfsGetFilePermissions(wsfEfsHandle_t handle)
{
wsfEfsControl_t *pFile;
if (((pFile = WsfEfsGetFileByHandle(handle)) != NULL))
{
return pFile->attributes.permissions;
}
return 0;
}
/*************************************************************************************************/
/*!
* \fn WsfEfsMediaSpecificCommand
*
* \brief Execute a media specific command on a file.
*
* \param handle File Handle.
* \param cmd Media specific command identifier.
* \param param Ccommand specific parameter.
*
* \return Status of the operation.
*/
/*************************************************************************************************/
uint8_t WsfEfsMediaSpecificCommand(wsfEfsHandle_t handle, uint8_t cmd, uint32_t param)
{
if (WsfEfsGetFileByHandle(handle))
{
uint8_t media = wsfEfsFileTbl[handle].media;
/* Call the command handler if it exists */
if (wsfEfsMediaTbl[media]->handleCmd)
{
return wsfEfsMediaTbl[media]->handleCmd(cmd, param);
}
}
return FALSE;
}
/*************************************************************************************************/
/*!
* \fn WsfEfsRegisterMedia
*
* \brief Registers a File Storage Medium with the Embedded File System.
*
* \param pMedia Pointer to the media control structure.
* \param mediaID Identifier of the media.
*
* \return WSF_EFS_SUCCESS or WSF_EFS_FAILURE.
*/
/*************************************************************************************************/
uint8_t WsfEfsRegisterMedia(const wsfEfsMedia_t *pMediaCtrl, uint8_t mediaID)
{
if (mediaID < WSF_EFS_MAX_MEDIA && pMediaCtrl)
{
wsfEfsMediaTbl[mediaID] = pMediaCtrl;
/* Call the initialization function for the media */
if (pMediaCtrl->init)
{
pMediaCtrl->init();
}
return WSF_EFS_SUCCESS;
}
return WSF_EFS_FAILURE;
}
ambiq-hal-sys/ambiq-sparkfun-sdk/third_party/exactle/wsf/sources/port/freertos/wsf_intrinsic.h
Vendored
+123
View File
@@ -0,0 +1,123 @@
/*************************************************************************************************/
/*!
* \file wsf_intrinsic.h
*
* \brief CPU core intrinsic functions.
*
* $Date: 2013-05-22 15:52:25 -0700 (Wed, 22 May 2013) $
* $Revision: 660 $
*
* Copyright (c) 2009 Wicentric, Inc., all rights reserved.
* Wicentric confidential and proprietary.
*
* IMPORTANT. Your use of this file is governed by a Software License Agreement
* ("Agreement") that must be accepted in order to download or otherwise receive a
* copy of this file. You may not use or copy this file for any purpose other than
* as described in the Agreement. If you do not agree to all of the terms of the
* Agreement do not use this file and delete all copies in your possession or control;
* if you do not have a copy of the Agreement, you must contact Wicentric, Inc. prior
* to any use, copying or further distribution of this software.
*/
/*************************************************************************************************/
#ifndef WSF_INTRINSIC_H
#define WSF_INTRINSIC_H
#ifdef __arm__
#include "device_cm3.h"
#endif
#ifdef __cplusplus
extern "C" {
#endif
/**************************************************************************************************
Macros
**************************************************************************************************/
/*************************************************************************************************/
/*!
* \def WsfLeadingMsbZeros
*
* \brief Count leading MSB zero.
*
* \param value Value to count leading zeros.
*
* \return Number of leading zeros.
*/
/*************************************************************************************************/
#ifdef __arm__
#define WsfClzMsb(v) __CLZ(v)
#else
static inline uint8_t WsfClzMsb(uint32_t value)
{
/* Stub for platform specific implementation. */
return 0;
}
#endif
/*************************************************************************************************/
/*!
* \def WsfLeadingMsbOnes
*
* \brief Count leading MSB ones.
*
* \param value Value to count leading ones.
*
* \return Number of leading ones.
*/
/*************************************************************************************************/
#ifdef __arm__
#define WsfCloMsb(v) __CLZ(~v)
#else
static inline uint8_t WsfCloMsb(uint32_t value)
{
return WsfClzMsb(~value);
}
#endif
/*************************************************************************************************/
/*!
* \def WsfLeadingLsbZeros
*
* \brief Count leading LSB zero.
*
* \param value Value to count leading zeros.
*
* \return Number of leading zeros.
*/
/*************************************************************************************************/
#ifdef __arm__
#define WsfClzLsb(v) __CLZ(__REV(v))
#else
static inline uint8_t WsfClzLsb(uint32_t value)
{
/* Stub for platform specific implementation. */
return 0;
}
#endif
/*************************************************************************************************/
/*!
* \def WsfLeadingLsbOnes
*
* \brief Count leading LSB ones.
*
* \param value Value to count leading ones.
*
* \return Number of leading ones.
*/
/*************************************************************************************************/
#ifdef __arm__
#define WsfCloLsb(v) __CLZ(__REV(~v))
#else
static inline uint8_t WsfCloLsb(uint32_t value)
{
return WsfClzLsb(~value);
}
#endif
#ifdef __cplusplus
};
#endif
#endif /* WSF_INTRINSIC_H */
ambiq-hal-sys/ambiq-sparkfun-sdk/third_party/exactle/wsf/sources/port/freertos/wsf_math.c
Vendored
+97
View File
@@ -0,0 +1,97 @@
/*************************************************************************************************/
/*!
* \file wsf_math.c
*
* \brief Common math utilities generic implementation file.
*
* $Date: 2014-09-16 13:19:18 -0700 (Tue, 16 Sep 2014) $
* $Revision: 1816 $
*
* Copyright (c) 2013 Wicentric, Inc., all rights reserved.
* Wicentric confidential and proprietary.
*
* IMPORTANT. Your use of this file is governed by a Software License Agreement
* ("Agreement") that must be accepted in order to download or otherwise receive a
* copy of this file. You may not use or copy this file for any purpose other than
* as described in the Agreement. If you do not agree to all of the terms of the
* Agreement do not use this file and delete all copies in your possession or control;
* if you do not have a copy of the Agreement, you must contact Wicentric, Inc. prior
* to any use, copying or further distribution of this software.
*/
/*************************************************************************************************/
#include "wsf_math.h"
#include <string.h>
/**************************************************************************************************
Global Variables
**************************************************************************************************/
static uint32_t wsfRngW = 88675123;
static uint32_t wsfRngX = 123456789;
static uint32_t wsfRngY = 362436069;
static uint32_t wsfRngZ = 521288629;
/*************************************************************************************************/
/*!
* \fn WsfMathInit
*
* \brief Initialize math routines.
*
* \return None.
*/
/*************************************************************************************************/
void WsfMathInit(void)
{
/* Seed PRNG. */
wsfRngW = 88675123;
wsfRngX = 123456789;
wsfRngY = 362436069;
wsfRngZ = 521288629;
}
/*************************************************************************************************/
/*!
* \fn WsfRandNum
*
* \brief Generate random number.
*
* \return 32-bit random number.
*
* This software implementation uses a xorshift random number generator.
* George Marsaglia (2003), "Xorshift RNGs", Journal of Statistical Software
*
* \note This routine is not a cryptographic grade random number generator.
*/
/*************************************************************************************************/
uint32_t WsfRandNum(void)
{
uint32_t t;
t = wsfRngX ^ (wsfRngX << 11);
wsfRngX = wsfRngY;
wsfRngY = wsfRngZ;
wsfRngZ = wsfRngW;
wsfRngW = wsfRngW ^ (wsfRngW >> 19) ^ (t ^ (t >> 8));
return wsfRngW;
}
/*************************************************************************************************/
/*!
* \fn WsfAesEcb
*
* \brief Calculate AES ECB.
*
* \param pKey Encryption key.
* \param pOut Output data.
* \param pIn Input data.
*
* \return None.
*/
/*************************************************************************************************/
void WsfAesEcb(const uint8_t *pKey, uint8_t *pOut, const uint8_t *pIn)
{
/* TODO implementation required. */
const unsigned int KEY_LEN = 16;
memcpy(pOut, pIn, KEY_LEN);
}
ambiq-hal-sys/ambiq-sparkfun-sdk/third_party/exactle/wsf/sources/port/freertos/wsf_msg.c
Vendored
+204
View File
@@ -0,0 +1,204 @@
/*************************************************************************************************/
/*!
* \file wsf_msg.c
*
* \brief Message passing service.
*
* $Date: 2017-03-10 14:08:37 -0600 (Fri, 10 Mar 2017) $
* $Revision: 11501 $
*
* Copyright (c) 2009-2017 ARM Ltd., all rights reserved.
* ARM Ltd. confidential and proprietary.
*
* IMPORTANT. Your use of this file is governed by a Software License Agreement
* ("Agreement") that must be accepted in order to download or otherwise receive a
* copy of this file. You may not use or copy this file for any purpose other than
* as described in the Agreement. If you do not agree to all of the terms of the
* Agreement do not use this file and delete all copies in your possession or control;
* if you do not have a copy of the Agreement, you must contact ARM Ltd. prior
* to any use, copying or further distribution of this software.
*/
/*************************************************************************************************/
#include "wsf_types.h"
#include "wsf_msg.h"
#include "wsf_assert.h"
#include "wsf_buf.h"
#include "wsf_queue.h"
#include "wsf_trace.h"
#include "wsf_os.h"
/**************************************************************************************************
Data Types
**************************************************************************************************/
/* Internal message buf structure */
typedef struct wsfMsg_tag
{
struct wsfMsg_tag *pNext;
wsfHandlerId_t handlerId;
} wsfMsg_t;
/*************************************************************************************************/
/*!
* \fn WsfMsgDataAlloc
*
* \brief Allocate a data message buffer to be sent with WsfMsgSend().
*
* \param len Message length in bytes.
* \param tailroom Tailroom length in bytes.
*
* \return Pointer to data message buffer or NULL if allocation failed.
*/
/*************************************************************************************************/
void *WsfMsgDataAlloc(uint16_t len, uint8_t tailroom)
{
return WsfMsgAlloc(len + tailroom);
}
/*************************************************************************************************/
/*!
* \fn WsfMsgAlloc
*
* \brief Allocate a message buffer to be sent with WsfMsgSend().
*
* \param len Message length in bytes.
*
* \return Pointer to message buffer or NULL if allocation failed.
*/
/*************************************************************************************************/
void *WsfMsgAlloc(uint16_t len)
{
wsfMsg_t *pMsg;
pMsg = WsfBufAlloc(len + sizeof(wsfMsg_t));
/* hide header */
if (pMsg != NULL)
{
pMsg++;
}
return pMsg;
}
/*************************************************************************************************/
/*!
* \fn WsfMsgFree
*
* \brief Free a message buffer allocated with WsfMsgAlloc().
*
* \param pMsg Pointer to message buffer.
*
* \return None.
*/
/*************************************************************************************************/
void WsfMsgFree(void *pMsg)
{
WsfBufFree(((wsfMsg_t *) pMsg) - 1);
}
/*************************************************************************************************/
/*!
* \fn WsfMsgSend
*
* \brief Send a message to an event handler.
*
* \param handlerId Event handler ID.
* \param pMsg Pointer to message buffer.
*
* \return None.
*/
/*************************************************************************************************/
void WsfMsgSend(wsfHandlerId_t handlerId, void *pMsg)
{
WSF_TRACE_MSG1("WsfMsgSend handlerId:%u", handlerId);
/* get queue for this handler and enqueue message */
WsfMsgEnq(WsfTaskMsgQueue(handlerId), handlerId, pMsg);
/* set task for this handler as ready to run */
WsfTaskSetReady(handlerId, WSF_MSG_QUEUE_EVENT);
}
/*************************************************************************************************/
/*!
* \fn WsfMsgEnq
*
* \brief Enqueue a message.
*
* \param pQueue Pointer to queue.
* \param handerId Set message handler ID to this value.
* \param pElem Pointer to message buffer.
*
* \return None.
*/
/*************************************************************************************************/
void WsfMsgEnq(wsfQueue_t *pQueue, wsfHandlerId_t handlerId, void *pMsg)
{
wsfMsg_t *p;
WSF_ASSERT(pMsg != NULL);
/* get message header */
p = ((wsfMsg_t *) pMsg) - 1;
/* set handler ID */
p->handlerId = handlerId;
WsfQueueEnq(pQueue, p);
}
/*************************************************************************************************/
/*!
* \fn WsfMsgDeq
*
* \brief Dequeue a message.
*
* \param pQueue Pointer to queue.
* \param pHandlerId Handler ID of returned message; this is a return parameter.
*
* \return Pointer to message that has been dequeued or NULL if queue is empty.
*/
/*************************************************************************************************/
void *WsfMsgDeq(wsfQueue_t *pQueue, wsfHandlerId_t *pHandlerId)
{
wsfMsg_t *pMsg;
if ((pMsg = WsfQueueDeq(pQueue)) != NULL)
{
*pHandlerId = pMsg->handlerId;
/* hide header */
pMsg++;
}
return pMsg;
}
/*************************************************************************************************/
/*!
* \fn WsfMsgPeek
*
* \brief Get the next message without removing it from the queue.
*
* \param pQueue Pointer to queue.
* \param pHandlerId Handler ID of returned message; this is a return parameter.
*
* \return Pointer to the next message on the queue or NULL if queue is empty.
*/
/*************************************************************************************************/
void *WsfMsgPeek(wsfQueue_t *pQueue, wsfHandlerId_t *pHandlerId)
{
wsfMsg_t *pMsg = pQueue->pHead;
if (pMsg != NULL)
{
*pHandlerId = pMsg->handlerId;
/* hide header */
pMsg++;
}
return pMsg;
}
ambiq-hal-sys/ambiq-sparkfun-sdk/third_party/exactle/wsf/sources/port/freertos/wsf_os.c
Vendored
+426
View File
@@ -0,0 +1,426 @@
/*************************************************************************************************/
/*!
* \file wsf_os.c
*
* \brief Software foundation OS main module.
*
* $Date: 2015-09-09 09:35:06 -0700 (Wed, 09 Sep 2015) $
* $Revision: 3809 $
*
* Copyright (c) 2009 Wicentric, Inc., all rights reserved.
* Wicentric confidential and proprietary.
*
* IMPORTANT. Your use of this file is governed by a Software License Agreement
* ("Agreement") that must be accepted in order to download or otherwise receive a
* copy of this file. You may not use or copy this file for any purpose other than
* as described in the Agreement. If you do not agree to all of the terms of the
* Agreement do not use this file and delete all copies in your possession or control;
* if you do not have a copy of the Agreement, you must contact Wicentric, Inc. prior
* to any use, copying or further distribution of this software.
*/
/*************************************************************************************************/
#ifdef __IAR_SYSTEMS_ICC__
#include <intrinsics.h>
#endif
#include <string.h>
#include "wsf_types.h"
#include "wsf_os.h"
#include "wsf_assert.h"
#include "wsf_trace.h"
#include "wsf_timer.h"
#include "wsf_queue.h"
#include "wsf_buf.h"
#include "wsf_msg.h"
#include "wsf_cs.h"
/**************************************************************************************************
Compile time assert checks
**************************************************************************************************/
WSF_CT_ASSERT(sizeof(uint8_t) == 1);
WSF_CT_ASSERT(sizeof(uint16_t) == 2);
WSF_CT_ASSERT(sizeof(uint32_t) == 4);
/**************************************************************************************************
Macros
**************************************************************************************************/
/* maximum number of event handlers per task */
#ifndef WSF_MAX_HANDLERS
#define WSF_MAX_HANDLERS 9
#endif
/**************************************************************************************************
Data Types
**************************************************************************************************/
/* Task structure */
typedef struct
{
wsfEventHandler_t handler[WSF_MAX_HANDLERS];
wsfEventMask_t handlerEventMask[WSF_MAX_HANDLERS];
wsfQueue_t msgQueue;
wsfTaskEvent_t taskEventMask;
uint8_t numHandler;
} wsfOsTask_t;
/* OS structure */
typedef struct
{
wsfOsTask_t task;
} wsfOs_t;
/**************************************************************************************************
Local Variables
**************************************************************************************************/
uint8_t csNesting = 0;
wsfOs_t wsfOs;
#include "FreeRTOS.h"
#include "event_groups.h"
EventGroupHandle_t xRadioTaskEventObject = NULL;
/*************************************************************************************************/
/*!
* \fn WsfCsEnter
*
* \brief Enter a critical section.
*
* \return None.
*/
/*************************************************************************************************/
void WsfCsEnter(void)
{
if (csNesting == 0)
{
#ifdef __IAR_SYSTEMS_ICC__
__disable_interrupt();
#endif
#ifdef __GNUC__
__asm volatile ("cpsid i");
#endif
#ifdef __CC_ARM
__disable_irq();
#endif
}
csNesting++;
}
/*************************************************************************************************/
/*!
* \fn WsfCsEnter
*
* \brief Enter a critical section.
*
* \return None.
*/
/*************************************************************************************************/
void WsfCsExit(void)
{
WSF_ASSERT(csNesting != 0);
csNesting--;
if (csNesting == 0)
{
#ifdef __IAR_SYSTEMS_ICC__
__enable_interrupt();
#endif
#ifdef __GNUC__
__asm volatile ("cpsie i");
#endif
#ifdef __CC_ARM
__enable_irq();
#endif
}
}
/*************************************************************************************************/
/*!
* \fn WsfTaskLock
*
* \brief Lock task scheduling.
*
* \return None.
*/
/*************************************************************************************************/
void WsfTaskLock(void)
{
WsfCsEnter();
}
/*************************************************************************************************/
/*!
* \fn WsfTaskUnlock
*
* \brief Unock task scheduling.
*
* \return None.
*/
/*************************************************************************************************/
void WsfTaskUnlock(void)
{
WsfCsExit();
}
void WsfSetOsSpecificEvent(void)
{
if(xRadioTaskEventObject != NULL)
{
BaseType_t xHigherPriorityTaskWoken, xResult;
if(xPortIsInsideInterrupt() == pdTRUE) {
//
// Send an event to the main radio task
//
xHigherPriorityTaskWoken = pdFALSE;
xResult = xEventGroupSetBitsFromISR(xRadioTaskEventObject, 1,
&xHigherPriorityTaskWoken);
//
// If the radio task is higher-priority than the context we're currently
// running from, we should yield now and run the radio task.
//
if ( xResult != pdFAIL )
{
portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}
}
else {
xResult = xEventGroupSetBits(xRadioTaskEventObject, 1);
//
// If the radio task is higher priority than the context we're currently
// running from, we should yield now and run the radio task.
//
if ( xResult != pdFAIL )
{
portYIELD();
}
}
}
}
/*************************************************************************************************/
/*!
* \fn WsfSetEvent
*
* \brief Set an event for an event handler.
*
* \param handlerId Handler ID.
* \param event Event or events to set.
*
* \return None.
*/
/*************************************************************************************************/
void WsfSetEvent(wsfHandlerId_t handlerId, wsfEventMask_t event)
{
WSF_CS_INIT(cs);
WSF_ASSERT(WSF_HANDLER_FROM_ID(handlerId) < WSF_MAX_HANDLERS);
WSF_TRACE_INFO2("WsfSetEvent handlerId:%u event:%u", handlerId, event);
WSF_CS_ENTER(cs);
wsfOs.task.handlerEventMask[WSF_HANDLER_FROM_ID(handlerId)] |= event;
wsfOs.task.taskEventMask |= WSF_HANDLER_EVENT;
WSF_CS_EXIT(cs);
/* set event in OS */
WsfSetOsSpecificEvent();
}
/*************************************************************************************************/
/*!
* \fn WsfTaskSetReady
*
* \brief Set the task used by the given handler as ready to run.
*
* \param handlerId Event handler ID.
* \param event Task event mask.
*
* \return None.
*/
/*************************************************************************************************/
void WsfTaskSetReady(wsfHandlerId_t handlerId, wsfTaskEvent_t event)
{
/* Unused parameter */
(void)handlerId;
WSF_CS_INIT(cs);
WSF_CS_ENTER(cs);
wsfOs.task.taskEventMask |= event;
WSF_CS_EXIT(cs);
/* set event in OS */
WsfSetOsSpecificEvent();
}
/*************************************************************************************************/
/*!
* \fn WsfTaskMsgQueue
*
* \brief Return the message queue used by the given handler.
*
* \param handlerId Event handler ID.
*
* \return Task message queue.
*/
/*************************************************************************************************/
wsfQueue_t *WsfTaskMsgQueue(wsfHandlerId_t handlerId)
{
/* Unused parameter */
(void)handlerId;
return &(wsfOs.task.msgQueue);
}
/*************************************************************************************************/
/*!
* \fn WsfOsSetNextHandler
*
* \brief Set the next WSF handler function in the WSF OS handler array. This function
* should only be called as part of the stack initialization procedure.
*
* \param handler WSF handler function.
*
* \return WSF handler ID for this handler.
*/
/*************************************************************************************************/
wsfHandlerId_t WsfOsSetNextHandler(wsfEventHandler_t handler)
{
wsfHandlerId_t handlerId = wsfOs.task.numHandler++;
WSF_ASSERT(handlerId < WSF_MAX_HANDLERS);
wsfOs.task.handler[handlerId] = handler;
return handlerId;
}
/*************************************************************************************************/
/*!
* \fn wsfOsReadyToSleep
*
* \brief Check if WSF is ready to sleep. This function should be called when interrupts
* are disabled.
*
* \param None.
*
* \return Return TRUE if there are no pending WSF task events set, FALSE otherwise.
*/
/*************************************************************************************************/
bool_t wsfOsReadyToSleep(void)
{
return (wsfOs.task.taskEventMask == 0);
}
/*************************************************************************************************/
/*!
* \brief Initialize OS control structure.
*
* \return None.
*/
/*************************************************************************************************/
void WsfOsInit(void)
{
memset(&wsfOs, 0, sizeof(wsfOs));
if( xRadioTaskEventObject == NULL)
{
xRadioTaskEventObject = xEventGroupCreate();
WSF_ASSERT(xRadioTaskEventObject != NULL);
}
}
/*************************************************************************************************/
/*!
* \fn wsfOsDispatcher
*
* \brief Event dispatched. Designed to be called repeatedly from infinite loop.
*
* \param None.
*
* \return None.
*/
/*************************************************************************************************/
void wsfOsDispatcher(void)
{
wsfOsTask_t *pTask;
void *pMsg;
wsfTimer_t *pTimer;
wsfEventMask_t eventMask;
wsfTaskEvent_t taskEventMask;
wsfHandlerId_t handlerId;
uint8_t i;
WSF_CS_INIT(cs);
pTask = &wsfOs.task;
WsfTimerUpdateTicks();
while (pTask->taskEventMask)
{
/* get and then clear task event mask */
WSF_CS_ENTER(cs);
taskEventMask = pTask->taskEventMask;
pTask->taskEventMask = 0;
WSF_CS_EXIT(cs);
if (taskEventMask & WSF_MSG_QUEUE_EVENT)
{
/* handle msg queue */
while ((pMsg = WsfMsgDeq(&pTask->msgQueue, &handlerId)) != NULL)
{
WSF_ASSERT(handlerId < WSF_MAX_HANDLERS);
(*pTask->handler[handlerId])(0, pMsg);
WsfMsgFree(pMsg);
}
}
if (taskEventMask & WSF_TIMER_EVENT)
{
/* service timers */
while ((pTimer = WsfTimerServiceExpired(0)) != NULL)
{
WSF_ASSERT(pTimer->handlerId < WSF_MAX_HANDLERS);
(*pTask->handler[pTimer->handlerId])(0, &pTimer->msg);
}
}
if (taskEventMask & WSF_HANDLER_EVENT)
{
/* service handlers */
for (i = 0; i < WSF_MAX_HANDLERS; i++)
{
if ((pTask->handlerEventMask[i] != 0) && (pTask->handler[i] != NULL))
{
WSF_CS_ENTER(cs);
eventMask = pTask->handlerEventMask[i];
pTask->handlerEventMask[i] = 0;
WSF_CS_EXIT(cs);
(*pTask->handler[i])(eventMask, NULL);
}
}
}
}
xEventGroupWaitBits(xRadioTaskEventObject, 1, pdTRUE,
pdFALSE, portMAX_DELAY);
}
ambiq-hal-sys/ambiq-sparkfun-sdk/third_party/exactle/wsf/sources/port/freertos/wsf_os_int.h
Vendored
+118
View File
@@ -0,0 +1,118 @@
/*************************************************************************************************/
/*!
* \file wsf_os_int.h
*
* \brief Software foundation OS platform-specific interface file.
*
* $Date: 2012-10-01 13:53:07 -0700 (Mon, 01 Oct 2012) $
* $Revision: 357 $
*
* Copyright (c) 2009 Wicentric, Inc., all rights reserved.
* Wicentric confidential and proprietary.
*
* IMPORTANT. Your use of this file is governed by a Software License Agreement
* ("Agreement") that must be accepted in order to download or otherwise receive a
* copy of this file. You may not use or copy this file for any purpose other than
* as described in the Agreement. If you do not agree to all of the terms of the
* Agreement do not use this file and delete all copies in your possession or control;
* if you do not have a copy of the Agreement, you must contact Wicentric, Inc. prior
* to any use, copying or further distribution of this software.
*/
/*************************************************************************************************/
#ifndef WSF_OS_INT_H
#define WSF_OS_INT_H
#ifdef __cplusplus
extern "C" {
#endif
/**************************************************************************************************
Macros
**************************************************************************************************/
/* Task events */
#define WSF_MSG_QUEUE_EVENT 0x01 /* Message queued for event handler */
#define WSF_TIMER_EVENT 0x02 /* Timer expired for event handler */
#define WSF_HANDLER_EVENT 0x04 /* Event set for event handler */
/* Derive task from handler ID */
#define WSF_TASK_FROM_ID(handlerID) (((handlerID) >> 4) & 0x0F)
/* Derive handler from handler ID */
#define WSF_HANDLER_FROM_ID(handlerID) ((handlerID) & 0x0F)
/**************************************************************************************************
Data Types
**************************************************************************************************/
/* Event handler ID data type */
typedef uint8_t wsfHandlerId_t;
/* Event handler event mask data type */
typedef uint8_t wsfEventMask_t;
/* Task ID data type */
typedef wsfHandlerId_t wsfTaskId_t;
/* Task event mask data type */
typedef uint8_t wsfTaskEvent_t;
/**************************************************************************************************
Function Declarations
**************************************************************************************************/
/*************************************************************************************************/
/*!
* \fn wsfOsReadyToSleep
*
* \brief Check if WSF is ready to sleep.
*
* \param None.
*
* \return Return TRUE if there are no pending WSF task events set, FALSE otherwise.
*/
/*************************************************************************************************/
bool_t wsfOsReadyToSleep(void);
/*************************************************************************************************/
/*!
* \fn WsfOsInit
*
* \brief Initialized WsfOs module.
*
* \param None.
*
* \return None.
*/
/*************************************************************************************************/
void WsfOsInit(void);
/*************************************************************************************************/
/*!
* \fn wsfOsDispatcher
*
* \brief Event dispatched. Designed to be called repeatedly from infinite loop.
*
* \param None.
*
* \return None.
*/
/*************************************************************************************************/
void wsfOsDispatcher(void);
/*************************************************************************************************/
/*!
* \fn WsfOsShutdown
*
* \brief Shutdown OS.
*
* \return None.
*/
/*************************************************************************************************/
void WsfOsShutdown(void);
#ifdef __cplusplus
};
#endif
#endif /* WSF_OS_INT_H */
ambiq-hal-sys/ambiq-sparkfun-sdk/third_party/exactle/wsf/sources/port/freertos/wsf_queue.c
Vendored
+329
View File
@@ -0,0 +1,329 @@
/*************************************************************************************************/
/*!
* \file wsf_queue.c
*
* \brief General purpose queue service.
*
* $Date: 2017-01-06 13:47:48 -0600 (Fri, 06 Jan 2017) $
* $Revision: 10864 $
*
* Copyright (c) 2009-2017 ARM Ltd., all rights reserved.
* ARM Ltd. confidential and proprietary.
*
* IMPORTANT. Your use of this file is governed by a Software License Agreement
* ("Agreement") that must be accepted in order to download or otherwise receive a
* copy of this file. You may not use or copy this file for any purpose other than
* as described in the Agreement. If you do not agree to all of the terms of the
* Agreement do not use this file and delete all copies in your possession or control;
* if you do not have a copy of the Agreement, you must contact ARM Ltd. prior
* to any use, copying or further distribution of this software.
*/
/*************************************************************************************************/
#include "wsf_types.h"
#include "wsf_queue.h"
#include "wsf_assert.h"
#include "wsf_cs.h"
/**************************************************************************************************
Macros
**************************************************************************************************/
/* Get next queue element */
#define WSF_QUEUE_NEXT(p) (((wsfQueueElem_t *)(p))->pNext)
/**************************************************************************************************
Data Types
**************************************************************************************************/
/* Queue element */
typedef struct wsfQueueElem_tag
{
struct wsfQueueElem_tag *pNext; /* pointer to next element */
} wsfQueueElem_t;
/*************************************************************************************************/
/*!
* \fn WsfQueueEnq
*
* \brief Enqueue and element to the tail of a queue.
*
* \param pQueue Pointer to queue.
* \param pElem Pointer to element.
*
* \return None.
*/
/*************************************************************************************************/
void WsfQueueEnq(wsfQueue_t *pQueue, void *pElem)
{
WSF_CS_INIT(cs);
WSF_ASSERT(pQueue != NULL);
WSF_ASSERT(pElem != NULL);
/* initialize next pointer */
WSF_QUEUE_NEXT(pElem) = NULL;
/* enter critical section */
WSF_CS_ENTER(cs);
/* if queue empty */
if (pQueue->pHead == NULL)
{
pQueue->pHead = pElem;
pQueue->pTail = pElem;
}
/* else enqueue element to the tail of queue */
else
{
WSF_QUEUE_NEXT(pQueue->pTail) = pElem;
pQueue->pTail = pElem;
}
/* exit critical section */
WSF_CS_EXIT(cs);
}
/*************************************************************************************************/
/*!
* \fn WsfQueueDeq
*
* \brief Dequeue and element from the head of a queue.
*
* \param pQueue Pointer to queue.
*
* \return Pointer to element that has been dequeued or NULL if queue is empty.
*/
/*************************************************************************************************/
void *WsfQueueDeq(wsfQueue_t *pQueue)
{
wsfQueueElem_t *pElem;
WSF_CS_INIT(cs);
WSF_ASSERT(pQueue != NULL);
/* enter critical section */
WSF_CS_ENTER(cs);
pElem = pQueue->pHead;
/* if queue is not empty */
if (pElem != NULL)
{
/* set head to next element in queue */
pQueue->pHead = WSF_QUEUE_NEXT(pElem);
/* check for empty queue */
if (pQueue->pHead == NULL)
{
pQueue->pTail = NULL;
}
}
/* exit critical section */
WSF_CS_EXIT(cs);
return pElem;
}
/*************************************************************************************************/
/*!
* \fn WsfQueuePush
*
* \brief Push and element to the head of a queue.
*
* \param pQueue Pointer to queue.
* \param pElem Pointer to element.
*
* \return None.
*/
/*************************************************************************************************/
void WsfQueuePush(wsfQueue_t *pQueue, void *pElem)
{
WSF_CS_INIT(cs);
WSF_ASSERT(pQueue != NULL);
WSF_ASSERT(pElem != NULL);
/* enter critical section */
WSF_CS_ENTER(cs);
/* else push element to head of queue */
WSF_QUEUE_NEXT(pElem) = pQueue->pHead;
/* if queue was empty set tail */
if (pQueue->pHead == NULL)
{
pQueue->pTail = pElem;
}
/* set head */
pQueue->pHead = pElem;
/* exit critical section */
WSF_CS_EXIT(cs);
}
/*************************************************************************************************/
/*!
* \fn WsfQueueInsert
*
* \brief Insert an element into a queue. This function is typically used when iterating
* over a queue.
*
* \param pQueue Pointer to queue.
* \param pElem Pointer to element to be inserted.
* \param pPrev Pointer to previous element in the queue before element to be inserted.
* Note: set pPrev to NULL if pElem is first element in queue.
* \return None.
*/
/*************************************************************************************************/
void WsfQueueInsert(wsfQueue_t *pQueue, void *pElem, void *pPrev)
{
WSF_CS_INIT(cs);
WSF_ASSERT(pQueue != NULL);
WSF_ASSERT(pElem != NULL);
/* enter critical section */
WSF_CS_ENTER(cs);
/* if queue empty or inserting at tail */
if (pQueue->pHead == NULL || pPrev == pQueue->pTail)
{
/* queue as normal */
WsfQueueEnq(pQueue, pElem);
}
/* else if inserting at head */
else if (pPrev == NULL)
{
/* push to head */
WsfQueuePush(pQueue, pElem);
}
else
{
/* insert in middle of queue */
WSF_QUEUE_NEXT(pElem) = WSF_QUEUE_NEXT(pPrev);
WSF_QUEUE_NEXT(pPrev) = pElem;
}
/* exit critical section */
WSF_CS_EXIT(cs);
}
/*************************************************************************************************/
/*!
* \fn WsfQueueRemove
*
* \brief Remove an element from a queue. This function is typically used when iterating
* over a queue.
*
* \param pQueue Pointer to queue.
* \param pElem Pointer to element to be removed.
* \param pPrev Pointer to previous element in the queue before element to be removed.
* Note: set pPrev to NULL if pElem is first element in queue.
* \return None.
*/
/*************************************************************************************************/
void WsfQueueRemove(wsfQueue_t *pQueue, void *pElem, void *pPrev)
{
WSF_CS_INIT(cs);
WSF_ASSERT(pQueue != NULL);
WSF_ASSERT(pQueue->pHead != NULL);
WSF_ASSERT(pElem != NULL);
/* enter critical section */
WSF_CS_ENTER(cs);
/* if first element */
if (pElem == pQueue->pHead)
{
/* remove from head of queue */
pQueue->pHead = WSF_QUEUE_NEXT(pElem);
}
else if (pPrev)
{
/* remove from middle of queue, pPrev will never be null */
WSF_QUEUE_NEXT(pPrev) = WSF_QUEUE_NEXT(pElem);
}
/* if last element */
if (pElem == pQueue->pTail)
{
/* update tail */
pQueue->pTail = pPrev;
}
/* exit critical section */
WSF_CS_EXIT(cs);
}
/*************************************************************************************************/
/*!
* \fn WsfQueueCount
*
* \brief Count the number of elements in a queue.
*
* \param pQueue Pointer to queue.
*
* \return Number of elements in queue.
*/
/*************************************************************************************************/
uint16_t WsfQueueCount(wsfQueue_t *pQueue)
{
wsfQueueElem_t *pElem;
uint16_t count = 0;
WSF_CS_INIT(cs);
WSF_ASSERT(pQueue != NULL);
/* enter critical section */
WSF_CS_ENTER(cs);
pElem = pQueue->pHead;
/* iterate over queue */
while (pElem != NULL)
{
count++;
pElem = pElem->pNext;
}
/* exit critical section */
WSF_CS_EXIT(cs);
return count;
}
/*************************************************************************************************/
/*!
* \fn WsfQueueEmpty
*
* \brief Return TRUE if queue is empty.
*
* \param pQueue Pointer to queue.
*
* \return TRUE if queue is empty, FALSE otherwise.
*/
/*************************************************************************************************/
bool_t WsfQueueEmpty(wsfQueue_t *pQueue)
{
bool_t empty;
WSF_CS_INIT(cs);
WSF_ASSERT(pQueue != NULL);
/* enter critical section */
WSF_CS_ENTER(cs);
empty = (pQueue->pHead == NULL);
/* exit critical section */
WSF_CS_EXIT(cs);
return empty;
}
ambiq-hal-sys/ambiq-sparkfun-sdk/third_party/exactle/wsf/sources/port/freertos/wsf_timer.c
Vendored
+407
View File
@@ -0,0 +1,407 @@
/*************************************************************************************************/
/*!
* \file wsf_timer.c
*
* \brief Timer service.
*
* $Date: 2016-12-28 16:12:14 -0600 (Wed, 28 Dec 2016) $
* $Revision: 10805 $
*
* Copyright (c) 2009-2017 ARM Ltd., all rights reserved.
* ARM Ltd. confidential and proprietary.
*
* IMPORTANT. Your use of this file is governed by a Software License Agreement
* ("Agreement") that must be accepted in order to download or otherwise receive a
* copy of this file. You may not use or copy this file for any purpose other than
* as described in the Agreement. If you do not agree to all of the terms of the
* Agreement do not use this file and delete all copies in your possession or control;
* if you do not have a copy of the Agreement, you must contact ARM Ltd. prior
* to any use, copying or further distribution of this software.
*/
/*************************************************************************************************/
#include "wsf_types.h"
#include "wsf_queue.h"
#include "wsf_timer.h"
#include "wsf_assert.h"
#include "wsf_trace.h"
#include "FreeRTOS.h"
#include "timers.h"
/**************************************************************************************************
Macros
**************************************************************************************************/
/* convert seconds to timer ticks */
#define WSF_TIMER_SEC_TO_TICKS(sec) ((1000 / WSF_MS_PER_TICK) * (sec))
/* convert milliseconds to timer ticks */
#define WSF_TIMER_MS_TO_TICKS(ms) ((ms) / WSF_MS_PER_TICK)
#define CLK_TICKS_PER_WSF_TICKS (WSF_MS_PER_TICK*configTICK_RATE_HZ/1000)
/**************************************************************************************************
Global Variables
**************************************************************************************************/
wsfQueue_t wsfTimerTimerQueue; /*!< Timer queue */
TimerHandle_t xWsfTimer;
static uint32_t g_ui32LastTime = 0;
/*************************************************************************************************/
/*!
* \fn wsfTimerRemove
*
* \brief Remove a timer from queue. Note this function does not lock task scheduling.
*
* \param pTimer Pointer to timer.
*
* \return None.
*/
/*************************************************************************************************/
static void wsfTimerRemove(wsfTimer_t *pTimer)
{
wsfTimer_t *pElem;
wsfTimer_t *pPrev = NULL;
pElem = (wsfTimer_t *) wsfTimerTimerQueue.pHead;
/* find timer in queue */
while (pElem != NULL)
{
if (pElem == pTimer)
{
break;
}
pPrev = pElem;
pElem = pElem->pNext;
}
/* if timer found remove from queue */
if (pElem != NULL)
{
WsfQueueRemove(&wsfTimerTimerQueue, pTimer, pPrev);
pTimer->isStarted = FALSE;
}
}
/*************************************************************************************************/
/*!
* \fn wsfTimerInsert
*
* \brief Insert a timer into the queue sorted by the timer expiration.
*
* \param pTimer Pointer to timer.
* \param ticks Timer ticks until expiration.
*
* \return None.
*/
/*************************************************************************************************/
static void wsfTimerInsert(wsfTimer_t *pTimer, wsfTimerTicks_t ticks)
{
wsfTimer_t *pElem;
wsfTimer_t *pPrev = NULL;
/* task schedule lock */
WsfTaskLock();
/* if timer is already running stop it first */
if (pTimer->isStarted)
{
wsfTimerRemove(pTimer);
}
pTimer->isStarted = TRUE;
pTimer->ticks = ticks;
pElem = (wsfTimer_t *) wsfTimerTimerQueue.pHead;
/* find insertion point in queue */
while (pElem != NULL)
{
if (pTimer->ticks < pElem->ticks)
{
break;
}
pPrev = pElem;
pElem = pElem->pNext;
}
/* insert timer into queue */
WsfQueueInsert(&wsfTimerTimerQueue, pTimer, pPrev);
/* task schedule unlock */
WsfTaskUnlock();
}
static void WsfTimer_handler(TimerHandle_t xTimer)
{
WsfTaskSetReady(0, WSF_TIMER_EVENT);
}
/*************************************************************************************************/
/*!
* \fn WsfTimerInit
*
* \brief Initialize the timer service. This function should only be called once
* upon system initialization.
*
* \return None.
*/
/*************************************************************************************************/
void WsfTimerInit(void)
{
WSF_QUEUE_INIT(&wsfTimerTimerQueue);
if(xWsfTimer == NULL)
{
xWsfTimer = xTimerCreate("WSF Timer", pdMS_TO_TICKS(WSF_MS_PER_TICK),
pdFALSE, NULL, WsfTimer_handler);
configASSERT(xWsfTimer);
}
}
/*************************************************************************************************/
/*!
* \fn WsfTimerStartSec
*
* \brief Start a timer in units of seconds.
*
* \param pTimer Pointer to timer.
* \param sec Seconds until expiration.
*
* \return None.
*/
/*************************************************************************************************/
void WsfTimerStartSec(wsfTimer_t *pTimer, wsfTimerTicks_t sec)
{
WSF_TRACE_INFO2("WsfTimerStartSec pTimer:0x%x ticks:%u", (uint32_t)pTimer, WSF_TIMER_SEC_TO_TICKS(sec));
/* insert timer into queue */
wsfTimerInsert(pTimer, WSF_TIMER_SEC_TO_TICKS(sec));
}
/*************************************************************************************************/
/*!
* \fn WsfTimerStartMs
*
* \brief Start a timer in units of milliseconds.
*
* \param pTimer Pointer to timer.
* \param ms Milliseconds until expiration.
*
* \return None.
*/
/*************************************************************************************************/
void WsfTimerStartMs(wsfTimer_t *pTimer, wsfTimerTicks_t ms)
{
WSF_TRACE_INFO2("WsfTimerStartMs pTimer:0x%x ticks:%u", (uint32_t)pTimer, WSF_TIMER_MS_TO_TICKS(ms));
/* insert timer into queue */
wsfTimerInsert(pTimer, WSF_TIMER_MS_TO_TICKS(ms));
}
/*************************************************************************************************/
/*!
* \fn WsfTimerStop
*
* \brief Stop a timer.
*
* \param pTimer Pointer to timer.
*
* \return None.
*/
/*************************************************************************************************/
void WsfTimerStop(wsfTimer_t *pTimer)
{
WSF_TRACE_INFO1("WsfTimerStop pTimer:0x%x", pTimer);
/* task schedule lock */
WsfTaskLock();
wsfTimerRemove(pTimer);
/* task schedule unlock */
WsfTaskUnlock();
}
/*************************************************************************************************/
/*!
* \fn WsfTimerUpdate
*
* \brief Update the timer service with the number of elapsed ticks.
*
* \param ticks Number of ticks since last update.
*
* \return None.
*/
/*************************************************************************************************/
void WsfTimerUpdate(wsfTimerTicks_t ticks)
{
wsfTimer_t *pElem;
/* task schedule lock */
WsfTaskLock();
pElem = (wsfTimer_t *) wsfTimerTimerQueue.pHead;
/* iterate over timer queue */
while (pElem != NULL)
{
/* decrement ticks while preventing underflow */
if (pElem->ticks > ticks)
{
pElem->ticks -= ticks;
}
else
{
pElem->ticks = 0;
/* timer expired; set task for this timer as ready */
WsfTaskSetReady(pElem->handlerId, WSF_TIMER_EVENT);
}
pElem = pElem->pNext;
}
/* task schedule unlock */
WsfTaskUnlock();
}
/*************************************************************************************************/
/*!
* \fn WsfTimerNextExpiration
*
* \brief Return the number of ticks until the next timer expiration. Note that this
* function can return zero even if a timer is running, indicating a timer
* has expired but has not yet been serviced.
*
* \param pTimerRunning Returns TRUE if a timer is running, FALSE if no timers running.
*
* \return The number of ticks until the next timer expiration.
*/
/*************************************************************************************************/
wsfTimerTicks_t WsfTimerNextExpiration(bool_t *pTimerRunning)
{
wsfTimerTicks_t ticks;
/* task schedule lock */
WsfTaskLock();
if (wsfTimerTimerQueue.pHead == NULL)
{
*pTimerRunning = FALSE;
ticks = 0;
}
else
{
*pTimerRunning = TRUE;
ticks = ((wsfTimer_t *) wsfTimerTimerQueue.pHead)->ticks;
}
/* task schedule unlock */
WsfTaskUnlock();
return ticks;
}
/*************************************************************************************************/
/*!
* \fn WsfTimerServiceExpired
*
* \brief Service expired timers for the given task.
*
* \param taskId Task ID.
*
* \return Pointer to timer or NULL.
*/
/*************************************************************************************************/
wsfTimer_t *WsfTimerServiceExpired(wsfTaskId_t taskId)
{
wsfTimer_t *pElem;
wsfTimer_t *pPrev = NULL;
/* Unused parameters */
(void)taskId;
/* task schedule lock */
WsfTaskLock();
/* find expired timers in queue */
if (((pElem = (wsfTimer_t *) wsfTimerTimerQueue.pHead) != NULL) &&
(pElem->ticks == 0))
{
/* remove timer from queue */
WsfQueueRemove(&wsfTimerTimerQueue, pElem, pPrev);
pElem->isStarted = FALSE;
/* task schedule unlock */
WsfTaskUnlock();
WSF_TRACE_INFO1("Timer expired pTimer:0x%x", pElem);
/* return timer */
return pElem;
}
/* task schedule unlock */
WsfTaskUnlock();
return NULL;
}
//*****************************************************************************
//
// Calculate the elapsed time, and update the WSF software timers.
//
//*****************************************************************************
void WsfTimerUpdateTicks(void)
{
uint32_t ui32CurrentTime, ui32ElapsedTime;
bool_t bTimerRunning;
wsfTimerTicks_t xNextExpiration;
//
// Read the continuous timer.
//
ui32CurrentTime = xTaskGetTickCount();
//
// Figure out how long it has been since the last time we've read the
// continuous timer. We should be reading often enough that we'll never
// have more than one overflow.
//
ui32ElapsedTime = ui32CurrentTime - g_ui32LastTime;
//
// Check to see if any WSF ticks need to happen.
//
if ( (ui32ElapsedTime / CLK_TICKS_PER_WSF_TICKS) > 0 )
{
//
// Update the WSF timers and save the current time as our "last
// update".
//
WsfTimerUpdate(ui32ElapsedTime / CLK_TICKS_PER_WSF_TICKS);
g_ui32LastTime = ui32CurrentTime;
}
//
// Check to see when the next timer expiration should happen.
//
xNextExpiration = WsfTimerNextExpiration(&bTimerRunning);
//
// If there's a pending WSF timer event, set an interrupt to wake us up in
// time to service it.
//
if ( xNextExpiration )
{
configASSERT(pdPASS == xTimerChangePeriod( xWsfTimer,
pdMS_TO_TICKS(xNextExpiration*CLK_TICKS_PER_WSF_TICKS), 100)) ;
}
}
ambiq-hal-sys/ambiq-sparkfun-sdk/third_party/exactle/wsf/sources/port/freertos/wsf_trace.c
Vendored
+219
View File
@@ -0,0 +1,219 @@
/*************************************************************************************************/
/*!
* \file wsf_trace.c
*
* \brief Trace message implementation.
*
* $Date: 2014-08-06 15:13:15 -0700 (Wed, 06 Aug 2014) $
* $Revision: 1708 $
*
* Copyright (c) 2009 Wicentric, Inc., all rights reserved.
* Wicentric confidential and proprietary.
*
* IMPORTANT. Your use of this file is governed by a Software License Agreement
* ("Agreement") that must be accepted in order to download or otherwise receive a
* copy of this file. You may not use or copy this file for any purpose other than
* as described in the Agreement. If you do not agree to all of the terms of the
* Agreement do not use this file and delete all copies in your possession or control;
* if you do not have a copy of the Agreement, you must contact Wicentric, Inc. prior
* to any use, copying or further distribution of this software.
*/
/*************************************************************************************************/
#include "wsf_types.h"
#include "wsf_trace.h"
#include "wsf_assert.h"
#include "wsf_cs.h"
#include <string.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdbool.h>
#include "am_util_debug.h"
#include "am_util_stdio.h"
/**************************************************************************************************
Macros
**************************************************************************************************/
#ifndef WSF_RING_BUF_SIZE
/*! \brief Size of token ring buffer (multiple of 2^N). */
#define WSF_RING_BUF_SIZE 32
#endif
/*! \brief Ring buffer flow control condition detected. */
#define WSF_TOKEN_FLAG_FLOW_CTRL (1 << 28)
/**************************************************************************************************
Data types
**************************************************************************************************/
#if WSF_TOKEN_ENABLED
/*! \brief Trace control block. */
struct
{
struct
{
uint32_t token; /*!< Token. */
uint32_t param; /*!< Parameter. */
} ringBuf[WSF_RING_BUF_SIZE]; /*!< Tokenized tracing ring buffer. */
volatile uint32_t prodIdx; /*!< Ring buffer producer index. */
volatile uint32_t consIdx; /*!< Ring buffer consumer index. */
WsfTokenHandler_t pendCback; /*!< Pending event handler. */
bool_t ringBufEmpty; /*!< Ring buffer state. */
} wsfTraceCb;
#endif
#if WSF_TRACE_ENABLED == TRUE
/*************************************************************************************************/
/*!
* \fn WsfPacketTrace
*
* \brief Print raw HCI data as a trace message.
*
* \param ui8Type HCI packet type byte
* \param ui32Len Length of the HCI packet
* \param pui8Buf Pointer to the buffer of HCI data
*
* \return None.
*/
/*************************************************************************************************/
void WsfPacketTrace(uint8_t ui8Type, uint32_t ui32Len, uint8_t *pui8Buf)
{
uint32_t i;
am_util_debug_printf("%02X ", ui8Type);
for(i = 0; i < ui32Len; i++)
{
if ((i % 8) == 0)
{
am_util_debug_printf("\n");
}
am_util_debug_printf("%02X ", *pui8Buf++);
}
am_util_debug_printf("\n\n");
}
/*************************************************************************************************/
/*!
* \fn WsfTrace
*
* \brief Print a trace message.
*
* \param pStr Message format string
* \param ... Additional aguments, printf-style
*
* \return None.
*/
/*************************************************************************************************/
void WsfTrace(const char *pStr, ...)
{
char pTraceMsg[AM_PRINTF_BUFSIZE];
uint32_t ui32NumChars;
va_list args;
va_start(args, pStr);
am_util_stdio_vsprintf(pTraceMsg, pStr, args);
//vprintf(pStr, args);
va_end(args);
ui32NumChars = am_util_debug_printf(pTraceMsg);
if (!(ui32NumChars < AM_PRINTF_BUFSIZE))
WsfAssert(__FILE__, (uint16_t) __LINE__);
am_util_debug_printf("\n");
}
#elif WSF_TOKEN_ENABLED == TRUE
/*************************************************************************************************/
/*!
* \fn WsfToken
*
* \brief Output tokenized message.
*
* \param tok Token
* \param var Variable
*
* \return None.
*/
/*************************************************************************************************/
void WsfToken(uint32_t tok, uint32_t var)
{
static uint32_t flags = 0;
WSF_CS_INIT(cs);
WSF_CS_ENTER(cs);
uint32_t prodIdx = (wsfTraceCb.prodIdx + 1) & (WSF_RING_BUF_SIZE - 1);
if (prodIdx != wsfTraceCb.consIdx)
{
wsfTraceCb.ringBuf[wsfTraceCb.prodIdx].token = tok | flags;
wsfTraceCb.ringBuf[wsfTraceCb.prodIdx].param = var;
wsfTraceCb.prodIdx = prodIdx;
flags = 0;
}
else
{
flags = WSF_TOKEN_FLAG_FLOW_CTRL;
}
WSF_CS_EXIT(cs);
if (wsfTraceCb.pendCback && wsfTraceCb.ringBufEmpty)
{
wsfTraceCb.ringBufEmpty = FALSE;
wsfTraceCb.pendCback();
}
}
/*************************************************************************************************/
/*!
* \fn wsfTokenService
*
* \brief Service the trace ring buffer.
*
* \return TRUE if trace messages pending, FALSE otherwise.
*
* This routine is called in the main loop for a "push" type trace systems.
*/
/*************************************************************************************************/
bool_t WsfTokenService(void)
{
static uint8_t outBuf[sizeof(wsfTraceCb.ringBuf[0])];
static uint8_t outBufIdx = sizeof(wsfTraceCb.ringBuf[0]);
if (outBufIdx < sizeof(wsfTraceCb.ringBuf[0]))
{
outBufIdx += WsfTokenIOWrite(outBuf + outBufIdx, sizeof(wsfTraceCb.ringBuf[0]) - outBufIdx);
if (outBufIdx < sizeof(wsfTraceCb.ringBuf[0]))
{
/* I/O device is flow controlled. */
return TRUE;
}
}
if (wsfTraceCb.consIdx != wsfTraceCb.prodIdx)
{
memcpy(&outBuf, &wsfTraceCb.ringBuf[wsfTraceCb.consIdx], sizeof(wsfTraceCb.ringBuf[0]));
outBufIdx = 0;
wsfTraceCb.consIdx = (wsfTraceCb.consIdx + 1) & (WSF_RING_BUF_SIZE - 1);
return TRUE;
}
return FALSE;
}
#endif
ambiq-hal-sys/ambiq-sparkfun-sdk/third_party/exactle/wsf/sources/port/freertos/wsf_trace.h
Vendored
+252
View File
@@ -0,0 +1,252 @@
/*************************************************************************************************/
/*!
* \file wsf_trace.h
*
* \brief Trace message interface.
*
* $Date: 2015-08-11 07:08:51 -0700 (Tue, 11 Aug 2015) $
* $Revision: 3555 $
*
* Copyright (c) 2009 Wicentric, Inc., all rights reserved.
* Wicentric confidential and proprietary.
*
* IMPORTANT. Your use of this file is governed by a Software License Agreement
* ("Agreement") that must be accepted in order to download or otherwise receive a
* copy of this file. You may not use or copy this file for any purpose other than
* as described in the Agreement. If you do not agree to all of the terms of the
* Agreement do not use this file and delete all copies in your possession or control;
* if you do not have a copy of the Agreement, you must contact Wicentric, Inc. prior
* to any use, copying or further distribution of this software.
*/
/*************************************************************************************************/
#ifndef WSF_TRACE_H
#define WSF_TRACE_H
/**************************************************************************************************
Data Types
**************************************************************************************************/
/*! \brief Token event handler. */
typedef void (*WsfTokenHandler_t)(void);
/**************************************************************************************************
Function Prototypes
**************************************************************************************************/
void WsfTrace(const char *pStr, ...);
void WsfToken(uint32_t tok, uint32_t var);
void WsfPacketTrace(uint8_t ui8Type, uint32_t ui32Len, uint8_t *pui8Buf);
/* Token management. */
bool_t WsfTokenService(void);
uint8_t WsfTokenIOWrite(uint8_t *pBuf, uint8_t len);
/**************************************************************************************************
Macros
**************************************************************************************************/
#ifdef WSF_TRACE_ENABLED
#ifndef AM_DEBUG_PRINTF
#undef WSF_TRACE_ENABLED
#warning "AM_DEBUG_PRINTF is needed when WSF_TRACE_ENABLED is defined"
#endif
#endif
#ifdef TOKEN_GENERATION
#define WSF_TOKEN(subsys, stat, msg) \
__WSF_TOKEN_DEFINE__( \
/* token: */ MODULE_ID, __LINE__, \
/* origin: */ __FILE__, subsys, \
/* message: */ stat, msg)
#define WSF_TRACE0(subsys, stat, msg) WSF_TOKEN(subsys, stat, msg)
#define WSF_TRACE1(subsys, stat, msg, var1) WSF_TOKEN(subsys, stat, msg)
#define WSF_TRACE2(subsys, stat, msg, var1, var2) WSF_TOKEN(subsys, stat, msg)
#define WSF_TRACE3(subsys, stat, msg, var1, var2, var3) WSF_TOKEN(subsys, stat, msg)
#define PACKET_TRACE(type, len, buf)
#elif WSF_TRACE_ENABLED == TRUE
#define WSF_TRACE0(subsys, stat, msg) WsfTrace(msg)
#define WSF_TRACE1(subsys, stat, msg, var1) WsfTrace(msg, var1)
#define WSF_TRACE2(subsys, stat, msg, var1, var2) WsfTrace(msg, var1, var2)
#define WSF_TRACE3(subsys, stat, msg, var1, var2, var3) WsfTrace(msg, var1, var2, var3)
#define PACKET_TRACE(type, len, buf) WsfPacketTrace(type, len, buf)
#elif WSF_TOKEN_ENABLED == TRUE
#define WSF_TRACE0(subsys, stat, msg) \
WsfToken(((__LINE__ & 0xFFF) << 16) | MODULE_ID, 0)
#define WSF_TRACE1(subsys, stat, msg, var1) \
WsfToken(((__LINE__ & 0xFFF) << 16) | MODULE_ID, (uint32_t)(var1))
#define WSF_TRACE2(subsys, stat, msg, var1, var2) \
WsfToken(((__LINE__ & 0xFFF) << 16) | MODULE_ID, (uint32_t)(((var2) << 16) | ((var1) & 0xFFFF)))
#define WSF_TRACE3(subsys, stat, msg, var1, var2, var3) \
WsfToken(((__LINE__ & 0xFFF) << 16) | MODULE_ID, (uint32_t)((((var3) & 0xFF) << 16) | (((var2) & 0xFF) << 8) | ((var1) & 0xFF)))
#define PACKET_TRACE(type, len, buf)
#else
#define WSF_TRACE0(subsys, stat, msg)
#define WSF_TRACE1(subsys, stat, msg, var1)
#define WSF_TRACE2(subsys, stat, msg, var1, var2)
#define WSF_TRACE3(subsys, stat, msg, var1, var2, var3)
#define PACKET_TRACE(type, len, buf)
#endif
#define WSF_TRACE_INFO0(msg)
#define WSF_TRACE_INFO1(msg, var1)
#define WSF_TRACE_INFO2(msg, var1, var2)
#define WSF_TRACE_INFO3(msg, var1, var2, var3)
#define WSF_TRACE_WARN0(msg) WSF_TRACE0("WSF", "WARN", msg)
#define WSF_TRACE_WARN1(msg, var1) WSF_TRACE1("WSF", "WARN", msg, var1)
#define WSF_TRACE_WARN2(msg, var1, var2) WSF_TRACE2("WSF", "WARN", msg, var1, var2)
#define WSF_TRACE_WARN3(msg, var1, var2, var3) WSF_TRACE3("WSF", "WARN", msg, var1, var2, var3)
#define WSF_TRACE_ERR0(msg) WSF_TRACE0("WSF", "ERR", msg)
#define WSF_TRACE_ERR1(msg, var1) WSF_TRACE1("WSF", "ERR", msg, var1)
#define WSF_TRACE_ERR2(msg, var1, var2) WSF_TRACE2("WSF", "ERR", msg, var1, var2)
#define WSF_TRACE_ERR3(msg, var1, var2, var3) WSF_TRACE3("WSF", "ERR", msg, var1, var2, var3)
#define WSF_TRACE_ALLOC0(msg)
#define WSF_TRACE_ALLOC1(msg, var1)
#define WSF_TRACE_ALLOC2(msg, var1, var2)
#define WSF_TRACE_ALLOC3(msg, var1, var2, var3)
#define WSF_TRACE_FREE0(msg)
#define WSF_TRACE_FREE1(msg, var1)
#define WSF_TRACE_FREE2(msg, var1, var2)
#define WSF_TRACE_FREE3(msg, var1, var2, var3)
#define WSF_TRACE_MSG0(msg)
#define WSF_TRACE_MSG1(msg, var1)
#define WSF_TRACE_MSG2(msg, var1, var2)
#define WSF_TRACE_MSG3(msg, var1, var2, var3)
#ifdef HCI_TRACE_ENABLED
#define HCI_TRACE_INFO0(msg) WSF_TRACE0("HCI", "INFO", msg)
#define HCI_TRACE_INFO1(msg, var1) WSF_TRACE1("HCI", "INFO", msg, var1)
#define HCI_TRACE_INFO2(msg, var1, var2) WSF_TRACE2("HCI", "INFO", msg, var1, var2)
#define HCI_TRACE_INFO3(msg, var1, var2, var3) WSF_TRACE3("HCI", "INFO", msg, var1, var2, var3)
#define HCI_TRACE_WARN0(msg) WSF_TRACE0("HCI", "WARN", msg)
#define HCI_TRACE_WARN1(msg, var1) WSF_TRACE1("HCI", "WARN", msg, var1)
#define HCI_TRACE_WARN2(msg, var1, var2) WSF_TRACE2("HCI", "WARN", msg, var1, var2)
#define HCI_TRACE_WARN3(msg, var1, var2, var3) WSF_TRACE3("HCI", "WARN", msg, var1, var2, var3)
#define HCI_TRACE_ERR0(msg) WSF_TRACE0("HCI", "ERR", msg)
#define HCI_TRACE_ERR1(msg, var1) WSF_TRACE1("HCI", "ERR", msg, var1)
#define HCI_TRACE_ERR2(msg, var1, var2) WSF_TRACE2("HCI", "ERR", msg, var1, var2)
#define HCI_TRACE_ERR3(msg, var1, var2, var3) WSF_TRACE3("HCI", "ERR", msg, var1, var2, var3)
#define HCI_PDUMP_CMD(len, pBuf) PACKET_TRACE(0x1, len, pBuf)
#define HCI_PDUMP_EVT(len, pBuf) PACKET_TRACE(0x4, len, pBuf)
#define HCI_PDUMP_TX_ACL(len, pBuf) PACKET_TRACE(0x2, len, pBuf)
#define HCI_PDUMP_RX_ACL(len, pBuf) PACKET_TRACE(0x2, len, pBuf)
#else
#define HCI_TRACE_INFO0(msg)
#define HCI_TRACE_INFO1(msg, var1)
#define HCI_TRACE_INFO2(msg, var1, var2)
#define HCI_TRACE_INFO3(msg, var1, var2, var3)
#define HCI_TRACE_WARN0(msg)
#define HCI_TRACE_WARN1(msg, var1)
#define HCI_TRACE_WARN2(msg, var1, var2)
#define HCI_TRACE_WARN3(msg, var1, var2, var3)
#define HCI_TRACE_ERR0(msg)
#define HCI_TRACE_ERR1(msg, var1)
#define HCI_TRACE_ERR2(msg, var1, var2)
#define HCI_TRACE_ERR3(msg, var1, var2, var3)
#define HCI_PDUMP_CMD(len, pBuf)
#define HCI_PDUMP_EVT(len, pBuf)
#define HCI_PDUMP_TX_ACL(len, pBuf)
#define HCI_PDUMP_RX_ACL(len, pBuf)
#endif //HCI_TRACE_ENABLED
#define DM_TRACE_INFO0(msg) WSF_TRACE0("DM", "INFO", msg)
#define DM_TRACE_INFO1(msg, var1) WSF_TRACE1("DM", "INFO", msg, var1)
#define DM_TRACE_INFO2(msg, var1, var2) WSF_TRACE2("DM", "INFO", msg, var1, var2)
#define DM_TRACE_INFO3(msg, var1, var2, var3) WSF_TRACE3("DM", "INFO", msg, var1, var2, var3)
#define DM_TRACE_WARN0(msg) WSF_TRACE0("DM", "WARN", msg)
#define DM_TRACE_WARN1(msg, var1) WSF_TRACE1("DM", "WARN", msg, var1)
#define DM_TRACE_WARN2(msg, var1, var2) WSF_TRACE2("DM", "WARN", msg, var1, var2)
#define DM_TRACE_WARN3(msg, var1, var2, var3) WSF_TRACE3("DM", "WARN", msg, var1, var2, var3)
#define DM_TRACE_ERR0(msg) WSF_TRACE0("DM", "ERR", msg)
#define DM_TRACE_ERR1(msg, var1) WSF_TRACE1("DM", "ERR", msg, var1)
#define DM_TRACE_ERR2(msg, var1, var2) WSF_TRACE2("DM", "ERR", msg, var1, var2)
#define DM_TRACE_ERR3(msg, var1, var2, var3) WSF_TRACE3("DM", "ERR", msg, var1, var2, var3)
#define DM_TRACE_ALLOC0(msg) WSF_TRACE0("DM", "ALLOC", msg)
#define DM_TRACE_ALLOC1(msg, var1) WSF_TRACE1("DM", "ALLOC", msg, var1)
#define DM_TRACE_ALLOC2(msg, var1, var2) WSF_TRACE2("DM", "ALLOC", msg, var1, var2)
#define DM_TRACE_ALLOC3(msg, var1, var2, var3) WSF_TRACE3("DM", "ALLOC", msg, var1, var2, var3)
#define DM_TRACE_FREE0(msg) WSF_TRACE0("DM", "FREE", msg)
#define DM_TRACE_FREE1(msg, var1) WSF_TRACE1("DM", "FREE", msg, var1)
#define DM_TRACE_FREE2(msg, var1, var2) WSF_TRACE2("DM", "FREE", msg, var1, var2)
#define DM_TRACE_FREE3(msg, var1, var2, var3) WSF_TRACE3("DM", "FREE", msg, var1, var2, var3)
#define L2C_TRACE_INFO0(msg) WSF_TRACE0("L2C", "INFO", msg)
#define L2C_TRACE_INFO1(msg, var1) WSF_TRACE1("L2C", "INFO", msg, var1)
#define L2C_TRACE_INFO2(msg, var1, var2) WSF_TRACE2("L2C", "INFO", msg, var1, var2)
#define L2C_TRACE_INFO3(msg, var1, var2, var3) WSF_TRACE3("L2C", "INFO", msg, var1, var2, var3)
#define L2C_TRACE_WARN0(msg) WSF_TRACE0("L2C", "WARN", msg)
#define L2C_TRACE_WARN1(msg, var1) WSF_TRACE1("L2C", "WARN", msg, var1)
#define L2C_TRACE_WARN2(msg, var1, var2) WSF_TRACE2("L2C", "WARN", msg, var1, var2)
#define L2C_TRACE_WARN3(msg, var1, var2, var3) WSF_TRACE3("L2C", "WARN", msg, var1, var2, var3)
#define L2C_TRACE_ERR0(msg) WSF_TRACE0("L2C", "ERR", msg)
#define L2C_TRACE_ERR1(msg, var1) WSF_TRACE1("L2C", "ERR", msg, var1)
#define L2C_TRACE_ERR2(msg, var1, var2) WSF_TRACE2("L2C", "ERR", msg, var1, var2)
#define L2C_TRACE_ERR3(msg, var1, var2, var3) WSF_TRACE3("L2C", "ERR", msg, var1, var2, var3)
#define ATT_TRACE_INFO0(msg) WSF_TRACE0("ATT", "INFO", msg)
#define ATT_TRACE_INFO1(msg, var1) WSF_TRACE1("ATT", "INFO", msg, var1)
#define ATT_TRACE_INFO2(msg, var1, var2) WSF_TRACE2("ATT", "INFO", msg, var1, var2)
#define ATT_TRACE_INFO3(msg, var1, var2, var3) WSF_TRACE3("ATT", "INFO", msg, var1, var2, var3)
#define ATT_TRACE_WARN0(msg) WSF_TRACE0("ATT", "WARN", msg)
#define ATT_TRACE_WARN1(msg, var1) WSF_TRACE1("ATT", "WARN", msg, var1)
#define ATT_TRACE_WARN2(msg, var1, var2) WSF_TRACE2("ATT", "WARN", msg, var1, var2)
#define ATT_TRACE_WARN3(msg, var1, var2, var3) WSF_TRACE3("ATT", "WARN", msg, var1, var2, var3)
#define ATT_TRACE_ERR0(msg) WSF_TRACE0("ATT", "ERR", msg)
#define ATT_TRACE_ERR1(msg, var1) WSF_TRACE1("ATT", "ERR", msg, var1)
#define ATT_TRACE_ERR2(msg, var1, var2) WSF_TRACE2("ATT", "ERR", msg, var1, var2)
#define ATT_TRACE_ERR3(msg, var1, var2, var3) WSF_TRACE3("ATT", "ERR", msg, var1, var2, var3)
#define SMP_TRACE_INFO0(msg) WSF_TRACE0("SMP", "INFO", msg)
#define SMP_TRACE_INFO1(msg, var1) WSF_TRACE1("SMP", "INFO", msg, var1)
#define SMP_TRACE_INFO2(msg, var1, var2) WSF_TRACE2("SMP", "INFO", msg, var1, var2)
#define SMP_TRACE_INFO3(msg, var1, var2, var3) WSF_TRACE3("SMP", "INFO", msg, var1, var2, var3)
#define SMP_TRACE_WARN0(msg) WSF_TRACE0("SMP", "WARN", msg)
#define SMP_TRACE_WARN1(msg, var1) WSF_TRACE1("SMP", "WARN", msg, var1)
#define SMP_TRACE_WARN2(msg, var1, var2) WSF_TRACE2("SMP", "WARN", msg, var1, var2)
#define SMP_TRACE_WARN3(msg, var1, var2, var3) WSF_TRACE3("SMP", "WARN", msg, var1, var2, var3)
#define SMP_TRACE_ERR0(msg) WSF_TRACE0("SMP", "ERR", msg)
#define SMP_TRACE_ERR1(msg, var1) WSF_TRACE1("SMP", "ERR", msg, var1)
#define SMP_TRACE_ERR2(msg, var1, var2) WSF_TRACE2("SMP", "ERR", msg, var1, var2)
#define SMP_TRACE_ERR3(msg, var1, var2, var3) WSF_TRACE3("SMP", "ERR", msg, var1, var2, var3)
#define APP_TRACE_INFO0(msg) WSF_TRACE0("APP", "INFO", msg)
#define APP_TRACE_INFO1(msg, var1) WSF_TRACE1("APP", "INFO", msg, var1)
#define APP_TRACE_INFO2(msg, var1, var2) WSF_TRACE2("APP", "INFO", msg, var1, var2)
#define APP_TRACE_INFO3(msg, var1, var2, var3) WSF_TRACE3("APP", "INFO", msg, var1, var2, var3)
#define APP_TRACE_WARN0(msg) WSF_TRACE0("APP", "WARN", msg)
#define APP_TRACE_WARN1(msg, var1) WSF_TRACE1("APP", "WARN", msg, var1)
#define APP_TRACE_WARN2(msg, var1, var2) WSF_TRACE2("APP", "WARN", msg, var1, var2)
#define APP_TRACE_WARN3(msg, var1, var2, var3) WSF_TRACE3("APP", "WARN", msg, var1, var2, var3)
#define APP_TRACE_ERR0(msg) WSF_TRACE0("APP", "ERR", msg)
#define APP_TRACE_ERR1(msg, var1) WSF_TRACE1("APP", "ERR", msg, var1)
#define APP_TRACE_ERR2(msg, var1, var2) WSF_TRACE2("APP", "ERR", msg, var1, var2)
#define APP_TRACE_ERR3(msg, var1, var2, var3) WSF_TRACE3("APP", "ERR", msg, var1, var2, var3)
#define LL_TRACE_INFO0(msg) WSF_TRACE0("LL", "INFO", msg)
#define LL_TRACE_INFO1(msg, var1) WSF_TRACE1("LL", "INFO", msg, var1)
#define LL_TRACE_INFO2(msg, var1, var2) WSF_TRACE2("LL", "INFO", msg, var1, var2)
#define LL_TRACE_INFO3(msg, var1, var2, var3) WSF_TRACE3("LL", "INFO", msg, var1, var2, var3)
#define LL_TRACE_WARN0(msg) WSF_TRACE0("LL", "WARN", msg)
#define LL_TRACE_WARN1(msg, var1) WSF_TRACE1("LL", "WARN", msg, var1)
#define LL_TRACE_WARN2(msg, var1, var2) WSF_TRACE2("LL", "WARN", msg, var1, var2)
#define LL_TRACE_WARN3(msg, var1, var2, var3) WSF_TRACE3("LL", "WARN", msg, var1, var2, var3)
#define LL_TRACE_ERR0(msg) WSF_TRACE0("LL", "ERR", msg)
#define LL_TRACE_ERR1(msg, var1) WSF_TRACE1("LL", "ERR", msg, var1)
#define LL_TRACE_ERR2(msg, var1, var2) WSF_TRACE2("LL", "ERR", msg, var1, var2)
#define LL_TRACE_ERR3(msg, var1, var2, var3) WSF_TRACE3("LL", "ERR", msg, var1, var2, var3)
#endif /* WSF_TRACE_H */
ambiq-hal-sys/ambiq-sparkfun-sdk/third_party/exactle/wsf/sources/port/freertos/wsf_types.h
Vendored
+62
View File
@@ -0,0 +1,62 @@
/*************************************************************************************************/
/*!
* \file wsf_types.h
*
* \brief Platform-independent data types.
*
* $Date: 2015-05-14 14:58:23 -0700 (Thu, 14 May 2015) $
* $Revision: 2837 $
*
* Copyright (c) 2009 Wicentric, Inc., all rights reserved.
* Wicentric confidential and proprietary.
*
* IMPORTANT. Your use of this file is governed by a Software License Agreement
* ("Agreement") that must be accepted in order to download or otherwise receive a
* copy of this file. You may not use or copy this file for any purpose other than
* as described in the Agreement. If you do not agree to all of the terms of the
* Agreement do not use this file and delete all copies in your possession or control;
* if you do not have a copy of the Agreement, you must contact Wicentric, Inc. prior
* to any use, copying or further distribution of this software.
*/
/*************************************************************************************************/
#ifndef WSF_TYPES_H
#define WSF_TYPES_H
/**************************************************************************************************
Macros
**************************************************************************************************/
#ifndef NULL
#define NULL 0
#endif
#ifndef TRUE
#define TRUE 1
#endif
#ifndef FALSE
#define FALSE 0
#endif
/**************************************************************************************************
Data Types
**************************************************************************************************/
/* Integer data types */
#if ((defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) && \
(!defined(__ICC8051__) || (__ICC8051__ == 0)))
#include <stdint.h>
#else
typedef signed char int8_t;
typedef unsigned char uint8_t;
typedef signed short int16_t;
typedef unsigned short uint16_t;
typedef signed long int32_t;
typedef unsigned long uint32_t;
typedef unsigned long long uint64_t;
#endif
/* Boolean data type */
typedef uint8_t bool_t;
#endif /* WSF_TYPES_H */
ambiq-hal-sys/ambiq-sparkfun-sdk/third_party/exactle/wsf/sources/util/bda.c
Vendored
+127
View File
@@ -0,0 +1,127 @@
/*************************************************************************************************/
/*!
* \file bda.c
*
* \brief Bluetooth device address utilities.
*
* $Date: 2016-12-28 16:12:14 -0600 (Wed, 28 Dec 2016) $
* $Revision: 10805 $
*
* Copyright (c) 2009-2017 ARM Ltd., all rights reserved.
* ARM Ltd. confidential and proprietary.
*
* IMPORTANT. Your use of this file is governed by a Software License Agreement
* ("Agreement") that must be accepted in order to download or otherwise receive a
* copy of this file. You may not use or copy this file for any purpose other than
* as described in the Agreement. If you do not agree to all of the terms of the
* Agreement do not use this file and delete all copies in your possession or control;
* if you do not have a copy of the Agreement, you must contact ARM Ltd. prior
* to any use, copying or further distribution of this software.
*/
/*************************************************************************************************/
#include <string.h>
#include "wsf_types.h"
#include "bda.h"
/*************************************************************************************************/
/*!
* \fn BdaCpy
*
* \brief Copy a BD address from source to destination.
*
* \param pDst Pointer to destination.
* \param pSrc Pointer to source.
*
* \return None.
*/
/*************************************************************************************************/
void BdaCpy(uint8_t *pDst, const uint8_t *pSrc)
{
memcpy(pDst, pSrc, BDA_ADDR_LEN);
}
/*************************************************************************************************/
/*!
* \fn BdaCmp
*
* \brief Compare two BD addresses.
*
* \param pAddr1 First address.
* \param pAddr2 Second address.
*
* \return TRUE if addresses match, FALSE otherwise.
*/
/*************************************************************************************************/
bool_t BdaCmp(const uint8_t *pAddr1, const uint8_t *pAddr2)
{
return (memcmp(pAddr1, pAddr2, BDA_ADDR_LEN) == 0);
}
/*************************************************************************************************/
/*!
* \fn BdaClr
*
* \brief Set a BD address to all zeros.
*
* \param pDst Pointer to destination.
*
* \return pDst + BDA_ADDR_LEN
*/
/*************************************************************************************************/
uint8_t *BdaClr(uint8_t *pDst)
{
memset(pDst, 0, BDA_ADDR_LEN);
return (pDst + BDA_ADDR_LEN);
}
/*************************************************************************************************/
/*!
* \fn BdaIsZeros
*
* \brief Check if a BD address is all zeros.
*
* \param pAddr Pointer to address.
*
* \return TRUE if address is all zeros, FALSE otherwise.
*/
/*************************************************************************************************/
bool_t BdaIsZeros(const uint8_t *pAddr)
{
uint8_t addrZeros[BDA_ADDR_LEN] = { 0 };
return (memcmp(pAddr, addrZeros, BDA_ADDR_LEN) == 0);
}
/*************************************************************************************************/
/*!
* \fn Bda2Str
*
* \brief Convert a BD address to a string.
*
* \param pAddr Pointer to BD address.
*
* \return Pointer to string.
*/
/*************************************************************************************************/
char *Bda2Str(const uint8_t *pAddr)
{
static const char hex[] = "0123456789ABCDEF";
static char str[BDA_ADDR_STR_LEN + 1];
char *pStr = str;
/* address is little endian so copy in reverse */
pAddr += BDA_ADDR_LEN;
while (pStr < &str[BDA_ADDR_STR_LEN])
{
*pStr++ = hex[*--pAddr >> 4];
*pStr++ = hex[*pAddr & 0x0F];
}
/* null terminate string */
*pStr = 0;
return str;
}
ambiq-hal-sys/ambiq-sparkfun-sdk/third_party/exactle/wsf/sources/util/bda.h
Vendored
+140
View File
@@ -0,0 +1,140 @@
/*************************************************************************************************/
/*!
* \file bda.h
*
* \brief Bluetooth device address utilities.
*
* $Date: 2016-12-28 16:12:14 -0600 (Wed, 28 Dec 2016) $
* $Revision: 10805 $
*
* Copyright (c) 2009-2017 ARM Ltd., all rights reserved.
* ARM Ltd. confidential and proprietary.
*
* IMPORTANT. Your use of this file is governed by a Software License Agreement
* ("Agreement") that must be accepted in order to download or otherwise receive a
* copy of this file. You may not use or copy this file for any purpose other than
* as described in the Agreement. If you do not agree to all of the terms of the
* Agreement do not use this file and delete all copies in your possession or control;
* if you do not have a copy of the Agreement, you must contact ARM Ltd. prior
* to any use, copying or further distribution of this software.
*/
/*************************************************************************************************/
#ifndef BDA_H
#define BDA_H
#ifdef __cplusplus
extern "C" {
#endif
/**************************************************************************************************
Macros
**************************************************************************************************/
/*! \brief BD address length */
#define BDA_ADDR_LEN 6
/*! \brief BD address string length */
#define BDA_ADDR_STR_LEN (BDA_ADDR_LEN * 2)
/*! \brief BDA RPA check */
#define BDA_ADDR_IS_RPA(bda) (((bda)[5] & 0xC0) == 0x40)
/*! \brief BDA NRPA check */
#define BDA_ADDR_IS_NRPA(bda) (((bda)[5] & 0xC0) == 0x00)
/*! \brief BDA static random check */
#define BDA_ADDR_IS_STATIC(bda) (((bda)[5] & 0xC0) == 0xC0)
/*! \brief BDA64 RPA check */
#define BDA64_ADDR_IS_RPA(bda64) ((((bda64) >> 40) & 0xC0) == 0x40)
/*! \brief BDA64 NRPA check */
#define BDA64_ADDR_IS_NRPA(bda64) ((((bda64) >> 40) & 0xC0) == 0x00)
/*! \brief BDA64 static random check */
#define BDA64_ADDR_IS_STATIC(bda64) ((((bda64) >> 40) & 0xC0) == 0xC0)
/**************************************************************************************************
Data Types
**************************************************************************************************/
/*! \brief BD address data type */
typedef uint8_t bdAddr_t[BDA_ADDR_LEN];
/**************************************************************************************************
Function Declarations
**************************************************************************************************/
/*************************************************************************************************/
/*!
* \fn BdaCpy
*
* \brief Copy a BD address from source to destination.
*
* \param pDst Pointer to destination.
* \param pSrc Pointer to source.
*
* \return None.
*/
/*************************************************************************************************/
void BdaCpy(uint8_t *pDst, const uint8_t *pSrc);
/*************************************************************************************************/
/*!
* \fn BdaCmp
*
* \brief Compare two BD addresses.
*
* \param pAddr1 First address.
* \param pAddr2 Second address.
*
* \return TRUE if addresses match, FALSE otherwise.
*/
/*************************************************************************************************/
bool_t BdaCmp(const uint8_t *pAddr1, const uint8_t *pAddr2);
/*************************************************************************************************/
/*!
* \fn BdaClr
*
* \brief Set a BD address to all zeros.
*
* \param pDst Pointer to destination.
*
* \return pDst + BDA_ADDR_LEN
*/
/*************************************************************************************************/
uint8_t *BdaClr(uint8_t *pDst);
/*************************************************************************************************/
/*!
* \fn BdaIsZeros
*
* \brief Check if a BD address is all zeros.
*
* \param pAddr Pointer to address.
*
* \return TRUE if address is all zeros, FALSE otherwise.
*/
/*************************************************************************************************/
bool_t BdaIsZeros(const uint8_t *pAddr);
/*************************************************************************************************/
/*!
* \fn Bda2Str
*
* \brief Convert a BD address to a string.
*
* \param pAddr Pointer to BD address.
*
* \return Pointer to string.
*/
/*************************************************************************************************/
char *Bda2Str(const uint8_t *pAddr);
#ifdef __cplusplus
};
#endif
#endif /* BDA_H */
ambiq-hal-sys/ambiq-sparkfun-sdk/third_party/exactle/wsf/sources/util/bstream.c
Vendored
+106
View File
@@ -0,0 +1,106 @@
/*************************************************************************************************/
/*!
* \file bstream.h
*
* \brief Byte stream to integer conversion functions.
*
* $Date: 2016-12-28 16:12:14 -0600 (Wed, 28 Dec 2016) $
* $Revision: 10805 $
*
* Copyright (c) 2009-2017 ARM Ltd., all rights reserved.
* ARM Ltd. confidential and proprietary.
*
* IMPORTANT. Your use of this file is governed by a Software License Agreement
* ("Agreement") that must be accepted in order to download or otherwise receive a
* copy of this file. You may not use or copy this file for any purpose other than
* as described in the Agreement. If you do not agree to all of the terms of the
* Agreement do not use this file and delete all copies in your possession or control;
* if you do not have a copy of the Agreement, you must contact ARM Ltd. prior
* to any use, copying or further distribution of this software.
*/
/*************************************************************************************************/
#include "wsf_types.h"
#include "bstream.h"
/*************************************************************************************************/
/*!
* \brief Convert bstream to uint64_t.
*
* \param p Bstream pointer.
*
* \return Resulting uint64_t number.
*/
/*************************************************************************************************/
uint64_t BstreamToUint64(const uint8_t *p)
{
return ((uint64_t)p[0] << 0) |
((uint64_t)p[1] << 8) |
((uint64_t)p[2] << 16) |
((uint64_t)p[3] << 24) |
((uint64_t)p[4] << 32) |
((uint64_t)p[5] << 40) |
((uint64_t)p[6] << 48) |
((uint64_t)p[7] << 56);
}
/*************************************************************************************************/
/*!
* \brief Convert uint64_t to bstream.
*
* \param p Bstream pointer.
* \param n uint64_t number.
*
* \return None.
*/
/*************************************************************************************************/
void Uint64ToBstream(uint8_t *p, uint64_t n)
{
p[0] = (uint8_t)(n >> 0);
p[1] = (uint8_t)(n >> 8);
p[2] = (uint8_t)(n >> 16);
p[3] = (uint8_t)(n >> 24);
p[4] = (uint8_t)(n >> 32);
p[5] = (uint8_t)(n >> 40);
p[6] = (uint8_t)(n >> 48);
p[7] = (uint8_t)(n >> 56);
}
/*************************************************************************************************/
/*!
* \brief Convert bstream to BDA64.
*
* \param p Bstream pointer.
*
* \return Resulting BDA64 number.
*/
/*************************************************************************************************/
uint64_t BstreamToBda64(const uint8_t *p)
{
return (uint64_t)p[0] << 0 |
(uint64_t)p[1] << 8 |
(uint64_t)p[2] << 16 |
(uint64_t)p[3] << 24 |
(uint64_t)p[4] << 32 |
(uint64_t)p[5] << 40;
}
/*************************************************************************************************/
/*!
* \brief Convert BDA64 to bstream.
*
* \param p Bstream pointer.
* \param bda uint64_t BDA.
*
* \return None.
*/
/*************************************************************************************************/
void Bda64ToBstream(uint8_t *p, uint64_t bda)
{
p[0] = (uint8_t)(bda >> 0);
p[1] = (uint8_t)(bda >> 8);
p[2] = (uint8_t)(bda >> 16);
p[3] = (uint8_t)(bda >> 24);
p[4] = (uint8_t)(bda >> 32);
p[5] = (uint8_t)(bda >> 40);
}
ambiq-hal-sys/ambiq-sparkfun-sdk/third_party/exactle/wsf/sources/util/bstream.h
Vendored
+149
View File
@@ -0,0 +1,149 @@
/*************************************************************************************************/
/*!
* \file bstream.h
*
* \brief Byte stream to integer conversion macros.
*
* $Date: 2017-02-06 19:25:09 -0600 (Mon, 06 Feb 2017) $
* $Revision: 11104 $
*
* Copyright (c) 2009-2017 ARM Ltd., all rights reserved.
* ARM Ltd. confidential and proprietary.
*
* IMPORTANT. Your use of this file is governed by a Software License Agreement
* ("Agreement") that must be accepted in order to download or otherwise receive a
* copy of this file. You may not use or copy this file for any purpose other than
* as described in the Agreement. If you do not agree to all of the terms of the
* Agreement do not use this file and delete all copies in your possession or control;
* if you do not have a copy of the Agreement, you must contact ARM Ltd. prior
* to any use, copying or further distribution of this software.
*/
/*************************************************************************************************/
#ifndef BSTREAM_H
#define BSTREAM_H
#include "bda.h"
#ifdef __cplusplus
extern "C" {
#endif
/**************************************************************************************************
Macros
**************************************************************************************************/
/*!
* Macros for converting a little endian byte buffer to integers.
*/
#define BYTES_TO_UINT16(n, p) {n = ((uint16_t)(p)[0] + ((uint16_t)(p)[1] << 8));}
#define BYTES_TO_UINT24(n, p) {n = ((uint16_t)(p)[0] + ((uint16_t)(p)[1] << 8) + \
((uint16_t)(p)[2] << 16));}
#define BYTES_TO_UINT32(n, p) {n = ((uint32_t)(p)[0] + ((uint32_t)(p)[1] << 8) + \
((uint32_t)(p)[2] << 16) + ((uint32_t)(p)[3] << 24));}
#define BYTES_TO_UINT40(n, p) {n = ((uint64_t)(p)[0] + ((uint64_t)(p)[1] << 8) + \
((uint64_t)(p)[2] << 16) + ((uint64_t)(p)[3] << 24) + \
((uint64_t)(p)[4] << 32));}
#define BYTES_TO_UINT64(n, p) {n = ((uint64_t)(p)[0] + ((uint64_t)(p)[1] << 8) + \
((uint64_t)(p)[2] << 16) + ((uint64_t)(p)[3] << 24) + \
((uint64_t)(p)[4] << 32) + ((uint64_t)(p)[5] << 40) + \
((uint64_t)(p)[6] << 48) + ((uint64_t)(p)[7] << 56));}
/*!
* Macros for converting little endian integers to array of bytes
*/
#define UINT16_TO_BYTES(n) ((uint8_t) (n)), ((uint8_t)((n) >> 8))
#define UINT32_TO_BYTES(n) ((uint8_t) (n)), ((uint8_t)((n) >> 8)), ((uint8_t)((n) >> 16)), ((uint8_t)((n) >> 24))
/*!
* Macros for converting little endian integers to single bytes
*/
#define UINT16_TO_BYTE0(n) ((uint8_t) (n))
#define UINT16_TO_BYTE1(n) ((uint8_t) ((n) >> 8))
#define UINT32_TO_BYTE0(n) ((uint8_t) (n))
#define UINT32_TO_BYTE1(n) ((uint8_t) ((n) >> 8))
#define UINT32_TO_BYTE2(n) ((uint8_t) ((n) >> 16))
#define UINT32_TO_BYTE3(n) ((uint8_t) ((n) >> 24))
/*!
* Macros for converting a little endian byte stream to integers, with increment.
*/
#define BSTREAM_TO_INT8(n, p) {n = (int8_t)(*(p)++);}
#define BSTREAM_TO_UINT8(n, p) {n = (uint8_t)(*(p)++);}
#define BSTREAM_TO_UINT16(n, p) {BYTES_TO_UINT16(n, p); p += 2;}
#define BSTREAM_TO_UINT24(n, p) {BYTES_TO_UINT24(n, p); p += 3;}
#define BSTREAM_TO_UINT32(n, p) {BYTES_TO_UINT32(n, p); p += 4;}
#define BSTREAM_TO_UINT40(n, p) {BYTES_TO_UINT40(n, p); p += 5;}
#define BSTREAM_TO_UINT64(n, p) {n = BstreamToUint64(p); p += 8;}
#define BSTREAM_TO_BDA(bda, p) {BdaCpy(bda, p); p += BDA_ADDR_LEN;}
#define BSTREAM_TO_BDA64(bda, p) {bda = BstreamToBda64(p); p += BDA_ADDR_LEN;}
/*!
* Macros for converting integers to a little endian byte stream, with increment.
*/
#define UINT8_TO_BSTREAM(p, n) {*(p)++ = (uint8_t)(n);}
#define UINT16_TO_BSTREAM(p, n) {*(p)++ = (uint8_t)(n); *(p)++ = (uint8_t)((n) >> 8);}
#define UINT24_TO_BSTREAM(p, n) {*(p)++ = (uint8_t)(n); *(p)++ = (uint8_t)((n) >> 8); \
*(p)++ = (uint8_t)((n) >> 16);}
#define UINT32_TO_BSTREAM(p, n) {*(p)++ = (uint8_t)(n); *(p)++ = (uint8_t)((n) >> 8); \
*(p)++ = (uint8_t)((n) >> 16); *(p)++ = (uint8_t)((n) >> 24);}
#define UINT40_TO_BSTREAM(p, n) {*(p)++ = (uint8_t)(n); *(p)++ = (uint8_t)((n) >> 8); \
*(p)++ = (uint8_t)((n) >> 16); *(p)++ = (uint8_t)((n) >> 24); \
*(p)++ = (uint8_t)((n) >> 32);}
#define UINT64_TO_BSTREAM(p, n) {Uint64ToBstream(p, n); p += sizeof(uint64_t);}
#define BDA_TO_BSTREAM(p, bda) {BdaCpy(p, bda); p += BDA_ADDR_LEN;}
#define BDA64_TO_BSTREAM(p, bda) {Bda64ToBstream(p, bda); p += BDA_ADDR_LEN;}
/*!
* Macros for converting integers to a little endian byte stream, without increment.
*/
#define UINT16_TO_BUF(p, n) {(p)[0] = (uint8_t)(n); (p)[1] = (uint8_t)((n) >> 8);}
#define UINT24_TO_BUF(p, n) {(p)[0] = (uint8_t)(n); (p)[1] = (uint8_t)((n) >> 8); \
(p)[2] = (uint8_t)((n) >> 16);}
#define UINT32_TO_BUF(p, n) {(p)[0] = (uint8_t)(n); (p)[1] = (uint8_t)((n) >> 8); \
(p)[2] = (uint8_t)((n) >> 16); (p)[3] = (uint8_t)((n) >> 24);}
#define UINT40_TO_BUF(p, n) {(p)[0] = (uint8_t)(n); (p)[1] = (uint8_t)((n) >> 8); \
(p)[2] = (uint8_t)((n) >> 16); (p)[3] = (uint8_t)((n) >> 24);\
(p)[4] = (uint8_t)((n) >> 32);}
/*!
* Macros for comparing a little endian byte buffer to integers.
*/
#define BYTES_UINT16_CMP(p, n) ((p)[1] == UINT16_TO_BYTE1(n) && (p)[0] == UINT16_TO_BYTE0(n))
/*!
* Macros for IEEE FLOAT type: exponent = byte 3, mantissa = bytes 2-0
*/
#define FLT_TO_UINT32(m, e) ((m) | ((int32_t)(e) << 24))
#define UINT32_TO_FLT(m, e, n) {m = UINT32_TO_FLT_M(n); e = UINT32_TO_FLT_E(n);}
#define UINT32_TO_FLT_M(n) ((((n) & 0x00FFFFFF) >= 0x00800000) ? \
((int32_t)(((n) | 0xFF000000))) : ((int32_t)((n) & 0x00FFFFFF)))
#define UINT32_TO_FLT_E(n) ((int8_t)(n >> 24))
/*!
* Macros for IEEE SFLOAT type: exponent = bits 15-12, mantissa = bits 11-0
*/
#define SFLT_TO_UINT16(m, e) ((m) | ((int16_t)(e) << 12))
#define UINT16_TO_SFLT(m, e, n) {m = UINT16_TO_SFLT_M(n); e = UINT16_TO_SFLT_E(n);}
#define UINT16_TO_SFLT_M(n) ((((n) & 0x0FFF) >= 0x0800) ? \
((int16_t)(((n) | 0xF000))) : ((int16_t)((n) & 0x0FFF)))
#define UINT16_TO_SFLT_E(n) (((n >> 12) >= 0x0008) ? \
((int8_t)(((n >> 12) | 0xF0))) : ((int8_t)(n >> 12)))
/**************************************************************************************************
Function Declarations
**************************************************************************************************/
uint64_t BstreamToBda64(const uint8_t *p);
uint64_t BstreamToUint64(const uint8_t *p);
void Bda64ToBstream(uint8_t *p, uint64_t bda);
void Uint64ToBstream(uint8_t *p, uint64_t n);
#ifdef __cplusplus
};
#endif
#endif /* BSTREAM_H */
ambiq-hal-sys/ambiq-sparkfun-sdk/third_party/exactle/wsf/sources/util/calc128.c
Vendored
+92
View File
@@ -0,0 +1,92 @@
/*************************************************************************************************/
/*!
* \file calc128.c
*
* \brief 128-bit integer utilities.
*
* $Date: 2016-12-28 16:12:14 -0600 (Wed, 28 Dec 2016) $
* $Revision: 10805 $
*
* Copyright (c) 2010-2017 ARM Ltd., all rights reserved.
* ARM Ltd. confidential and proprietary.
*
* IMPORTANT. Your use of this file is governed by a Software License Agreement
* ("Agreement") that must be accepted in order to download or otherwise receive a
* copy of this file. You may not use or copy this file for any purpose other than
* as described in the Agreement. If you do not agree to all of the terms of the
* Agreement do not use this file and delete all copies in your possession or control;
* if you do not have a copy of the Agreement, you must contact ARM Ltd. prior
* to any use, copying or further distribution of this software.
*/
/*************************************************************************************************/
#include <string.h>
#include "wsf_types.h"
#include "calc128.h"
/**************************************************************************************************
Global Variables
**************************************************************************************************/
/* 128-bit zero value */
const uint8_t calc128Zeros[CALC128_LEN] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
/**************************************************************************************************
Function Declarations
**************************************************************************************************/
/*************************************************************************************************/
/*!
* \fn Calc128Cpy
*
* \brief Copy a 128-bit integer from source to destination.
*
* \param pDst Pointer to destination.
* \param pSrc Pointer to source.
*
* \return None.
*/
/*************************************************************************************************/
void Calc128Cpy(uint8_t *pDst, uint8_t *pSrc)
{
memcpy(pDst, pSrc, CALC128_LEN);
}
/*************************************************************************************************/
/*!
* \fn Calc128Cpy64
*
* \brief Copy a 64-bit integer from source to destination.
*
* \param pDst Pointer to destination.
* \param pSrc Pointer to source.
*
* \return None.
*/
/*************************************************************************************************/
void Calc128Cpy64(uint8_t *pDst, uint8_t *pSrc)
{
memcpy(pDst, pSrc, CALC128_LEN/2);
}
/*************************************************************************************************/
/*!
* \fn Calc128Xor
*
* \brief Exclusive-or two 128-bit integers and return the result in pDst.
*
* \param pDst Pointer to destination.
* \param pSrc Pointer to source.
*
* \return None.
*/
/*************************************************************************************************/
void Calc128Xor(uint8_t *pDst, uint8_t *pSrc)
{
uint8_t i;
for (i = CALC128_LEN; i > 0; i--)
{
*pDst++ ^= *pSrc++;
}
}
ambiq-hal-sys/ambiq-sparkfun-sdk/third_party/exactle/wsf/sources/util/calc128.h
Vendored
+93
View File
@@ -0,0 +1,93 @@
/*************************************************************************************************/
/*!
* \file calc128.h
*
* \brief 128-bit integer utilities.
*
* $Date: 2016-12-28 16:12:14 -0600 (Wed, 28 Dec 2016) $
* $Revision: 10805 $
*
* Copyright (c) 2010-2017 ARM Ltd., all rights reserved.
* ARM Ltd. confidential and proprietary.
*
* IMPORTANT. Your use of this file is governed by a Software License Agreement
* ("Agreement") that must be accepted in order to download or otherwise receive a
* copy of this file. You may not use or copy this file for any purpose other than
* as described in the Agreement. If you do not agree to all of the terms of the
* Agreement do not use this file and delete all copies in your possession or control;
* if you do not have a copy of the Agreement, you must contact ARM Ltd. prior
* to any use, copying or further distribution of this software.
*/
/*************************************************************************************************/
#ifndef CALC128_H
#define CALC128_H
#ifdef __cplusplus
extern "C" {
#endif
/**************************************************************************************************
Macros
**************************************************************************************************/
/*! 128-bit integer length in bytes */
#define CALC128_LEN 16
/**************************************************************************************************
Global Variables
**************************************************************************************************/
/*! 128-bit zero value */
extern const uint8_t calc128Zeros[CALC128_LEN];
/**************************************************************************************************
Function Declarations
**************************************************************************************************/
/*************************************************************************************************/
/*!
* \fn Calc128Cpy
*
* \brief Copy a 128-bit integer from source to destination.
*
* \param pDst Pointer to destination.
* \param pSrc Pointer to source.
*
* \return None.
*/
/*************************************************************************************************/
void Calc128Cpy(uint8_t *pDst, uint8_t *pSrc);
/*************************************************************************************************/
/*!
* \fn Calc128Cpy64
*
* \brief Copy a 64-bit integer from source to destination.
*
* \param pDst Pointer to destination.
* \param pSrc Pointer to source.
*
* \return None.
*/
/*************************************************************************************************/
void Calc128Cpy64(uint8_t *pDst, uint8_t *pSrc);
/*************************************************************************************************/
/*!
* \fn Calc128Xor
*
* \brief Exclusive-or two 128-bit integers and return the result in pDst.
*
* \param pDst Pointer to destination.
* \param pSrc Pointer to source.
*
* \return None.
*/
/*************************************************************************************************/
void Calc128Xor(uint8_t *pDst, uint8_t *pSrc);
#ifdef __cplusplus
};
#endif
#endif /* CALC128_H */
ambiq-hal-sys/ambiq-sparkfun-sdk/third_party/exactle/wsf/sources/util/crc32.c
Vendored
+128
View File
@@ -0,0 +1,128 @@
/*************************************************************************************************/
/*!
* \file crc32.c
*
* \brief CRC-32 utilities.
*
* $Date: 2016-12-28 16:12:14 -0600 (Wed, 28 Dec 2016) $
* $Revision: 10805 $
*
* Copyright (c) 2010-2017 ARM Ltd., all rights reserved.
* ARM Ltd. confidential and proprietary.
*
* IMPORTANT. Your use of this file is governed by a Software License Agreement
* ("Agreement") that must be accepted in order to download or otherwise receive a
* copy of this file. You may not use or copy this file for any purpose other than
* as described in the Agreement. If you do not agree to all of the terms of the
* Agreement do not use this file and delete all copies in your possession or control;
* if you do not have a copy of the Agreement, you must contact ARM Ltd. prior
* to any use, copying or further distribution of this software.
*/
/*************************************************************************************************/
#include "wsf_types.h"
#include "crc32.h"
/**************************************************************************************************
Local Variables
**************************************************************************************************/
static const uint32_t crc32Table[256] =
{
0x00000000U, 0x77073096U, 0xEE0E612CU, 0x990951BAU,
0x076DC419U, 0x706AF48FU, 0xE963A535U, 0x9E6495A3U,
0x0EDB8832U, 0x79DCB8A4U, 0xE0D5E91EU, 0x97D2D988U,
0x09B64C2BU, 0x7EB17CBDU, 0xE7B82D07U, 0x90BF1D91U,
0x1DB71064U, 0x6AB020F2U, 0xF3B97148U, 0x84BE41DEU,
0x1ADAD47DU, 0x6DDDE4EBU, 0xF4D4B551U, 0x83D385C7U,
0x136C9856U, 0x646BA8C0U, 0xFD62F97AU, 0x8A65C9ECU,
0x14015C4FU, 0x63066CD9U, 0xFA0F3D63U, 0x8D080DF5U,
0x3B6E20C8U, 0x4C69105EU, 0xD56041E4U, 0xA2677172U,
0x3C03E4D1U, 0x4B04D447U, 0xD20D85FDU, 0xA50AB56BU,
0x35B5A8FAU, 0x42B2986CU, 0xDBBBC9D6U, 0xACBCF940U,
0x32D86CE3U, 0x45DF5C75U, 0xDCD60DCFU, 0xABD13D59U,
0x26D930ACU, 0x51DE003AU, 0xC8D75180U, 0xBFD06116U,
0x21B4F4B5U, 0x56B3C423U, 0xCFBA9599U, 0xB8BDA50FU,
0x2802B89EU, 0x5F058808U, 0xC60CD9B2U, 0xB10BE924U,
0x2F6F7C87U, 0x58684C11U, 0xC1611DABU, 0xB6662D3DU,
0x76DC4190U, 0x01DB7106U, 0x98D220BCU, 0xEFD5102AU,
0x71B18589U, 0x06B6B51FU, 0x9FBFE4A5U, 0xE8B8D433U,
0x7807C9A2U, 0x0F00F934U, 0x9609A88EU, 0xE10E9818U,
0x7F6A0DBBU, 0x086D3D2DU, 0x91646C97U, 0xE6635C01U,
0x6B6B51F4U, 0x1C6C6162U, 0x856530D8U, 0xF262004EU,
0x6C0695EDU, 0x1B01A57BU, 0x8208F4C1U, 0xF50FC457U,
0x65B0D9C6U, 0x12B7E950U, 0x8BBEB8EAU, 0xFCB9887CU,
0x62DD1DDFU, 0x15DA2D49U, 0x8CD37CF3U, 0xFBD44C65U,
0x4DB26158U, 0x3AB551CEU, 0xA3BC0074U, 0xD4BB30E2U,
0x4ADFA541U, 0x3DD895D7U, 0xA4D1C46DU, 0xD3D6F4FBU,
0x4369E96AU, 0x346ED9FCU, 0xAD678846U, 0xDA60B8D0U,
0x44042D73U, 0x33031DE5U, 0xAA0A4C5FU, 0xDD0D7CC9U,
0x5005713CU, 0x270241AAU, 0xBE0B1010U, 0xC90C2086U,
0x5768B525U, 0x206F85B3U, 0xB966D409U, 0xCE61E49FU,
0x5EDEF90EU, 0x29D9C998U, 0xB0D09822U, 0xC7D7A8B4U,
0x59B33D17U, 0x2EB40D81U, 0xB7BD5C3BU, 0xC0BA6CADU,
0xEDB88320U, 0x9ABFB3B6U, 0x03B6E20CU, 0x74B1D29AU,
0xEAD54739U, 0x9DD277AFU, 0x04DB2615U, 0x73DC1683U,
0xE3630B12U, 0x94643B84U, 0x0D6D6A3EU, 0x7A6A5AA8U,
0xE40ECF0BU, 0x9309FF9DU, 0x0A00AE27U, 0x7D079EB1U,
0xF00F9344U, 0x8708A3D2U, 0x1E01F268U, 0x6906C2FEU,
0xF762575DU, 0x806567CBU, 0x196C3671U, 0x6E6B06E7U,
0xFED41B76U, 0x89D32BE0U, 0x10DA7A5AU, 0x67DD4ACCU,
0xF9B9DF6FU, 0x8EBEEFF9U, 0x17B7BE43U, 0x60B08ED5U,
0xD6D6A3E8U, 0xA1D1937EU, 0x38D8C2C4U, 0x4FDFF252U,
0xD1BB67F1U, 0xA6BC5767U, 0x3FB506DDU, 0x48B2364BU,
0xD80D2BDAU, 0xAF0A1B4CU, 0x36034AF6U, 0x41047A60U,
0xDF60EFC3U, 0xA867DF55U, 0x316E8EEFU, 0x4669BE79U,
0xCB61B38CU, 0xBC66831AU, 0x256FD2A0U, 0x5268E236U,
0xCC0C7795U, 0xBB0B4703U, 0x220216B9U, 0x5505262FU,
0xC5BA3BBEU, 0xB2BD0B28U, 0x2BB45A92U, 0x5CB36A04U,
0xC2D7FFA7U, 0xB5D0CF31U, 0x2CD99E8BU, 0x5BDEAE1DU,
0x9B64C2B0U, 0xEC63F226U, 0x756AA39CU, 0x026D930AU,
0x9C0906A9U, 0xEB0E363FU, 0x72076785U, 0x05005713U,
0x95BF4A82U, 0xE2B87A14U, 0x7BB12BAEU, 0x0CB61B38U,
0x92D28E9BU, 0xE5D5BE0DU, 0x7CDCEFB7U, 0x0BDBDF21U,
0x86D3D2D4U, 0xF1D4E242U, 0x68DDB3F8U, 0x1FDA836EU,
0x81BE16CDU, 0xF6B9265BU, 0x6FB077E1U, 0x18B74777U,
0x88085AE6U, 0xFF0F6A70U, 0x66063BCAU, 0x11010B5CU,
0x8F659EFFU, 0xF862AE69U, 0x616BFFD3U, 0x166CCF45U,
0xA00AE278U, 0xD70DD2EEU, 0x4E048354U, 0x3903B3C2U,
0xA7672661U, 0xD06016F7U, 0x4969474DU, 0x3E6E77DBU,
0xAED16A4AU, 0xD9D65ADCU, 0x40DF0B66U, 0x37D83BF0U,
0xA9BCAE53U, 0xDEBB9EC5U, 0x47B2CF7FU, 0x30B5FFE9U,
0xBDBDF21CU, 0xCABAC28AU, 0x53B39330U, 0x24B4A3A6U,
0xBAD03605U, 0xCDD70693U, 0x54DE5729U, 0x23D967BFU,
0xB3667A2EU, 0xC4614AB8U, 0x5D681B02U, 0x2A6F2B94U,
0xB40BBE37U, 0xC30C8EA1U, 0x5A05DF1BU, 0x2D02EF8DU
};
/*************************************************************************************************/
/*!
* \fn CalcCrc32
*
* \brief Calculate the CRC-32 of the given buffer.
*
* \param crcInit Initial value of the CRC.
* \param len Length of the buffer.
* \param pBuf Buffer to compute the CRC.
*
* \return None.
*
* This routine was originally generated with crcmod.py using the following parameters:
* - polynomial 0x104C11DB7
* - bit reverse algorithm
*/
/*************************************************************************************************/
uint32_t CalcCrc32(uint32_t crcInit, uint32_t len, uint8_t *pBuf)
{
uint32_t crc = crcInit;
while (len > 0)
{
crc = crc32Table[*pBuf ^ (uint8_t)crc] ^ (crc >> 8);
pBuf++;
len--;
}
crc = crc ^ 0xFFFFFFFFU;
return crc;
}
ambiq-hal-sys/ambiq-sparkfun-sdk/third_party/exactle/wsf/sources/util/crc32.h
Vendored
+52
View File
@@ -0,0 +1,52 @@
/*************************************************************************************************/
/*!
* \file crc32.h
*
* \brief CRC-32 utilities.
*
* $Date: 2016-12-28 16:12:14 -0600 (Wed, 28 Dec 2016) $
* $Revision: 10805 $
*
* Copyright (c) 2010-2017 ARM Ltd., all rights reserved.
* ARM Ltd. confidential and proprietary.
*
* IMPORTANT. Your use of this file is governed by a Software License Agreement
* ("Agreement") that must be accepted in order to download or otherwise receive a
* copy of this file. You may not use or copy this file for any purpose other than
* as described in the Agreement. If you do not agree to all of the terms of the
* Agreement do not use this file and delete all copies in your possession or control;
* if you do not have a copy of the Agreement, you must contact ARM Ltd. prior
* to any use, copying or further distribution of this software.
*/
/*************************************************************************************************/
#ifndef CRC32_H
#define CRC32_H
#ifdef __cplusplus
extern "C" {
#endif
/*************************************************************************************************/
/*!
* \fn CalcCrc32
*
* \brief Calculate the CRC-32 of the given buffer.
*
* \param crcInit Initial value of the CRC.
* \param len Length of the buffer.
* \param pBuf Buffer to compute the CRC.
*
* \return None.
*
* This routine was originally generated with crcmod.py using the following parameters:
* - polynomial 0x104C11DB7
* - bit reverse algorithm
*/
/*************************************************************************************************/
uint32_t CalcCrc32(uint32_t crcInit, uint32_t len, uint8_t *pBuf);
#ifdef __cplusplus
};
#endif
#endif /* CRC32_H */
ambiq-hal-sys/ambiq-sparkfun-sdk/third_party/exactle/wsf/sources/util/print.c
Vendored
+308
View File
@@ -0,0 +1,308 @@
/*************************************************************************************************/
/*!
* \file print.c
*
* \brief Utility functions.
*
* $Date: 2016-03-29 14:55:12 -0700 (Tue, 29 Mar 2016) $
* $Revision: 6524 $
*
* Copyright (c) 2015-2017 ARM Ltd., all rights reserved.
* ARM confidential and proprietary.
*
* IMPORTANT. Your use of this file is governed by a Software License Agreement
* ("Agreement") that must be accepted in order to download or otherwise receive a
* copy of this file. You may not use or copy this file for any purpose other than
* as described in the Agreement. If you do not agree to all of the terms of the
* Agreement do not use this file and delete all copies in your possession or control;
* if you do not have a copy of the Agreement, you must contact ARM Ltd. prior
* to any use, copying or further distribution of this software.
*/
/*************************************************************************************************/
#include <string.h>
#include "print.h"
/**************************************************************************************************
Macros
**************************************************************************************************/
/*! \brief Detect hexadecimal digits. */
#define PRINT_IS_XDIGIT(c) (((c >= '0') && (c <= '9')) || ((c >= 'a') && (c <= 'f')) || \
((c >= 'A') && (c <= 'F')))
/*! \brief Convert hexadecimal digit to integer. */
#define PRINT_XDIGIT_TO_INT(c) (((c >= '0') && (c <= '9')) ? (uint8_t)(c - '0') : \
((c >= 'a') && (c <= 'f')) ? (uint8_t)(c - 'a' + 10u) : \
((c >= 'A') && (c <= 'F')) ? (uint8_t)(c - 'A' + 10u) : 0u)
/*************************************************************************************************/
/*!
* \fn printFmtInt
*
* \brief Format an integer.
*
* \param pStr Storage for formatted integer.
* \param maxLen Maximum number of characters to store.
* \param i Integer to format.
* \param base Integer base.
* \param sign TRUE if sign should be printed.
* \param width Width of field.
*
* \return Number of characters stored.
*/
/*************************************************************************************************/
static int printFmtInt(char *pStr, int maxLen, int i, uint8_t base, bool_t sign, int width)
{
char *s, *p = pStr;
unsigned int u = (unsigned int) i;
uint8_t use_width;
int t;
use_width = width;
if (i == 0)
{
s = "0\0";
width--;
goto almost;
}
if (sign && base == 10 && i < 0)
{
*pStr++ = '-';
u = (unsigned int)-i;
width--;
}
s = pStr + maxLen - 1;
*s = '\0';
while (u && (!use_width || (width > 0)))
{
t = (unsigned int)u % base;
if (t >= 10)
{
t += 'A' - '0' - 10;
}
*--s = (char)(t + '0');
u /= base;
width--;
}
almost:
while (width > 0)
{
*pStr++ = '0';
width--;
}
strcpy(pStr, s);
return strlen(p);
}
/*************************************************************************************************/
/*!
* \fn printParseInt
*
* \brief Parse an integer from a string.
*
* \param pStr String to parse.
* \param pInt Storage for parsed integer.
* \param base Integer base.
*
* \return Number of characters consumed.
*/
/*************************************************************************************************/
static int32_t printParseInt(const char *pStr, uint32_t *pInt, uint32_t base)
{
int32_t r = 0;
if (base == 0)
{
if (*pStr == '0')
{
if (((*(pStr + 1) == 'x') || (*(pStr + 1) == 'X')) && PRINT_IS_XDIGIT(*(pStr + 2)))
{
r += 2;
pStr += 2;
base = 16;
}
else
{
base = 8;
}
}
else
{
base = 10;
}
}
else if (base == 16)
{
if (*pStr == '0')
{
if (((*(pStr + 1) == 'x') || (*(pStr + 1) == 'X')) && PRINT_IS_XDIGIT(*(pStr + 2)))
{
r += 2;
pStr += 2;
}
}
}
/* One character is required; all characters must be consumed. */
*pInt = 0;
do
{
char c;
uint8_t t;
c = *pStr++;
if (!PRINT_IS_XDIGIT(c))
{
break;
}
t = PRINT_XDIGIT_TO_INT(c);
if (t >= base)
{
break;
}
*pInt *= base;
*pInt += t;
r++;
} while (*pStr != '\0');
return r;
}
/*************************************************************************************************/
/*!
* \fn PrintVsn
*
* \brief Print a trace message.
*
* \param pStr Storage for formatted string.
* \param size Maximum number of characters to store.
* \param pFmt Format string.
* \param ap Arguments.
*
* \return Number of characters stored.
*/
/*************************************************************************************************/
uint32_t PrintVsn(char *pStr, uint32_t size, const char *pFmt, va_list ap)
{
size_t len = 0;
*pStr = 0;
size--; /* Ensure we null-terminate within our buffer */
while ((*pFmt != '\0') && (len < size))
{
uint32_t width = 0;
/* normal */
if (*pFmt != '%')
{
*pStr++ = *pFmt++;
len++;
continue;
}
pFmt++;
if (*pFmt == '%')
{
*pStr++ = '%';
len++;
pFmt++;
continue;
}
/* width */
if (*pFmt == '0')
{
pFmt += printParseInt(pFmt, &width, 10u);
}
/* long (ignore) */
if (*pFmt == 'l')
{
pFmt++;
}
switch(*pFmt)
{
/* character */
case 'c':
{
char tmp = va_arg(ap, int);
*pStr++ = tmp;
len++;
break;
}
/* unsigned decimal integer */
case 'u':
{
unsigned int tmp = va_arg(ap, unsigned int);
uint8_t lenTmp = printFmtInt(pStr, size - len, tmp, 10, 0, width);
pStr += lenTmp;
len += lenTmp;
break;
}
/* signed decimal integer */
case 'd':
{
int tmp = va_arg(ap, int);
uint8_t lenTmp = printFmtInt(pStr, size - len, tmp, 10, 1, width);
pStr += lenTmp;
len += lenTmp;
break;
}
/* pointer */
case 'p':
{
unsigned long tmp = va_arg(ap, unsigned long);
uint8_t lenTmp = printFmtInt(pStr, size - len, tmp, 16, 1, 8u);
pStr += lenTmp;
len += lenTmp;
break;
}
/* unsigned hexadecimal integer */
case 'x':
case 'X':
{
unsigned int tmp = va_arg(ap, unsigned int);
uint8_t lenTmp = printFmtInt(pStr, size - len, tmp, 16, 0, width);
pStr += lenTmp;
len += lenTmp;
break;
}
/* string */
case 's':
{
char *tmp = va_arg(ap, char *);
while ((tmp != NULL) && (*tmp != '\0') && (len < size))
{
*pStr++ = *tmp++;
len++;
}
break;
}
default:
break;
}
pFmt++;
}
/* Null-terminate output. */
*pStr = 0;
if (len > size)
{
/* Compensate for -1 earlier. */
return size + 2;
}
return len;
}
ambiq-hal-sys/ambiq-sparkfun-sdk/third_party/exactle/wsf/sources/util/print.h
Vendored
+57
View File
@@ -0,0 +1,57 @@
/*************************************************************************************************/
/*!
* \file print.h
*
* \brief Print functions.
*
* $Date: 2016-12-28 16:12:14 -0600 (Wed, 28 Dec 2016) $
* $Revision: 10805 $
*
* Copyright (c) 2015-2017 ARM Ltd., all rights reserved.
* ARM confidential and proprietary.
*
* IMPORTANT. Your use of this file is governed by a Software License Agreement
* ("Agreement") that must be accepted in order to download or otherwise receive a
* copy of this file. You may not use or copy this file for any purpose other than
* as described in the Agreement. If you do not agree to all of the terms of the
* Agreement do not use this file and delete all copies in your possession or control;
* if you do not have a copy of the Agreement, you must contact ARM Ltd. prior
* to any use, copying or further distribution of this software.
*/
/*************************************************************************************************/
#ifndef PRINT_H
#define PRINT_H
#include <stdarg.h>
#include "wsf_types.h"
/**************************************************************************************************
Macros
**************************************************************************************************/
/*! \brief Print function attributes. */
#if defined(__GNUC__) || defined(__CC_ARM)
#define PRINT_ATTRIBUTE(a, b) __attribute__((format(printf, a, b)))
#else
#define PRINT_ATTRIBUTE(a, b)
#endif
/*************************************************************************************************/
/*!
* \fn UtilVsnPrintf
*
* \brief Print a trace message.
*
* \param pStr Storage for formatted string.
* \param size Maximum number of characters to store.
* \param pFmt Format string.
* \param ap Arguments.
*
* \return Number of characters stored.
*/
/*************************************************************************************************/
uint32_t PrintVsn(char *pStr, uint32_t size, const char *pFmt, va_list ap) PRINT_ATTRIBUTE(3, 0);
#endif /* PRINT_H */
ambiq-hal-sys/ambiq-sparkfun-sdk/third_party/exactle/wsf/sources/util/terminal.c
Vendored
+532
View File
@@ -0,0 +1,532 @@
/*************************************************************************************************/
/*!
* \file terminal.c
*
* \brief Terminal handler.
*
* $Date: 2016-03-29 14:55:12 -0700 (Tue, 29 Mar 2016) $
* $Revision: 6524 $
*
* Copyright (c) 2015-2017 ARM Ltd., all rights reserved.
* ARM confidential and proprietary.
*
* IMPORTANT. Your use of this file is governed by a Software License Agreement
* ("Agreement") that must be accepted in order to download or otherwise receive a
* copy of this file. You may not use or copy this file for any purpose other than
* as described in the Agreement. If you do not agree to all of the terms of the
* Agreement do not use this file and delete all copies in your possession or control;
* if you do not have a copy of the Agreement, you must contact ARM Ltd. prior
* to any use, copying or further distribution of this software.
*/
/*************************************************************************************************/
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include "terminal.h"
#include "print.h"
#include "wsf_types.h"
#include "wsf_assert.h"
#include "wsf_trace.h"
#include "bstream.h"
/**************************************************************************************************
Macros
**************************************************************************************************/
#define TERMINAL_IS_SPACE(c) ((c == '\n') || (c == '\t') || (c == '\r') || (c == ' ') || (c == '\v') || (c == '\f'))
#define TERMINAL_IS_PRINT(c) ((c >= 0x20) && (c != 0x7F))
/*! \brief Terminal events. */
enum
{
TERMINAL_EVENT_COMMAND_RX = (1 << 0)
};
/**************************************************************************************************
Data Types
**************************************************************************************************/
/*! \brief Control block for terminal. */
typedef struct
{
wsfHandlerId_t handlerId; /*!< Handler ID for TerminalHandler(). */
terminalCommand_t *pFirstCommand; /*!< Pointer to first command. */
char buf[TERMINAL_MAX_COMMAND_LEN + 1]; /*!< Command buffer. */
bool_t isExecuting; /*!< TRUE if command in buffer is executing. */
bool_t doEcho; /*!< TRUE if input should be echoed. */
uint32_t bufOffset; /*!< Offset within buffer. */
terminalUartTx_t terminalTx; /*!< Function to transmit via UART. */
} terminalCtrlBlk_t;
/**************************************************************************************************
Local Function Prototypes
**************************************************************************************************/
/*! \brief Help Command Handler */
static uint8_t terminalCommandHelpHandler(uint32_t argc, char **argv);
/*! \brief Echo Command Handler */
static uint8_t terminalCommandEchoHandler(uint32_t argc, char **argv);
/**************************************************************************************************
Local Variables
**************************************************************************************************/
/*! \brief Control block for terminal. */
static terminalCtrlBlk_t terminalCb;
/*! \brief Help command. */
static terminalCommand_t terminalCommandHelp = { NULL, "help", "help", terminalCommandHelpHandler };
/*! \brief Echo command. */
static terminalCommand_t terminalCommandEcho = { NULL, "echo", "echo <on|off>", terminalCommandEchoHandler };
/*************************************************************************************************/
/*!
* \fn TerminalInit
*
* \brief Initialize terminal.
*
* \param handlerId Handler ID for TerminalHandler().
*
* \return None.
*/
/*************************************************************************************************/
void TerminalInit(wsfHandlerId_t handlerId)
{
APP_TRACE_INFO0("terminal: init");
terminalCb.handlerId = handlerId;
terminalCb.pFirstCommand = NULL;
terminalCb.isExecuting = FALSE;
terminalCb.doEcho = TRUE;
terminalCb.bufOffset = 0;
TerminalRegisterCommand(&terminalCommandHelp);
TerminalRegisterCommand(&terminalCommandEcho);
}
/*************************************************************************************************/
/*!
* \fn TerminalRegisterUartTxFunc
*
* \brief Register the UART Tx Function for the platform.
*
* \return None.
*/
/*************************************************************************************************/
void TerminalRegisterUartTxFunc(terminalUartTx_t uartTxFunc)
{
terminalCb.terminalTx = uartTxFunc;
}
/*************************************************************************************************/
/*!
* \fn TerminalRegisterCommand
*
* \brief Register command with terminal.
*
* \param pCommand Command.
*
* \return None.
*/
/*************************************************************************************************/
void TerminalRegisterCommand(terminalCommand_t *pCommand)
{
terminalCommand_t *pCommandTemp = terminalCb.pFirstCommand;
if (pCommandTemp == NULL)
{
terminalCb.pFirstCommand = pCommand;
}
else
{
while (pCommandTemp->pNext != NULL)
{
pCommandTemp = pCommandTemp->pNext;
}
pCommandTemp->pNext = pCommand;
}
pCommand->pNext = NULL;
}
/*************************************************************************************************/
/*!
* \fn terminalExecute
*
* \brief Execute a received command.
*
* \param pBuf Command string.
*
* \return None.
*/
/*************************************************************************************************/
static void terminalExecute(char *pBuf)
{
uint32_t argc = 0;
char *argv[TERMINAL_MAX_ARGC + 1];
uint32_t length;
char *pBufCur;
int state;
enum
{
STATE_OUTSIDE_OF_ARG,
STATE_JUST_GOT_QUOTE,
STATE_INSIDE_OF_ARG,
STATE_INSIDE_OF_ARG_IN_QUOTES
};
/* Parse arguments in command */
state = STATE_OUTSIDE_OF_ARG;
length = strlen(pBuf);
for (pBufCur = pBuf; pBufCur < pBuf + length; pBufCur++)
{
switch (state)
{
case STATE_OUTSIDE_OF_ARG:
{
if (*pBufCur == '\"')
{
state = STATE_JUST_GOT_QUOTE;
}
else if (!TERMINAL_IS_SPACE(*pBufCur))
{
state = STATE_INSIDE_OF_ARG;
if (argc < TERMINAL_MAX_ARGC)
{
argv[argc] = pBufCur;
}
argc++;
}
break;
}
case STATE_JUST_GOT_QUOTE:
{
if (argc < TERMINAL_MAX_ARGC)
{
argv[state] = pBufCur;
}
argc++;
if (*pBufCur == '\"')
{
state = STATE_OUTSIDE_OF_ARG;
*pBufCur = '\0';
}
else
{
state = STATE_INSIDE_OF_ARG_IN_QUOTES;
}
break;
}
case STATE_INSIDE_OF_ARG:
{
if (TERMINAL_IS_SPACE(*pBufCur))
{
state = STATE_OUTSIDE_OF_ARG;
*pBufCur = '\0';
}
else if (*pBufCur == '\"')
{
state = STATE_JUST_GOT_QUOTE;
*pBufCur = '\0';
}
break;
}
case STATE_INSIDE_OF_ARG_IN_QUOTES:
{
if (*pBufCur == '\"')
{
state = STATE_OUTSIDE_OF_ARG;
*pBufCur = '\0';
}
break;
}
}
}
/* Find & invoke command. */
if (argc > TERMINAL_MAX_ARGC)
{
TerminalTxStr(TERMINAL_STRING_ERROR "too many arguments" TERMINAL_STRING_NEW_LINE);
}
else if (argc > 0)
{
terminalCommand_t *pCommand = terminalCb.pFirstCommand;
while (pCommand != NULL)
{
if (strcmp(pCommand->pName, argv[0]) == 0)
{
break;
}
pCommand = pCommand->pNext;
}
if (pCommand == NULL)
{
TerminalTxStr(TERMINAL_STRING_ERROR "unrecognized command \"");
TerminalTxStr(argv[0]);
TerminalTxStr("\"" TERMINAL_STRING_NEW_LINE);
}
else
{
uint8_t r = pCommand->handler(argc, argv);
switch (r)
{
case TERMINAL_ERROR_EXEC:
case TERMINAL_ERROR_OK:
break;
case TERMINAL_ERROR_BAD_ARGUMENTS:
TerminalTxStr(TERMINAL_STRING_ERROR "Invalid argument(s)" TERMINAL_STRING_NEW_LINE);
break;
case TERMINAL_ERROR_TOO_FEW_ARGUMENTS:
TerminalTxStr(TERMINAL_STRING_ERROR "Too few arguments" TERMINAL_STRING_NEW_LINE);
break;
case TERMINAL_ERROR_TOO_MANY_ARGUMENTS:
TerminalTxStr(TERMINAL_STRING_ERROR "Too many arguments" TERMINAL_STRING_NEW_LINE);
break;
default:
TerminalTxStr(TERMINAL_STRING_ERROR "Unknown error" TERMINAL_STRING_NEW_LINE);
break;
}
}
}
}
/*************************************************************************************************/
/*!
* \fn TerminalHandler
*
* \brief Handler for terminal messages.
*
* \param event WSF event mask.
* \param pMsg WSF message.
*
* \return None.
*/
/*************************************************************************************************/
void TerminalHandler(wsfEventMask_t event, wsfMsgHdr_t *pMsg)
{
if ((event & TERMINAL_EVENT_COMMAND_RX) != 0)
{
terminalExecute(terminalCb.buf);
TerminalTxStr(TERMINAL_STRING_PROMPT);
terminalCb.bufOffset = 0;
terminalCb.isExecuting = FALSE;
}
}
/*************************************************************************************************/
/*!
* \fn TerminalRx
*
* \brief Called by application when a data byte is received.
*
* \param dataByte Received byte.
*
* \return None.
*/
/*************************************************************************************************/
void TerminalRx(uint8_t dataByte)
{
/* Hands off buf if command is executing. */
if (!terminalCb.isExecuting)
{
/* If this is the end of a line, signal task. */
if ((dataByte == '\n') || (dataByte == '\r'))
{
TerminalTxStr(TERMINAL_STRING_NEW_LINE);
terminalCb.buf[terminalCb.bufOffset] = '\0';
WsfSetEvent(terminalCb.handlerId, TERMINAL_EVENT_COMMAND_RX);
terminalCb.isExecuting = TRUE;
}
/* Check for delete. */
else if (dataByte == 0x7F)
{
if (terminalCb.bufOffset > 0)
{
terminalCb.bufOffset--;
if (terminalCb.doEcho)
{
TerminalTxStr("\b \b");
}
}
}
/* If we still have room in the buf, put it in buf. Othewise ignore it. */
else if (terminalCb.bufOffset < TERMINAL_MAX_COMMAND_LEN)
{
/* Ignore non-printable characters. */
if (TERMINAL_IS_PRINT(dataByte))
{
terminalCb.buf[terminalCb.bufOffset] = dataByte;
terminalCb.bufOffset++;
if (terminalCb.doEcho)
{
TerminalTxChar(dataByte);
}
}
}
}
}
/*************************************************************************************************/
/*!
* \fn TerminalTxStr
*
* \brief Called by application to transmit string.
*
* \param pStr String.
*
* \return None.
*/
/*************************************************************************************************/
void TerminalTxStr(const char *pStr)
{
TerminalTx((const uint8_t *)pStr, strlen(pStr));
}
/*************************************************************************************************/
/*!
* \fn TerminalTxChar
*
* \brief Called by application to transmit character.
*
* \param c Character.
*
* \return None.
*/
/*************************************************************************************************/
void TerminalTxChar(char c)
{
TerminalTx((const uint8_t *)&c, 1);
}
/*************************************************************************************************/
/*!
* \fn TerminalTxPrint
*
* \brief Called by application to print formatted data.
*
* \param pStr Message format string
* \param ... Additional arguments, printf-style
*
* \return None.
*/
/*************************************************************************************************/
void TerminalTxPrint(const char *pStr, ...)
{
uint32_t len;
char buf[TERMINAL_PRINTF_MAX_LEN];
va_list args;
va_start(args, pStr);
len = PrintVsn(buf, TERMINAL_PRINTF_MAX_LEN, pStr, args);
va_end(args);
TerminalTx((uint8_t *)buf, len);
}
/*************************************************************************************************/
/*!
* \fn terminalCommandHelpHandler
*
* \brief Handler for a terminal command.
*
* \param argc The number of arguments passed to the command.
* \param argv The array of arguments; the 0th argument is the command.
*
* \return Error code.
*/
/*************************************************************************************************/
static uint8_t terminalCommandHelpHandler(uint32_t argc, char **argv)
{
terminalCommand_t *pCommand = terminalCb.pFirstCommand;
if (argc > 1)
{
return TERMINAL_ERROR_TOO_MANY_ARGUMENTS;
}
while (pCommand != NULL)
{
TerminalTxStr(pCommand->pHelpStr);
TerminalTxStr(TERMINAL_STRING_NEW_LINE);
pCommand = pCommand->pNext;
}
TerminalTxStr(TERMINAL_STRING_NEW_LINE);
return TERMINAL_ERROR_OK;
}
/*************************************************************************************************/
/*!
* \fn TerminalTx
*
* \brief Transmit buffer on platform UART.
*
* \param pBuf Buffer to transmit.
* \param len Length of buffer in octets.
*
* \return None.
*/
/*************************************************************************************************/
void TerminalTx(const uint8_t *pData, uint16_t len)
{
WSF_ASSERT(terminalCb.terminalTx);
(*terminalCb.terminalTx)(pData, len);
}
/*************************************************************************************************/
/*!
* \fn terminalCommandEchoHandler
*
* \brief Handler for a terminal command.
*
* \param argc The number of arguments passed to the command.
* \param argv The array of arguments; the 0th argument is the command.
*
* \return Error code.
*/
/*************************************************************************************************/
static uint8_t terminalCommandEchoHandler(uint32_t argc, char **argv)
{
if (argc < 2)
{
return TERMINAL_ERROR_TOO_FEW_ARGUMENTS;
}
else if (argc == 2)
{
if (strcmp(argv[1], "on") == 0)
{
terminalCb.doEcho = TRUE;
TerminalTxStr("echo on" TERMINAL_STRING_NEW_LINE);
}
else if (strcmp(argv[1], "off") == 0)
{
terminalCb.doEcho = FALSE;
TerminalTxStr("echo off" TERMINAL_STRING_NEW_LINE);
}
else
{
return TERMINAL_ERROR_BAD_ARGUMENTS;
}
}
else
{
return TERMINAL_ERROR_TOO_MANY_ARGUMENTS;
}
return TERMINAL_ERROR_OK;
}
ambiq-hal-sys/ambiq-sparkfun-sdk/third_party/exactle/wsf/sources/util/terminal.h
Vendored
+212
View File
@@ -0,0 +1,212 @@
/*************************************************************************************************/
/*!
* \file terminal.h
*
* \brief Terminal handler.
*
* $Date: 2016-12-28 16:12:14 -0600 (Wed, 28 Dec 2016) $
* $Revision: 10805 $
*
* Copyright (c) 2015-2017 ARM Ltd., all rights reserved.
* ARM confidential and proprietary.
*
* IMPORTANT. Your use of this file is governed by a Software License Agreement
* ("Agreement") that must be accepted in order to download or otherwise receive a
* copy of this file. You may not use or copy this file for any purpose other than
* as described in the Agreement. If you do not agree to all of the terms of the
* Agreement do not use this file and delete all copies in your possession or control;
* if you do not have a copy of the Agreement, you must contact ARM Ltd. prior
* to any use, copying or further distribution of this software.
*/
/*************************************************************************************************/
#ifndef TERMINAL_H
#define TERMINAL_H
#include <stdarg.h>
#include "wsf_types.h"
#include "wsf_os.h"
/**************************************************************************************************
Macros
**************************************************************************************************/
#define TERMINAL_MAX_ARGC 8u /*!< Maximum number of arguments to any command. */
#define TERMINAL_MAX_COMMAND_LEN 100u /*!< Maximum length of command line. */
#define TERMINAL_PRINTF_MAX_LEN 128u /*!< Maximum length of any printed output. */
#define TERMINAL_STRING_PROMPT "> " /*!< Prompt string. */
#define TERMINAL_STRING_ERROR "ERROR: " /*!< Error prefix. */
#define TERMINAL_STRING_USAGE "USAGE: " /*!< Usage prefix. */
#define TERMINAL_STRING_NEW_LINE "\r\n" /*!< New line string. */
/*! \brief Terminal command error codes. */
enum
{
TERMINAL_ERROR_OK = 0, /*!< Command completed. */
TERMINAL_ERROR_BAD_ARGUMENTS = 1, /*!< ERROR: Invalid argument(s) */
TERMINAL_ERROR_TOO_FEW_ARGUMENTS = 2, /*!< ERROR: Too few arguments */
TERMINAL_ERROR_TOO_MANY_ARGUMENTS = 3, /*!< ERROR: Too many arguments */
TERMINAL_ERROR_EXEC = 4 /*!< Command completed with execution error. */
};
/**************************************************************************************************
Data Types
**************************************************************************************************/
/*************************************************************************************************/
/*!
* \brief Handler for a terminal command.
*
* \param argc The number of arguments passed to the command.
* \param argv The array of arguments; the 0th argument is the command.
*
* \return Error code.
*/
/*************************************************************************************************/
typedef uint8_t (*terminalHandler_t)(uint32_t argc, char **argv);
/*************************************************************************************************/
/*!
* \brief Handler for transmit.
*
* \param pBuf Buffer to transmit.
* \param len Number of bytes to transmit.
*
* \return None.
*/
/*************************************************************************************************/
typedef void (*terminalUartTx_t)(const uint8_t *pBuf, uint32_t len);
/*! \brief Terminal command. */
typedef struct terminalCommand_tag
{
struct terminalCommand_tag *pNext; /*!< Pointer to next command in list. */
const char *pName; /*!< Name of command. */
const char *pHelpStr; /*!< Help String for command. */
terminalHandler_t handler; /*!< Handler for command. */
} terminalCommand_t;
/**************************************************************************************************
Function Prototypes
**************************************************************************************************/
/*************************************************************************************************/
/*!
* \fn TerminalInit
*
* \brief Initialize terminal.
*
* \param handlerId Handler ID for TerminalHandler().
*
* \return None.
*/
/*************************************************************************************************/
void TerminalInit(wsfHandlerId_t handlerId);
/*************************************************************************************************/
/*!
* \fn TerminalRegisterUartTxFunc
*
* \brief Register the UART Tx Function for the platform.
*
* \return None.
*/
/*************************************************************************************************/
void TerminalRegisterUartTxFunc(terminalUartTx_t uartTxFunc);
/*************************************************************************************************/
/*!
* \fn TerminalRegisterCommand
*
* \brief Register command with terminal.
*
* \param pCommand Command.
*
* \return None.
*/
/*************************************************************************************************/
void TerminalRegisterCommand(terminalCommand_t *pCommand);
/*************************************************************************************************/
/*!
* \fn TerminalHandler
*
* \brief Handler for terminal messages.
*
* \param event WSF event mask.
* \param pMsg WSF message.
*
* \return None.
*/
/*************************************************************************************************/
void TerminalHandler(wsfEventMask_t event, wsfMsgHdr_t *pMsg);
/*************************************************************************************************/
/*!
* \fn TerminalRx
*
* \brief Called by application when a data byte is received.
*
* \param dataByte received byte
*
* \return None.
*/
/*************************************************************************************************/
void TerminalRx(uint8_t dataByte);
/*************************************************************************************************/
/*!
* \fn TerminalTxStr
*
* \brief Called by application to transmit string.
*
* \param pStr String.
*
* \return None.
*/
/*************************************************************************************************/
void TerminalTxStr(const char *pStr);
/*************************************************************************************************/
/*!
* \fn TerminalTxChar
*
* \brief Called by application to transmit character.
*
* \param c Character.
*
* \return None.
*/
/*************************************************************************************************/
void TerminalTxChar(char c);
/*************************************************************************************************/
/*!
* \fn TerminalTxPrint
*
* \brief Called by application to print formatted data.
*
* \param pStr Message format string
* \param ... Additional arguments, printf-style
*
* \return None.
*/
/*************************************************************************************************/
void TerminalTxPrint(const char *pStr, ...);
/*************************************************************************************************/
/*!
* \fn TerminalTx
*
* \brief Application function to transmit data..
*
* \param pData Data.
* \param len Length of data, in bytes.
*
* \return None.
*/
/*************************************************************************************************/
void TerminalTx(const uint8_t *pData, uint16_t len);
#endif /* TERMINAL_H */
ambiq-hal-sys/ambiq-sparkfun-sdk/third_party/exactle/wsf/sources/util/wstr.c
Vendored
+98
View File
@@ -0,0 +1,98 @@
/*************************************************************************************************/
/*!
* \file wstr.c
*
* \brief String manipulation functions.
*
* $Date: 2017-02-14 15:31:43 -0600 (Tue, 14 Feb 2017) $
* $Revision: 11184 $
*
* Copyright (c) 2014-2017 ARM Ltd., all rights reserved.
* ARM Ltd. confidential and proprietary.
*
* IMPORTANT. Your use of this file is governed by a Software License Agreement
* ("Agreement") that must be accepted in order to download or otherwise receive a
* copy of this file. You may not use or copy this file for any purpose other than
* as described in the Agreement. If you do not agree to all of the terms of the
* Agreement do not use this file and delete all copies in your possession or control;
* if you do not have a copy of the Agreement, you must contact ARM Ltd. prior
* to any use, copying or further distribution of this software.
*/
/*************************************************************************************************/
#include <string.h>
#include "wsf_types.h"
#include "wstr.h"
/*************************************************************************************************/
/*!
* \fn WstrnCpy
*
* \brief Copy a string and zero out space after the string length.
*
* \return none.
*/
/*************************************************************************************************/
void WstrnCpy(char *pBuf, const char *pData, uint8_t n)
{
uint8_t i;
uint8_t zeroing = FALSE;
for (i=0; i<n; i++)
{
if (!zeroing && pData[i] == '\0')
zeroing = TRUE;
if (zeroing)
*pBuf++ = 0;
else
*pBuf++ = pData[i];
}
}
/*************************************************************************************************/
/*!
* \fn WStrReverseCpy
*
* \brief Byte by byte reverse and copy a buffer.
*
* \param pBuf1 Buffer to hold reversed copy.
* \param pBuf2 Buffer to copy.
* \param len Size of pBuf1 and pBuf2 in bytes.
*
* \return None.
*/
/*************************************************************************************************/
void WStrReverseCpy(uint8_t *pBuf1, const uint8_t *pBuf2, uint16_t len)
{
int16_t i;
for (i=0; i<len; i++)
{
pBuf1[len-1-i] = pBuf2[i];
}
}
/*************************************************************************************************/
/*!
* \fn WStrReverse
*
* \brief Byte by byte reverse a buffer.
*
* \param pBuf Buffer to reverse.
* \param len size of pBuf in bytes.
*
* \return None.
*/
/*************************************************************************************************/
void WStrReverse(uint8_t *pBuf, uint8_t len)
{
uint8_t i, temp;
for (i=0; i<len/2; i++)
{
temp = pBuf[len-i-1];
pBuf[len-i-1] = pBuf[i];
pBuf[i] = temp;
}
}
ambiq-hal-sys/ambiq-sparkfun-sdk/third_party/exactle/wsf/sources/util/wstr.h
Vendored
+78
View File
@@ -0,0 +1,78 @@
/*************************************************************************************************/
/*!
* \file wstr.h
*
* \brief String manipulation functions.
*
* $Date: 2017-02-14 15:31:43 -0600 (Tue, 14 Feb 2017) $
* $Revision: 11184 $
*
* Copyright (c) 2014-2017 ARM Ltd., all rights reserved.
* ARM Ltd. confidential and proprietary.
*
* IMPORTANT. Your use of this file is governed by a Software License Agreement
* ("Agreement") that must be accepted in order to download or otherwise receive a
* copy of this file. You may not use or copy this file for any purpose other than
* as described in the Agreement. If you do not agree to all of the terms of the
* Agreement do not use this file and delete all copies in your possession or control;
* if you do not have a copy of the Agreement, you must contact ARM Ltd. prior
* to any use, copying or further distribution of this software.
*/
/*************************************************************************************************/
#ifndef WSTR_H
#define WSTR_H
#ifdef __cplusplus
extern "C" {
#endif
/*************************************************************************************************/
/*!
* \fn WstrnCpy
*
* \brief Copies a string up to a given length.
*
* \param pBuf Pointer to buffer to copy to.
* \param pData Pointer to the string to copy.
* \param n Size of pBuf in bytes.
*
* \return none.
*/
/*************************************************************************************************/
void WstrnCpy(char *pBuf, const char *pData, uint8_t n);
/*************************************************************************************************/
/*!
* \fn WStrReverseCpy
*
* \brief Byte by byte reverse and copy a buffer.
*
* \param pBuf1 Buffer to hold reversed copy.
* \param pBuf2 Buffer to copy.
* \param len Size of pBuf1 and pBuf2 in bytes.
*
* \return None.
*/
/*************************************************************************************************/
void WStrReverseCpy(uint8_t *pBuf1, const uint8_t *pBuf2, uint16_t len);
/*************************************************************************************************/
/*!
* \fn WStrReverse
*
* \brief Byte by byte reverse a buffer.
*
* \param pBuf Buffer to reverse.
* \param len size of pBuf in bytes.
*
* \return None.
*/
/*************************************************************************************************/
void WStrReverse(uint8_t *pBuf, uint8_t len);
#ifdef __cplusplus
}
#endif
#endif /* WSTR_H */