Update bt fork to be based on v5.3
This commit is contained in:
jacqueline
@@ -0,0 +1,315 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2015-2021 Espressif Systems (Shanghai) CO LTD
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
#ifndef H_HCI_TRANSPORT_
|
||||
#define H_HCI_TRANSPORT_
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include <inttypes.h>
|
||||
#include "os/os_mempool.h"
|
||||
|
||||
#define BLE_HCI_TRANS_CMD_SZ 260
|
||||
/*** Type of buffers for holding commands and events. */
|
||||
/**
|
||||
* Controller-to-host event buffers. Events have one of two priorities:
|
||||
* o Low-priority (BLE_HCI_TRANS_BUF_EVT_LO)
|
||||
* o High-priority (BLE_HCI_TRANS_BUF_EVT_HI)
|
||||
*
|
||||
* Low-priority event buffers are only used for advertising reports. If there
|
||||
* are no free low-priority event buffers, then an incoming advertising report
|
||||
* will get dropped.
|
||||
*
|
||||
* High-priority event buffers are for everything except advertising reports.
|
||||
* If there are no free high-priority event buffers, a request to allocate one
|
||||
* will try to allocate a low-priority buffer instead.
|
||||
*
|
||||
* If you want all events to be given equal treatment, then you should allocate
|
||||
* low-priority events only.
|
||||
*
|
||||
* Event priorities solve the problem of critical events getting dropped due to
|
||||
* a flood of advertising reports. This solution is likely temporary: when
|
||||
* HCI flow control is added, event priorities may become obsolete.
|
||||
*
|
||||
* Not all transports distinguish between low and high priority events. If the
|
||||
* transport does not have separate settings for low and high buffer counts,
|
||||
* then it treats all events with equal priority.
|
||||
*/
|
||||
#define BLE_HCI_TRANS_BUF_EVT_LO 1
|
||||
#define BLE_HCI_TRANS_BUF_EVT_HI 2
|
||||
|
||||
/* Host-to-controller command. */
|
||||
#define BLE_HCI_TRANS_BUF_CMD 3
|
||||
|
||||
/** Callback function types; executed when HCI packets are received. */
|
||||
typedef int ble_hci_trans_rx_cmd_fn(uint8_t *cmd, void *arg);
|
||||
typedef int ble_hci_trans_rx_acl_fn(struct os_mbuf *om, void *arg);
|
||||
|
||||
#if SOC_ESP_NIMBLE_CONTROLLER && CONFIG_BT_CONTROLLER_ENABLED
|
||||
#define ble_transport_alloc_cmd() ble_hci_trans_buf_alloc(BLE_HCI_TRANS_BUF_CMD)
|
||||
#define ble_transport_alloc_event(X) ble_hci_trans_buf_alloc(X ? BLE_HCI_TRANS_BUF_EVT_LO : BLE_HCI_TRANS_BUF_EVT_HI)
|
||||
#define ble_transport_free ble_hci_trans_buf_free
|
||||
|
||||
struct ble_hci_trans_funcs_t {
|
||||
int(*_ble_hci_trans_hs_acl_tx)(struct os_mbuf *om);
|
||||
int(*_ble_hci_trans_hs_cmd_tx)(uint8_t *cmd);
|
||||
int(*_ble_hci_trans_ll_acl_tx)(struct os_mbuf *om);
|
||||
int(*_ble_hci_trans_ll_evt_tx)(uint8_t *hci_ev);
|
||||
int(*_ble_hci_trans_reset)(void);
|
||||
int(*_ble_hci_trans_set_acl_free_cb)(os_mempool_put_fn *cb, void *arg);
|
||||
};
|
||||
|
||||
extern struct ble_hci_trans_funcs_t *ble_hci_trans_funcs_ptr;
|
||||
|
||||
/**
|
||||
* Sends an HCI event from the controller to the host.
|
||||
*
|
||||
* @param cmd The HCI event to send. This buffer must be
|
||||
* allocated via ble_hci_trans_buf_alloc().
|
||||
*
|
||||
* @return 0 on success;
|
||||
* A BLE_ERR_[...] error code on failure.
|
||||
*/
|
||||
extern int r_ble_hci_trans_ll_evt_tx(uint8_t *hci_ev);
|
||||
#define ble_hci_trans_ll_evt_tx ble_hci_trans_funcs_ptr->_ble_hci_trans_ll_evt_tx
|
||||
|
||||
/**
|
||||
* Sends ACL data from controller to host.
|
||||
*
|
||||
* @param om The ACL data packet to send.
|
||||
*
|
||||
* @return 0 on success;
|
||||
* A BLE_ERR_[...] error code on failure.
|
||||
*/
|
||||
extern int r_ble_hci_trans_ll_acl_tx(struct os_mbuf *om);
|
||||
#define ble_hci_trans_ll_acl_tx ble_hci_trans_funcs_ptr->_ble_hci_trans_ll_acl_tx
|
||||
|
||||
/**
|
||||
* Sends an HCI command from the host to the controller.
|
||||
*
|
||||
* @param cmd The HCI command to send. This buffer must be
|
||||
* allocated via ble_hci_trans_buf_alloc().
|
||||
*
|
||||
* @return 0 on success;
|
||||
* A BLE_ERR_[...] error code on failure.
|
||||
*/
|
||||
extern int r_ble_hci_trans_hs_cmd_tx(uint8_t *cmd);
|
||||
#define ble_hci_trans_hs_cmd_tx ble_hci_trans_funcs_ptr->_ble_hci_trans_hs_cmd_tx
|
||||
|
||||
/**
|
||||
* Sends ACL data from host to controller.
|
||||
*
|
||||
* @param om The ACL data packet to send.
|
||||
*
|
||||
* @return 0 on success;
|
||||
* A BLE_ERR_[...] error code on failure.
|
||||
*/
|
||||
extern int r_ble_hci_trans_hs_acl_tx(struct os_mbuf *om);
|
||||
#define ble_hci_trans_hs_acl_tx ble_hci_trans_funcs_ptr->_ble_hci_trans_hs_acl_tx
|
||||
|
||||
/**
|
||||
* Allocates a flat buffer of the specified type.
|
||||
*
|
||||
* @param type The type of buffer to allocate; one of the
|
||||
* BLE_HCI_TRANS_BUF_[...] constants.
|
||||
*
|
||||
* @return The allocated buffer on success;
|
||||
* NULL on buffer exhaustion.
|
||||
*/
|
||||
extern uint8_t *r_ble_hci_trans_buf_alloc(int type);
|
||||
#define ble_hci_trans_buf_alloc r_ble_hci_trans_buf_alloc
|
||||
|
||||
/**
|
||||
* Frees the specified flat buffer. The buffer must have been allocated via
|
||||
* ble_hci_trans_buf_alloc().
|
||||
*
|
||||
* @param buf The buffer to free.
|
||||
*/
|
||||
extern void r_ble_hci_trans_buf_free(uint8_t *buf);
|
||||
#define ble_hci_trans_buf_free r_ble_hci_trans_buf_free
|
||||
|
||||
/**
|
||||
* Configures a callback to get executed whenever an ACL data packet is freed.
|
||||
* The function is called immediately before the free occurs.
|
||||
*
|
||||
* @param cb The callback to configure.
|
||||
* @param arg An optional argument to pass to the callback.
|
||||
*
|
||||
* @return 0 on success;
|
||||
* BLE_ERR_UNSUPPORTED if the transport does not
|
||||
* support this operation.
|
||||
*/
|
||||
extern int r_ble_hci_trans_set_acl_free_cb(os_mempool_put_fn *cb, void *arg);
|
||||
#define ble_hci_trans_set_acl_free_cb ble_hci_trans_funcs_ptr->_ble_hci_trans_set_acl_free_cb
|
||||
|
||||
/**
|
||||
* Configures the HCI transport to operate with a controller. The transport
|
||||
* will execute specified callbacks upon receiving HCI packets from the host.
|
||||
*
|
||||
* @param cmd_cb The callback to execute upon receiving an HCI
|
||||
* command.
|
||||
* @param cmd_arg Optional argument to pass to the command
|
||||
* callback.
|
||||
* @param acl_cb The callback to execute upon receiving ACL
|
||||
* data.
|
||||
* @param acl_arg Optional argument to pass to the ACL
|
||||
* callback.
|
||||
*/
|
||||
extern void r_ble_hci_trans_cfg_ll(ble_hci_trans_rx_cmd_fn *cmd_cb,
|
||||
void *cmd_arg,
|
||||
ble_hci_trans_rx_acl_fn *acl_cb,
|
||||
void *acl_arg);
|
||||
#define ble_hci_trans_cfg_ll r_ble_hci_trans_cfg_ll
|
||||
|
||||
/**
|
||||
* Configures the HCI transport to operate with a host. The transport will
|
||||
* execute specified callbacks upon receiving HCI packets from the controller.
|
||||
*
|
||||
* @param evt_cb The callback to execute upon receiving an HCI
|
||||
* event.
|
||||
* @param evt_arg Optional argument to pass to the event
|
||||
* callback.
|
||||
* @param acl_cb The callback to execute upon receiving ACL
|
||||
* data.
|
||||
* @param acl_arg Optional argument to pass to the ACL
|
||||
* callback.
|
||||
*/
|
||||
extern void r_ble_hci_trans_cfg_hs(ble_hci_trans_rx_cmd_fn *evt_cb,
|
||||
void *evt_arg,
|
||||
ble_hci_trans_rx_acl_fn *acl_cb,
|
||||
void *acl_arg);
|
||||
#define ble_hci_trans_cfg_hs r_ble_hci_trans_cfg_hs
|
||||
|
||||
/**
|
||||
* Resets the HCI module to a clean state. Frees all buffers and reinitializes
|
||||
* the underlying transport.
|
||||
*
|
||||
* @return 0 on success;
|
||||
* A BLE_ERR_[...] error code on failure.
|
||||
*/
|
||||
extern int r_ble_hci_trans_reset(void);
|
||||
#define ble_hci_trans_reset ble_hci_trans_funcs_ptr->_ble_hci_trans_reset
|
||||
|
||||
void esp_ble_hci_trans_init(uint8_t);
|
||||
|
||||
#else
|
||||
/**
|
||||
* Sends an HCI event from the controller to the host.
|
||||
*
|
||||
* @param cmd The HCI event to send. This buffer must be
|
||||
* allocated via ble_hci_trans_buf_alloc().
|
||||
*
|
||||
* @return 0 on success;
|
||||
* A BLE_ERR_[...] error code on failure.
|
||||
*/
|
||||
int ble_hci_trans_ll_evt_tx(uint8_t *hci_ev);
|
||||
|
||||
/**
|
||||
* Sends ACL data from controller to host.
|
||||
*
|
||||
* @param om The ACL data packet to send.
|
||||
*
|
||||
* @return 0 on success;
|
||||
* A BLE_ERR_[...] error code on failure.
|
||||
*/
|
||||
int ble_hci_trans_ll_acl_tx(struct os_mbuf *om);
|
||||
|
||||
/**
|
||||
* Sends an HCI command from the host to the controller.
|
||||
*
|
||||
* @param cmd The HCI command to send. This buffer must be
|
||||
* allocated via ble_hci_trans_buf_alloc().
|
||||
*
|
||||
* @return 0 on success;
|
||||
* A BLE_ERR_[...] error code on failure.
|
||||
*/
|
||||
int ble_hci_trans_hs_cmd_tx(uint8_t *cmd);
|
||||
|
||||
/**
|
||||
* Sends ACL data from host to controller.
|
||||
*
|
||||
* @param om The ACL data packet to send.
|
||||
*
|
||||
* @return 0 on success;
|
||||
* A BLE_ERR_[...] error code on failure.
|
||||
*/
|
||||
int ble_hci_trans_hs_acl_tx(struct os_mbuf *om);
|
||||
|
||||
/**
|
||||
* Allocates a flat buffer of the specified type.
|
||||
*
|
||||
* @param type The type of buffer to allocate; one of the
|
||||
* BLE_HCI_TRANS_BUF_[...] constants.
|
||||
*
|
||||
* @return The allocated buffer on success;
|
||||
* NULL on buffer exhaustion.
|
||||
*/
|
||||
int esp_ble_hci_trans_hs_cmd_tx(uint8_t *cmd);
|
||||
|
||||
/**
|
||||
* Sends ACL data from host to controller.
|
||||
*
|
||||
* @param om The ACL data packet to send.
|
||||
*
|
||||
* @return 0 on success;
|
||||
* A BLE_ERR_[...] error code on failure.
|
||||
*/
|
||||
int esp_ble_hci_trans_hs_acl_tx(struct os_mbuf *om);
|
||||
|
||||
/**
|
||||
* Allocates a flat buffer of the specified type.
|
||||
*
|
||||
* @param type The type of buffer to allocate; one of the
|
||||
* BLE_HCI_TRANS_BUF_[...] constants.
|
||||
*
|
||||
* @return The allocated buffer on success;
|
||||
* NULL on buffer exhaustion.
|
||||
*/
|
||||
uint8_t *esp_ble_hci_trans_buf_alloc(int type);
|
||||
|
||||
/**
|
||||
* Frees the specified flat buffer. The buffer must have been allocated via
|
||||
* ble_hci_trans_buf_alloc().
|
||||
*
|
||||
* @param buf The buffer to free.
|
||||
*/
|
||||
void esp_ble_hci_trans_buf_free(uint8_t *buf);
|
||||
|
||||
/**
|
||||
* Configures the HCI transport to operate with a host. The transport will
|
||||
* execute specified callbacks upon receiving HCI packets from the controller.
|
||||
*
|
||||
* @param evt_cb The callback to execute upon receiving an HCI
|
||||
* event.
|
||||
* @param evt_arg Optional argument to pass to the event
|
||||
* callback.
|
||||
* @param acl_cb The callback to execute upon receiving ACL
|
||||
* data.
|
||||
* @param acl_arg Optional argument to pass to the ACL
|
||||
* callback.
|
||||
*/
|
||||
void esp_ble_hci_trans_cfg_hs(ble_hci_trans_rx_cmd_fn *evt_cb,
|
||||
void *evt_arg,
|
||||
ble_hci_trans_rx_acl_fn *acl_cb,
|
||||
void *acl_arg);
|
||||
|
||||
/**
|
||||
* Resets the HCI module to a clean state. Frees all buffers and reinitializes
|
||||
* the underlying transport.
|
||||
*
|
||||
* @return 0 on success;
|
||||
* A BLE_ERR_[...] error code on failure.
|
||||
*/
|
||||
int esp_ble_hci_trans_reset(void);
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* H_HCI_TRANSPORT_ */
|
||||
@@ -0,0 +1,21 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2015-2021 Espressif Systems (Shanghai) CO LTD
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "sdkconfig.h"
|
||||
#include "esp_attr.h"
|
||||
#include "esp_heap_caps.h"
|
||||
|
||||
void *bt_osi_mem_malloc(size_t size);
|
||||
|
||||
void *bt_osi_mem_calloc(size_t n, size_t size);
|
||||
|
||||
void *bt_osi_mem_malloc_internal(size_t size);
|
||||
|
||||
void *bt_osi_mem_calloc_internal(size_t n, size_t size);
|
||||
|
||||
void bt_osi_mem_free(void *ptr);
|
||||
@@ -0,0 +1,296 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2015-2022 The Apache Software Foundation (ASF)
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* SPDX-FileContributor: 2019-2022 Espressif Systems (Shanghai) CO LTD
|
||||
*/
|
||||
/*
|
||||
* Licensed to the Apache Software Foundation (ASF) under one
|
||||
* or more contributor license agreements. See the NOTICE file
|
||||
* distributed with this work for additional information
|
||||
* regarding copyright ownership. The ASF licenses this file
|
||||
* to you under the Apache License, Version 2.0 (the
|
||||
* "License"); you may not use this file except in compliance
|
||||
* with the License. You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing,
|
||||
* software distributed under the License is distributed on an
|
||||
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
||||
* KIND, either express or implied. See the License for the
|
||||
* specific language governing permissions and limitations
|
||||
* under the License.
|
||||
*/
|
||||
|
||||
#ifndef H_ENDIAN_
|
||||
#define H_ENDIAN_
|
||||
|
||||
#include <inttypes.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* Internal helpers */
|
||||
#ifndef os_bswap_64
|
||||
#define os_bswap_64(x) ((uint64_t) \
|
||||
((((x) & 0xff00000000000000ull) >> 56) | \
|
||||
(((x) & 0x00ff000000000000ull) >> 40) | \
|
||||
(((x) & 0x0000ff0000000000ull) >> 24) | \
|
||||
(((x) & 0x000000ff00000000ull) >> 8) | \
|
||||
(((x) & 0x00000000ff000000ull) << 8) | \
|
||||
(((x) & 0x0000000000ff0000ull) << 24) | \
|
||||
(((x) & 0x000000000000ff00ull) << 40) | \
|
||||
(((x) & 0x00000000000000ffull) << 56)))
|
||||
#endif
|
||||
|
||||
#ifndef os_bswap_32
|
||||
#define os_bswap_32(x) ((uint32_t) \
|
||||
((((x) & 0xff000000) >> 24) | \
|
||||
(((x) & 0x00ff0000) >> 8) | \
|
||||
(((x) & 0x0000ff00) << 8) | \
|
||||
(((x) & 0x000000ff) << 24)))
|
||||
#endif
|
||||
|
||||
#ifndef os_bswap_16
|
||||
#define os_bswap_16(x) ((uint16_t) \
|
||||
((((x) & 0xff00) >> 8) | \
|
||||
(((x) & 0x00ff) << 8)))
|
||||
#endif
|
||||
|
||||
#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
|
||||
|
||||
#ifndef ntohll
|
||||
#define ntohll(x) ((uint64_t)(x))
|
||||
#endif
|
||||
|
||||
#ifndef htonll
|
||||
#define htonll(x) ((uint64_t)(x))
|
||||
#endif
|
||||
|
||||
#ifndef ntohl
|
||||
#define ntohl(x) ((uint32_t)(x))
|
||||
#endif
|
||||
|
||||
#ifndef htonl
|
||||
#define htonl(x) ((uint32_t)(x))
|
||||
#endif
|
||||
|
||||
#ifndef ntohs
|
||||
#define ntohs(x) ((uint16_t)(x))
|
||||
#endif
|
||||
|
||||
#ifndef htons
|
||||
#define htons(x) ((uint16_t)(x))
|
||||
#endif
|
||||
|
||||
#ifndef htobe16
|
||||
#define htobe16(x) ((uint16_t)(x))
|
||||
#endif
|
||||
|
||||
#ifndef htole16
|
||||
#define htole16(x) os_bswap_16 (x)
|
||||
#endif
|
||||
|
||||
#ifndef be16toh
|
||||
#define be16toh(x) ((uint16_t)(x))
|
||||
#endif
|
||||
|
||||
#ifndef le16toh
|
||||
#define le16toh(x) os_bswap_16 (x)
|
||||
#endif
|
||||
|
||||
#ifndef htobe32
|
||||
#define htobe32(x) ((uint32_t)(x))
|
||||
#endif
|
||||
|
||||
#ifndef htole32
|
||||
#define htole32(x) os_bswap_32 (x)
|
||||
#endif
|
||||
|
||||
#ifndef be32toh
|
||||
#define be32toh(x) ((uint32_t)(x))
|
||||
#endif
|
||||
|
||||
#ifndef le32toh
|
||||
#define le32toh(x) os_bswap_32 (x)
|
||||
#endif
|
||||
|
||||
#ifndef htobe64
|
||||
#define htobe64(x) ((uint64_t)(x))
|
||||
#endif
|
||||
|
||||
#ifndef htole64
|
||||
#define htole64(x) os_bswap_64 (x)
|
||||
#endif
|
||||
|
||||
#ifndef be64toh
|
||||
#define be64toh(x) ((uint64_t)(x))
|
||||
#endif
|
||||
|
||||
#ifndef le64toh
|
||||
#define le64toh(x) os_bswap_64 (x)
|
||||
#endif
|
||||
|
||||
#else
|
||||
|
||||
#ifndef ntohll
|
||||
#define ntohll(x) os_bswap_64(x)
|
||||
#endif
|
||||
|
||||
#ifndef htonll
|
||||
#define htonll ntohll
|
||||
#endif
|
||||
|
||||
/* These are not used in NimBLE and ESP-IDF uses them from LwIP */
|
||||
#if 0
|
||||
#ifndef ntohl
|
||||
#define ntohl(x) os_bswap_32(x)
|
||||
#endif
|
||||
|
||||
#ifndef htonl
|
||||
#define htonl ntohl
|
||||
#endif
|
||||
|
||||
#ifndef htons
|
||||
#define htons(x) os_bswap_16(x)
|
||||
#endif
|
||||
|
||||
#ifndef ntohs
|
||||
#define ntohs htons
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef htobe16
|
||||
#define htobe16(x) os_bswap_16(x)
|
||||
#endif
|
||||
|
||||
#ifndef htole16
|
||||
#define htole16(x) ((uint16_t)(x))
|
||||
#endif
|
||||
|
||||
#ifndef be16toh
|
||||
#define be16toh(x) os_bswap_16(x)
|
||||
#endif
|
||||
|
||||
#ifndef le16toh
|
||||
#define le16toh(x) ((uint16_t)(x))
|
||||
#endif
|
||||
|
||||
#ifndef htobe32
|
||||
#define htobe32(x) os_bswap_32(x)
|
||||
#endif
|
||||
|
||||
#ifndef htole32
|
||||
#define htole32(x) ((uint32_t)(x))
|
||||
#endif
|
||||
|
||||
#ifndef be32toh
|
||||
#define be32toh(x) os_bswap_32(x)
|
||||
#endif
|
||||
|
||||
#ifndef le32toh
|
||||
#define le32toh(x) ((uint32_t)(x))
|
||||
#endif
|
||||
|
||||
#ifndef htobe64
|
||||
#define htobe64(x) os_bswap_64(x)
|
||||
#endif
|
||||
|
||||
#ifndef htole64
|
||||
#define htole64(x) ((uint64_t)(x))
|
||||
#endif
|
||||
|
||||
#ifndef be64toh
|
||||
#define be64toh(x) os_bswap_64(x)
|
||||
#endif
|
||||
|
||||
#ifndef le64toh
|
||||
#define le64toh(x) ((uint64_t)(x))
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
#if SOC_ESP_NIMBLE_CONTROLLER && CONFIG_BT_CONTROLLER_ENABLED
|
||||
void r_put_le16(void *buf, uint16_t x);
|
||||
#define put_le16 r_put_le16
|
||||
|
||||
void r_put_le24(void *buf, uint32_t x);
|
||||
#define put_le24 r_put_le24
|
||||
|
||||
void r_put_le32(void *buf, uint32_t x);
|
||||
#define put_le32 r_put_le32
|
||||
|
||||
void r_put_le64(void *buf, uint64_t x);
|
||||
#define put_le64 r_put_le64
|
||||
|
||||
uint16_t r_get_le16(const void *buf);
|
||||
#define get_le16 r_get_le16
|
||||
|
||||
uint32_t r_get_le24(const void *buf);
|
||||
#define get_le24 r_get_le24
|
||||
|
||||
uint32_t r_get_le32(const void *buf);
|
||||
#define get_le32 r_get_le32
|
||||
|
||||
uint64_t r_get_le64(const void *buf);
|
||||
#define get_le64 r_get_le64
|
||||
|
||||
void r_put_be16(void *buf, uint16_t x);
|
||||
#define put_be16 r_put_be16
|
||||
|
||||
void r_put_be24(void *buf, uint32_t x);
|
||||
#define put_be24 r_put_be24
|
||||
|
||||
void r_put_be32(void *buf, uint32_t x);
|
||||
#define put_be32 r_put_be32
|
||||
|
||||
void r_put_be64(void *buf, uint64_t x);
|
||||
#define put_be64 r_put_be64
|
||||
|
||||
uint16_t r_get_be16(const void *buf);
|
||||
#define get_be16 r_get_be16
|
||||
|
||||
uint32_t r_get_be24(const void *buf);
|
||||
#define get_be24 r_get_be24
|
||||
|
||||
uint32_t r_get_be32(const void *buf);
|
||||
#define get_be32 r_get_be32
|
||||
|
||||
uint64_t r_get_be64(const void *buf);
|
||||
#define get_be64 r_get_be64
|
||||
|
||||
void r_swap_in_place(void *buf, int len);
|
||||
#define swap_in_place r_swap_in_place
|
||||
|
||||
void r_swap_buf(uint8_t *dst, const uint8_t *src, int len);
|
||||
#define swap_buf r_swap_buf
|
||||
|
||||
|
||||
#else
|
||||
void put_le16(void *buf, uint16_t x);
|
||||
void put_le24(void *buf, uint32_t x);
|
||||
void put_le32(void *buf, uint32_t x);
|
||||
void put_le64(void *buf, uint64_t x);
|
||||
uint16_t get_le16(const void *buf);
|
||||
uint32_t get_le24(const void *buf);
|
||||
uint32_t get_le32(const void *buf);
|
||||
uint64_t get_le64(const void *buf);
|
||||
void put_be16(void *buf, uint16_t x);
|
||||
void put_be24(void *buf, uint32_t x);
|
||||
void put_be32(void *buf, uint32_t x);
|
||||
void put_be64(void *buf, uint64_t x);
|
||||
uint16_t get_be16(const void *buf);
|
||||
uint32_t get_be24(const void *buf);
|
||||
uint32_t get_be32(const void *buf);
|
||||
uint64_t get_be64(const void *buf);
|
||||
void swap_in_place(void *buf, int len);
|
||||
void swap_buf(uint8_t *dst, const uint8_t *src, int len);
|
||||
#endif
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,66 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2015-2022 The Apache Software Foundation (ASF)
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* SPDX-FileContributor: 2019-2022 Espressif Systems (Shanghai) CO LTD
|
||||
*/
|
||||
/*
|
||||
* Licensed to the Apache Software Foundation (ASF) under one
|
||||
* or more contributor license agreements. See the NOTICE file
|
||||
* distributed with this work for additional information
|
||||
* regarding copyright ownership. The ASF licenses this file
|
||||
* to you under the Apache License, Version 2.0 (the
|
||||
* "License"); you may not use this file except in compliance
|
||||
* with the License. You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing,
|
||||
* software distributed under the License is distributed on an
|
||||
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
||||
* KIND, either express or implied. See the License for the
|
||||
* specific language governing permissions and limitations
|
||||
* under the License.
|
||||
*/
|
||||
|
||||
#ifndef _OS_H
|
||||
#define _OS_H
|
||||
|
||||
#include <assert.h>
|
||||
#include "esp_assert.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#if !defined __cplusplus && !defined static_assert
|
||||
#define static_assert _Static_assert
|
||||
#endif
|
||||
|
||||
#include "nimble/nimble_npl.h"
|
||||
|
||||
#define OS_ALIGN(__n, __a) ( \
|
||||
(((__n) & ((__a) - 1)) == 0) ? \
|
||||
(__n) : \
|
||||
((__n) + ((__a) - ((__n) & ((__a) - 1)))) \
|
||||
)
|
||||
#define OS_ALIGNMENT (BLE_NPL_OS_ALIGNMENT)
|
||||
|
||||
typedef uint32_t os_sr_t;
|
||||
#define OS_ENTER_CRITICAL(_sr) (_sr = ble_npl_hw_enter_critical())
|
||||
#define OS_EXIT_CRITICAL(_sr) (ble_npl_hw_exit_critical(_sr))
|
||||
#define OS_ASSERT_CRITICAL() assert(ble_npl_hw_is_in_critical())
|
||||
|
||||
/* Mynewt components (not abstracted in NPL) */
|
||||
#include "os/endian.h"
|
||||
#include "os/queue.h"
|
||||
#include "os/os_error.h"
|
||||
#include "os/os_mbuf.h"
|
||||
#include "os/os_mempool.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* _OS_H */
|
||||
@@ -0,0 +1,69 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2015-2022 The Apache Software Foundation (ASF)
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* SPDX-FileContributor: 2019-2022 Espressif Systems (Shanghai) CO LTD
|
||||
*/
|
||||
/*
|
||||
* Licensed to the Apache Software Foundation (ASF) under one
|
||||
* or more contributor license agreements. See the NOTICE file
|
||||
* distributed with this work for additional information
|
||||
* regarding copyright ownership. The ASF licenses this file
|
||||
* to you under the Apache License, Version 2.0 (the
|
||||
* "License"); you may not use this file except in compliance
|
||||
* with the License. You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing,
|
||||
* software distributed under the License is distributed on an
|
||||
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
||||
* KIND, either express or implied. See the License for the
|
||||
* specific language governing permissions and limitations
|
||||
* under the License.
|
||||
*/
|
||||
|
||||
#ifndef H_OS_ERROR_
|
||||
#define H_OS_ERROR_
|
||||
|
||||
#include "os/os.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* OS error enumerations */
|
||||
enum os_error {
|
||||
OS_OK = 0,
|
||||
OS_ENOMEM = 1,
|
||||
OS_EINVAL = 2,
|
||||
OS_INVALID_PARM = 3,
|
||||
OS_MEM_NOT_ALIGNED = 4,
|
||||
OS_BAD_MUTEX = 5,
|
||||
OS_TIMEOUT = 6,
|
||||
OS_ERR_IN_ISR = 7, /* Function cannot be called from ISR */
|
||||
OS_ERR_PRIV = 8, /* Privileged access error */
|
||||
OS_NOT_STARTED = 9, /* OS must be started to call this function, but isn't */
|
||||
OS_ENOENT = 10, /* No such thing */
|
||||
OS_EBUSY = 11, /* Resource busy */
|
||||
OS_ERROR = 12, /* Generic Error */
|
||||
};
|
||||
|
||||
typedef enum os_error os_error_t;
|
||||
|
||||
/**
|
||||
* @brief Converts an OS error code (`OS_[...]`) to an equivalent system error
|
||||
* code (`SYS_E[...]`).
|
||||
*
|
||||
* @param os_error The OS error code to convert.
|
||||
*
|
||||
* @return The equivalent system error code.
|
||||
*/
|
||||
int os_error_to_sys(os_error_t os_error);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,407 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2015-2022 The Apache Software Foundation (ASF)
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* SPDX-FileContributor: 2019-2022 Espressif Systems (Shanghai) CO LTD
|
||||
*/
|
||||
/*
|
||||
* Licensed to the Apache Software Foundation (ASF) under one
|
||||
* or more contributor license agreements. See the NOTICE file
|
||||
* distributed with this work for additional information
|
||||
* regarding copyright ownership. The ASF licenses this file
|
||||
* to you under the Apache License, Version 2.0 (the
|
||||
* "License"); you may not use this file except in compliance
|
||||
* with the License. You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing,
|
||||
* software distributed under the License is distributed on an
|
||||
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
||||
* KIND, either express or implied. See the License for the
|
||||
* specific language governing permissions and limitations
|
||||
* under the License.
|
||||
*/
|
||||
|
||||
/**
|
||||
* @addtogroup OSKernel
|
||||
* @{
|
||||
* @defgroup OSMempool Memory Pools
|
||||
* @{
|
||||
*/
|
||||
|
||||
|
||||
#ifndef _OS_MEMPOOL_H_
|
||||
#define _OS_MEMPOOL_H_
|
||||
|
||||
#include <stdbool.h>
|
||||
#include "os/os.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/**
|
||||
* A memory block structure. This simply contains a pointer to the free list
|
||||
* chain and is only used when the block is on the free list. When the block
|
||||
* has been removed from the free list the entire memory block is usable by the
|
||||
* caller.
|
||||
*/
|
||||
struct os_memblock {
|
||||
SLIST_ENTRY(os_memblock) mb_next;
|
||||
};
|
||||
|
||||
/* XXX: Change this structure so that we keep the first address in the pool? */
|
||||
/* XXX: add memory debug structure and associated code */
|
||||
/* XXX: Change how I coded the SLIST_HEAD here. It should be named:
|
||||
SLIST_HEAD(,os_memblock) mp_head; */
|
||||
|
||||
/**
|
||||
* Memory pool
|
||||
*/
|
||||
struct os_mempool {
|
||||
/** Size of the memory blocks, in bytes. */
|
||||
uint32_t mp_block_size;
|
||||
/** The number of memory blocks. */
|
||||
uint16_t mp_num_blocks;
|
||||
/** The number of free blocks left */
|
||||
uint16_t mp_num_free;
|
||||
/** The lowest number of free blocks seen */
|
||||
uint16_t mp_min_free;
|
||||
/** Bitmap of OS_MEMPOOL_F_[...] values. */
|
||||
uint8_t mp_flags;
|
||||
/** Address of memory buffer used by pool */
|
||||
uint32_t mp_membuf_addr;
|
||||
STAILQ_ENTRY(os_mempool) mp_list;
|
||||
SLIST_HEAD(,os_memblock);
|
||||
/** Name for memory block */
|
||||
const char *name;
|
||||
};
|
||||
|
||||
/**
|
||||
* Indicates an extended mempool. Address can be safely cast to
|
||||
* (struct os_mempool_ext *).
|
||||
*/
|
||||
#define OS_MEMPOOL_F_EXT 0x01
|
||||
|
||||
struct os_mempool_ext;
|
||||
|
||||
/**
|
||||
* Block put callback function. If configured, this callback gets executed
|
||||
* whenever a block is freed to the corresponding extended mempool. Note: The
|
||||
* os_memblock_put() function calls this callback instead of freeing the block
|
||||
* itself. Therefore, it is the callback's responsibility to free the block
|
||||
* via a call to os_memblock_put_from_cb().
|
||||
*
|
||||
* @param ome The extended mempool that a block is being
|
||||
* freed back to.
|
||||
* @param data The block being freed.
|
||||
* @param arg Optional argument configured along with the
|
||||
* callback.
|
||||
*
|
||||
* @return Indicates whether the block was successfully
|
||||
* freed. A non-zero value should only be
|
||||
* returned if the block was not successfully
|
||||
* released back to its pool.
|
||||
*/
|
||||
typedef os_error_t os_mempool_put_fn(struct os_mempool_ext *ome, void *data,
|
||||
void *arg);
|
||||
|
||||
struct os_mempool_ext {
|
||||
struct os_mempool mpe_mp;
|
||||
|
||||
/* Callback that is executed immediately when a block is freed. */
|
||||
os_mempool_put_fn *mpe_put_cb;
|
||||
void *mpe_put_arg;
|
||||
};
|
||||
|
||||
#define OS_MEMPOOL_INFO_NAME_LEN (32)
|
||||
|
||||
/**
|
||||
* Information describing a memory pool, used to return OS information
|
||||
* to the management layer.
|
||||
*/
|
||||
struct os_mempool_info {
|
||||
/** Size of the memory blocks in the pool */
|
||||
int omi_block_size;
|
||||
/** Number of memory blocks in the pool */
|
||||
int omi_num_blocks;
|
||||
/** Number of free memory blocks */
|
||||
int omi_num_free;
|
||||
/** Minimum number of free memory blocks ever */
|
||||
int omi_min_free;
|
||||
/** Name of the memory pool */
|
||||
char omi_name[OS_MEMPOOL_INFO_NAME_LEN];
|
||||
};
|
||||
|
||||
/**
|
||||
* Get information about the next system memory pool.
|
||||
*
|
||||
* @param mempool The current memory pool, or NULL if starting iteration.
|
||||
* @param info A pointer to the structure to return memory pool information
|
||||
* into.
|
||||
*
|
||||
* @return The next memory pool in the list to get information about, or NULL
|
||||
* when at the last memory pool.
|
||||
*/
|
||||
struct os_mempool *os_mempool_info_get_next(struct os_mempool *,
|
||||
struct os_mempool_info *);
|
||||
|
||||
#if (OS_ALIGNMENT == 4)
|
||||
typedef uint32_t os_membuf_t;
|
||||
#elif (OS_ALIGNMENT == 8)
|
||||
typedef uint64_t os_membuf_t;
|
||||
#elif (OS_ALIGNMENT == 16)
|
||||
typedef __uint128_t os_membuf_t;
|
||||
#else
|
||||
#error "Unhandled `OS_ALIGNMENT` for `os_membuf_t`"
|
||||
#endif /* OS_ALIGNMENT == * */
|
||||
#define OS_MEMPOOL_SIZE(n,blksize) ((((blksize) + ((OS_ALIGNMENT)-1)) / (OS_ALIGNMENT)) * (n))
|
||||
|
||||
/** Calculates the number of bytes required to initialize a memory pool. */
|
||||
#define OS_MEMPOOL_BYTES(n,blksize) \
|
||||
(sizeof (os_membuf_t) * OS_MEMPOOL_SIZE((n), (blksize)))
|
||||
|
||||
#if SOC_ESP_NIMBLE_CONTROLLER && CONFIG_BT_CONTROLLER_ENABLED
|
||||
/**
|
||||
* Initialize a memory pool.
|
||||
*
|
||||
* @param mp Pointer to a pointer to a mempool
|
||||
* @param blocks The number of blocks in the pool
|
||||
* @param blocks_size The size of the block, in bytes.
|
||||
* @param membuf Pointer to memory to contain blocks.
|
||||
* @param name Name of the pool.
|
||||
*
|
||||
* @return os_error_t
|
||||
*/
|
||||
os_error_t r_os_mempool_init(struct os_mempool *mp, uint16_t blocks,
|
||||
uint32_t block_size, void *membuf, const char *name);
|
||||
#define os_mempool_init r_os_mempool_init
|
||||
/**
|
||||
* Initializes an extended memory pool. Extended attributes (e.g., callbacks)
|
||||
* are not specified when this function is called; they are assigned manually
|
||||
* after initialization.
|
||||
*
|
||||
* @param mpe The extended memory pool to initialize.
|
||||
* @param blocks The number of blocks in the pool.
|
||||
* @param block_size The size of each block, in bytes.
|
||||
* @param membuf Pointer to memory to contain blocks.
|
||||
* @param name Name of the pool.
|
||||
*
|
||||
* @return os_error_t
|
||||
*/
|
||||
os_error_t r_os_mempool_ext_init(struct os_mempool_ext *mpe, uint16_t blocks,
|
||||
uint32_t block_size, void *membuf, const char *name);
|
||||
#define os_mempool_ext_init r_os_mempool_ext_init
|
||||
/**
|
||||
* Removes the specified mempool from the list of initialized mempools.
|
||||
*
|
||||
* @param mp The mempool to unregister.
|
||||
*
|
||||
* @return 0 on success;
|
||||
* OS_INVALID_PARM if the mempool is not
|
||||
* registered.
|
||||
*/
|
||||
os_error_t r_os_mempool_unregister(struct os_mempool *mp);
|
||||
#define os_mempool_unregister r_os_mempool_unregister
|
||||
|
||||
|
||||
/**
|
||||
* Clears a memory pool.
|
||||
*
|
||||
* @param mp The mempool to clear.
|
||||
*
|
||||
* @return os_error_t
|
||||
*/
|
||||
os_error_t r_os_mempool_clear(struct os_mempool *mp);
|
||||
#define os_mempool_clear r_os_mempool_clear
|
||||
|
||||
|
||||
/**
|
||||
* Performs an integrity check of the specified mempool. This function
|
||||
* attempts to detect memory corruption in the specified memory pool.
|
||||
*
|
||||
* @param mp The mempool to check.
|
||||
*
|
||||
* @return true if the memory pool passes the integrity
|
||||
* check;
|
||||
* false if the memory pool is corrupt.
|
||||
*/
|
||||
bool r_os_mempool_is_sane(const struct os_mempool *mp);
|
||||
#define os_mempool_is_sane r_os_mempool_is_sane
|
||||
|
||||
|
||||
/**
|
||||
* Checks if a memory block was allocated from the specified mempool.
|
||||
*
|
||||
* @param mp The mempool to check as parent.
|
||||
* @param block_addr The memory block to check as child.
|
||||
*
|
||||
* @return 0 if the block does not belong to the mempool;
|
||||
* 1 if the block does belong to the mempool.
|
||||
*/
|
||||
int r_os_memblock_from(const struct os_mempool *mp, const void *block_addr);
|
||||
#define os_memblock_from r_os_memblock_from
|
||||
|
||||
|
||||
/**
|
||||
* Get a memory block from a memory pool
|
||||
*
|
||||
* @param mp Pointer to the memory pool
|
||||
*
|
||||
* @return void* Pointer to block if available; NULL otherwise
|
||||
*/
|
||||
void *r_os_memblock_get(struct os_mempool *mp);
|
||||
#define os_memblock_get r_os_memblock_get
|
||||
/**
|
||||
* Puts the memory block back into the pool, ignoring the put callback, if any.
|
||||
* This function should only be called from a put callback to free a block
|
||||
* without causing infinite recursion.
|
||||
*
|
||||
* @param mp Pointer to memory pool
|
||||
* @param block_addr Pointer to memory block
|
||||
*
|
||||
* @return os_error_t
|
||||
*/
|
||||
os_error_t r_os_memblock_put_from_cb(struct os_mempool *mp, void *block_addr);
|
||||
#define os_memblock_put_from_cb r_os_memblock_put_from_cb
|
||||
|
||||
|
||||
/**
|
||||
* Puts the memory block back into the pool
|
||||
*
|
||||
* @param mp Pointer to memory pool
|
||||
* @param block_addr Pointer to memory block
|
||||
*
|
||||
* @return os_error_t
|
||||
*/
|
||||
os_error_t r_os_memblock_put(struct os_mempool *mp, void *block_addr);
|
||||
#define os_memblock_put r_os_memblock_put
|
||||
|
||||
#else
|
||||
/**
|
||||
* Initialize a memory pool.
|
||||
*
|
||||
* @param mp Pointer to a pointer to a mempool
|
||||
* @param blocks The number of blocks in the pool
|
||||
* @param blocks_size The size of the block, in bytes.
|
||||
* @param membuf Pointer to memory to contain blocks.
|
||||
* @param name Name of the pool.
|
||||
*
|
||||
* @return os_error_t
|
||||
*/
|
||||
os_error_t os_mempool_init(struct os_mempool *mp, uint16_t blocks,
|
||||
uint32_t block_size, void *membuf, const char *name);
|
||||
|
||||
/**
|
||||
* Initializes an extended memory pool. Extended attributes (e.g., callbacks)
|
||||
* are not specified when this function is called; they are assigned manually
|
||||
* after initialization.
|
||||
*
|
||||
* @param mpe The extended memory pool to initialize.
|
||||
* @param blocks The number of blocks in the pool.
|
||||
* @param block_size The size of each block, in bytes.
|
||||
* @param membuf Pointer to memory to contain blocks.
|
||||
* @param name Name of the pool.
|
||||
*
|
||||
* @return os_error_t
|
||||
*/
|
||||
os_error_t os_mempool_ext_init(struct os_mempool_ext *mpe, uint16_t blocks,
|
||||
uint32_t block_size, void *membuf, const char *name);
|
||||
|
||||
/**
|
||||
* Removes the specified mempool from the list of initialized mempools.
|
||||
*
|
||||
* @param mp The mempool to unregister.
|
||||
*
|
||||
* @return 0 on success;
|
||||
* OS_INVALID_PARM if the mempool is not
|
||||
* registered.
|
||||
*/
|
||||
os_error_t os_mempool_unregister(struct os_mempool *mp);
|
||||
|
||||
/**
|
||||
* Clears a memory pool.
|
||||
*
|
||||
* @param mp The mempool to clear.
|
||||
*
|
||||
* @return os_error_t
|
||||
*/
|
||||
os_error_t os_mempool_clear(struct os_mempool *mp);
|
||||
|
||||
/**
|
||||
* Clears an extended memory pool.
|
||||
*
|
||||
* @param mpe The extended memory pool to clear.
|
||||
*
|
||||
* @return os_error_t
|
||||
*/
|
||||
os_error_t os_mempool_ext_clear(struct os_mempool_ext *mpe);
|
||||
|
||||
/**
|
||||
* Performs an integrity check of the specified mempool. This function
|
||||
* attempts to detect memory corruption in the specified memory pool.
|
||||
*
|
||||
* @param mp The mempool to check.
|
||||
*
|
||||
* @return true if the memory pool passes the integrity
|
||||
* check;
|
||||
* false if the memory pool is corrupt.
|
||||
*/
|
||||
bool os_mempool_is_sane(const struct os_mempool *mp);
|
||||
|
||||
/**
|
||||
* Checks if a memory block was allocated from the specified mempool.
|
||||
*
|
||||
* @param mp The mempool to check as parent.
|
||||
* @param block_addr The memory block to check as child.
|
||||
*
|
||||
* @return 0 if the block does not belong to the mempool;
|
||||
* 1 if the block does belong to the mempool.
|
||||
*/
|
||||
int os_memblock_from(const struct os_mempool *mp, const void *block_addr);
|
||||
|
||||
/**
|
||||
* Get a memory block from a memory pool
|
||||
*
|
||||
* @param mp Pointer to the memory pool
|
||||
*
|
||||
* @return void* Pointer to block if available; NULL otherwise
|
||||
*/
|
||||
void *os_memblock_get(struct os_mempool *mp);
|
||||
|
||||
/**
|
||||
* Puts the memory block back into the pool, ignoring the put callback, if any.
|
||||
* This function should only be called from a put callback to free a block
|
||||
* without causing infinite recursion.
|
||||
*
|
||||
* @param mp Pointer to memory pool
|
||||
* @param block_addr Pointer to memory block
|
||||
*
|
||||
* @return os_error_t
|
||||
*/
|
||||
os_error_t os_memblock_put_from_cb(struct os_mempool *mp, void *block_addr);
|
||||
|
||||
/**
|
||||
* Puts the memory block back into the pool
|
||||
*
|
||||
* @param mp Pointer to memory pool
|
||||
* @param block_addr Pointer to memory block
|
||||
*
|
||||
* @return os_error_t
|
||||
*/
|
||||
os_error_t os_memblock_put(struct os_mempool *mp, void *block_addr);
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* _OS_MEMPOOL_H_ */
|
||||
|
||||
|
||||
/**
|
||||
* @} OSMempool
|
||||
* @} OSKernel
|
||||
*/
|
||||
@@ -0,0 +1,212 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2015-2022 The Apache Software Foundation (ASF)
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* SPDX-FileContributor: 2019-2022 Espressif Systems (Shanghai) CO LTD
|
||||
*/
|
||||
/*
|
||||
* Licensed to the Apache Software Foundation (ASF) under one
|
||||
* or more contributor license agreements. See the NOTICE file
|
||||
* distributed with this work for additional information
|
||||
* regarding copyright ownership. The ASF licenses this file
|
||||
* to you under the Apache License, Version 2.0 (the
|
||||
* "License"); you may not use this file except in compliance
|
||||
* with the License. You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing,
|
||||
* software distributed under the License is distributed on an
|
||||
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
||||
* KIND, either express or implied. See the License for the
|
||||
* specific language governing permissions and limitations
|
||||
* under the License.
|
||||
*/
|
||||
|
||||
#ifndef _QUEUE_H_
|
||||
#define _QUEUE_H_
|
||||
|
||||
/* The common BSD linked list queue macros are already defined here for ESP-IDF */
|
||||
#include <sys/queue.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/*
|
||||
* This file defines circular queues. The other types of data structures:
|
||||
* singly-linked lists, singly-linked tail queues, lists and tail queues
|
||||
* are used from sys/queue.h
|
||||
*
|
||||
* A singly-linked list is headed by a single forward pointer. The elements
|
||||
* are singly linked for minimum space and pointer manipulation overhead at
|
||||
* the expense of O(n) removal for arbitrary elements. New elements can be
|
||||
* added to the list after an existing element or at the head of the list.
|
||||
* Elements being removed from the head of the list should use the explicit
|
||||
* macro for this purpose for optimum efficiency. A singly-linked list may
|
||||
* only be traversed in the forward direction. Singly-linked lists are ideal
|
||||
* for applications with large datasets and few or no removals or for
|
||||
* implementing a LIFO queue.
|
||||
*
|
||||
* A singly-linked tail queue is headed by a pair of pointers, one to the
|
||||
* head of the list and the other to the tail of the list. The elements are
|
||||
* singly linked for minimum space and pointer manipulation overhead at the
|
||||
* expense of O(n) removal for arbitrary elements. New elements can be added
|
||||
* to the list after an existing element, at the head of the list, or at the
|
||||
* end of the list. Elements being removed from the head of the tail queue
|
||||
* should use the explicit macro for this purpose for optimum efficiency.
|
||||
* A singly-linked tail queue may only be traversed in the forward direction.
|
||||
* Singly-linked tail queues are ideal for applications with large datasets
|
||||
* and few or no removals or for implementing a FIFO queue.
|
||||
*
|
||||
* A list is headed by a single forward pointer (or an array of forward
|
||||
* pointers for a hash table header). The elements are doubly linked
|
||||
* so that an arbitrary element can be removed without a need to
|
||||
* traverse the list. New elements can be added to the list before
|
||||
* or after an existing element or at the head of the list. A list
|
||||
* may only be traversed in the forward direction.
|
||||
*
|
||||
* A tail queue is headed by a pair of pointers, one to the head of the
|
||||
* list and the other to the tail of the list. The elements are doubly
|
||||
* linked so that an arbitrary element can be removed without a need to
|
||||
* traverse the list. New elements can be added to the list before or
|
||||
* after an existing element, at the head of the list, or at the end of
|
||||
* the list. A tail queue may be traversed in either direction.
|
||||
*
|
||||
* A circle queue is headed by a pair of pointers, one to the head of the
|
||||
* list and the other to the tail of the list. The elements are doubly
|
||||
* linked so that an arbitrary element can be removed without a need to
|
||||
* traverse the list. New elements can be added to the list before or after
|
||||
* an existing element, at the head of the list, or at the end of the list.
|
||||
* A circle queue may be traversed in either direction, but has a more
|
||||
* complex end of list detection.
|
||||
*
|
||||
* For details on the use of these macros, see the queue(3) manual page.
|
||||
*
|
||||
*
|
||||
* SLIST LIST STAILQ TAILQ CIRCLEQ
|
||||
* _HEAD + + + + +
|
||||
* _HEAD_INITIALIZER + + + + +
|
||||
* _ENTRY + + + + +
|
||||
* _INIT + + + + +
|
||||
* _EMPTY + + + + +
|
||||
* _FIRST + + + + +
|
||||
* _NEXT + + + + +
|
||||
* _PREV - - - + +
|
||||
* _LAST - - + + +
|
||||
* _FOREACH + + + + +
|
||||
* _FOREACH_REVERSE - - - + +
|
||||
* _INSERT_HEAD + + + + +
|
||||
* _INSERT_BEFORE - + - + +
|
||||
* _INSERT_AFTER + + + + +
|
||||
* _INSERT_TAIL - - + + +
|
||||
* _REMOVE_HEAD + - + - -
|
||||
* _REMOVE + + + + +
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* Circular queue declarations.
|
||||
*/
|
||||
#define CIRCLEQ_HEAD(name, type) \
|
||||
struct name { \
|
||||
struct type *cqh_first; /* first element */ \
|
||||
struct type *cqh_last; /* last element */ \
|
||||
}
|
||||
|
||||
#define CIRCLEQ_HEAD_INITIALIZER(head) \
|
||||
{ (void *)&(head), (void *)&(head) }
|
||||
|
||||
#define CIRCLEQ_ENTRY(type) \
|
||||
struct { \
|
||||
struct type *cqe_next; /* next element */ \
|
||||
struct type *cqe_prev; /* previous element */ \
|
||||
}
|
||||
|
||||
/*
|
||||
* Circular queue functions.
|
||||
*/
|
||||
#define CIRCLEQ_EMPTY(head) ((head)->cqh_first == (void *)(head))
|
||||
|
||||
#define CIRCLEQ_FIRST(head) ((head)->cqh_first)
|
||||
|
||||
#define CIRCLEQ_FOREACH(var, head, field) \
|
||||
for ((var) = CIRCLEQ_FIRST((head)); \
|
||||
(var) != (void *)(head) || ((var) = NULL); \
|
||||
(var) = CIRCLEQ_NEXT((var), field))
|
||||
|
||||
#define CIRCLEQ_FOREACH_REVERSE(var, head, field) \
|
||||
for ((var) = CIRCLEQ_LAST((head)); \
|
||||
(var) != (void *)(head) || ((var) = NULL); \
|
||||
(var) = CIRCLEQ_PREV((var), field))
|
||||
|
||||
#define CIRCLEQ_INIT(head) do { \
|
||||
CIRCLEQ_FIRST((head)) = (void *)(head); \
|
||||
CIRCLEQ_LAST((head)) = (void *)(head); \
|
||||
} while (0)
|
||||
|
||||
#define CIRCLEQ_INSERT_AFTER(head, listelm, elm, field) do { \
|
||||
CIRCLEQ_NEXT((elm), field) = CIRCLEQ_NEXT((listelm), field); \
|
||||
CIRCLEQ_PREV((elm), field) = (listelm); \
|
||||
if (CIRCLEQ_NEXT((listelm), field) == (void *)(head)) \
|
||||
CIRCLEQ_LAST((head)) = (elm); \
|
||||
else \
|
||||
CIRCLEQ_PREV(CIRCLEQ_NEXT((listelm), field), field) = (elm);\
|
||||
CIRCLEQ_NEXT((listelm), field) = (elm); \
|
||||
} while (0)
|
||||
|
||||
#define CIRCLEQ_INSERT_BEFORE(head, listelm, elm, field) do { \
|
||||
CIRCLEQ_NEXT((elm), field) = (listelm); \
|
||||
CIRCLEQ_PREV((elm), field) = CIRCLEQ_PREV((listelm), field); \
|
||||
if (CIRCLEQ_PREV((listelm), field) == (void *)(head)) \
|
||||
CIRCLEQ_FIRST((head)) = (elm); \
|
||||
else \
|
||||
CIRCLEQ_NEXT(CIRCLEQ_PREV((listelm), field), field) = (elm);\
|
||||
CIRCLEQ_PREV((listelm), field) = (elm); \
|
||||
} while (0)
|
||||
|
||||
#define CIRCLEQ_INSERT_HEAD(head, elm, field) do { \
|
||||
CIRCLEQ_NEXT((elm), field) = CIRCLEQ_FIRST((head)); \
|
||||
CIRCLEQ_PREV((elm), field) = (void *)(head); \
|
||||
if (CIRCLEQ_LAST((head)) == (void *)(head)) \
|
||||
CIRCLEQ_LAST((head)) = (elm); \
|
||||
else \
|
||||
CIRCLEQ_PREV(CIRCLEQ_FIRST((head)), field) = (elm); \
|
||||
CIRCLEQ_FIRST((head)) = (elm); \
|
||||
} while (0)
|
||||
|
||||
#define CIRCLEQ_INSERT_TAIL(head, elm, field) do { \
|
||||
CIRCLEQ_NEXT((elm), field) = (void *)(head); \
|
||||
CIRCLEQ_PREV((elm), field) = CIRCLEQ_LAST((head)); \
|
||||
if (CIRCLEQ_FIRST((head)) == (void *)(head)) \
|
||||
CIRCLEQ_FIRST((head)) = (elm); \
|
||||
else \
|
||||
CIRCLEQ_NEXT(CIRCLEQ_LAST((head)), field) = (elm); \
|
||||
CIRCLEQ_LAST((head)) = (elm); \
|
||||
} while (0)
|
||||
|
||||
#define CIRCLEQ_LAST(head) ((head)->cqh_last)
|
||||
|
||||
#define CIRCLEQ_NEXT(elm,field) ((elm)->field.cqe_next)
|
||||
|
||||
#define CIRCLEQ_PREV(elm,field) ((elm)->field.cqe_prev)
|
||||
|
||||
#define CIRCLEQ_REMOVE(head, elm, field) do { \
|
||||
if (CIRCLEQ_NEXT((elm), field) == (void *)(head)) \
|
||||
CIRCLEQ_LAST((head)) = CIRCLEQ_PREV((elm), field); \
|
||||
else \
|
||||
CIRCLEQ_PREV(CIRCLEQ_NEXT((elm), field), field) = \
|
||||
CIRCLEQ_PREV((elm), field); \
|
||||
if (CIRCLEQ_PREV((elm), field) == (void *)(head)) \
|
||||
CIRCLEQ_FIRST((head)) = CIRCLEQ_NEXT((elm), field); \
|
||||
else \
|
||||
CIRCLEQ_NEXT(CIRCLEQ_PREV((elm), field), field) = \
|
||||
CIRCLEQ_NEXT((elm), field); \
|
||||
} while (0)
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* !_SYS_QUEUE_H_ */
|
||||
@@ -0,0 +1,45 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2015-2022 The Apache Software Foundation (ASF)
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* SPDX-FileContributor: 2019-2022 Espressif Systems (Shanghai) CO LTD
|
||||
*/
|
||||
/*
|
||||
* Licensed to the Apache Software Foundation (ASF) under one
|
||||
* or more contributor license agreements. See the NOTICE file
|
||||
* distributed with this work for additional information
|
||||
* regarding copyright ownership. The ASF licenses this file
|
||||
* to you under the Apache License, Version 2.0 (the
|
||||
* "License"); you may not use this file except in compliance
|
||||
* with the License. You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing,
|
||||
* software distributed under the License is distributed on an
|
||||
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
||||
* KIND, either express or implied. See the License for the
|
||||
* specific language governing permissions and limitations
|
||||
* under the License.
|
||||
*/
|
||||
|
||||
#ifndef H_OS_UTIL_
|
||||
#define H_OS_UTIL_
|
||||
|
||||
/* Helpers to pass integers as pointers and vice-versa */
|
||||
#define POINTER_TO_UINT(p) ((unsigned int) ((uintptr_t) (p)))
|
||||
#define UINT_TO_POINTER(u) ((void *) ((uintptr_t) (u)))
|
||||
#define POINTER_TO_INT(p) ((int) ((intptr_t) (p)))
|
||||
#define INT_TO_POINTER(u) ((void *) ((intptr_t) (u)))
|
||||
|
||||
/* Helper to retrieve pointer to "parent" object in structure */
|
||||
#define CONTAINER_OF(ptr, type, field) \
|
||||
((type *)(((char *)(ptr)) - offsetof(type, field)))
|
||||
|
||||
/* Helper to calculate number of elements in array */
|
||||
#ifndef ARRAY_SIZE
|
||||
#define ARRAY_SIZE(array) \
|
||||
(sizeof(array) / sizeof((array)[0]))
|
||||
#endif
|
||||
#endif
|
||||
Reference in New Issue
Block a user