l2cap.h

Go to the documentation of this file.

 
/*
 * Copyright (c) 2015-2016 Intel Corporation
 * Copyright (c) 2023 Nordic Semiconductor
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef ZEPHYR_INCLUDE_BLUETOOTH_L2CAP_H_
#define ZEPHYR_INCLUDE_BLUETOOTH_L2CAP_H_
 
#include <stddef.h>
#include <stdint.h>
 
#include <zephyr/bluetooth/buf.h>
#include <zephyr/bluetooth/conn.h>
#include <zephyr/bluetooth/hci.h>
#include <zephyr/kernel.h>
#include <zephyr/net_buf.h>
#include <zephyr/sys/atomic.h>
#include <zephyr/sys/slist.h>
#include <zephyr/sys/util.h>
#include <sys/types.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define BT_L2CAP_HDR_SIZE               4
 
#define BT_L2CAP_TX_MTU (CONFIG_BT_L2CAP_TX_MTU)
 
#define BT_L2CAP_RX_MTU (CONFIG_BT_BUF_ACL_RX_SIZE - BT_L2CAP_HDR_SIZE)
 
#define BT_L2CAP_BUF_SIZE(mtu) BT_BUF_ACL_SIZE(BT_L2CAP_HDR_SIZE + (mtu))
 
#define BT_L2CAP_SDU_HDR_SIZE           2
 
#define BT_L2CAP_SDU_TX_MTU (BT_L2CAP_TX_MTU - BT_L2CAP_SDU_HDR_SIZE)
 
#define BT_L2CAP_SDU_RX_MTU (BT_L2CAP_RX_MTU - BT_L2CAP_SDU_HDR_SIZE)
 
#define BT_L2CAP_SDU_BUF_SIZE(mtu) BT_L2CAP_BUF_SIZE(BT_L2CAP_SDU_HDR_SIZE + (mtu))
 
#define BT_L2CAP_ECRED_MIN_MTU 64
 
#define BT_L2CAP_ECRED_MIN_MPS 64
 
#define BT_L2CAP_MAX_MTU UINT16_MAX
 
#define BT_L2CAP_MAX_MPS 65533
 
#define BT_L2CAP_ECRED_CHAN_MAX_PER_REQ 5
 
struct bt_l2cap_chan;
 
typedef void (*bt_l2cap_chan_destroy_t)(struct bt_l2cap_chan *chan);
 
typedef enum bt_l2cap_chan_state {
        BT_L2CAP_DISCONNECTED,
        BT_L2CAP_CONNECTING,
        BT_L2CAP_CONFIG,
        BT_L2CAP_CONNECTED,
        BT_L2CAP_DISCONNECTING,
 
} __packed bt_l2cap_chan_state_t;
 
typedef enum bt_l2cap_chan_status {
        BT_L2CAP_STATUS_OUT,
 
        BT_L2CAP_STATUS_SHUTDOWN,
 
        BT_L2CAP_STATUS_ENCRYPT_PENDING,
 
        /* Total number of status - must be at the end of the enum */
        BT_L2CAP_NUM_STATUS,
} __packed bt_l2cap_chan_status_t;
 
struct bt_l2cap_chan {
        struct bt_conn                  *conn;
        const struct bt_l2cap_chan_ops  *ops;
        sys_snode_t                     node;
        bt_l2cap_chan_destroy_t         destroy;
 
        ATOMIC_DEFINE(status, BT_L2CAP_NUM_STATUS);
};
 
struct bt_l2cap_le_endpoint {
        uint16_t                                cid;
        uint16_t                                mtu;
        uint16_t                                mps;
        atomic_t                        credits;
};
 
struct bt_l2cap_le_chan {
        struct bt_l2cap_chan            chan;
        struct bt_l2cap_le_endpoint     rx;
 
        uint16_t pending_rx_mtu;
 
        struct bt_l2cap_le_endpoint     tx;
        struct k_fifo                   tx_queue;
#if defined(CONFIG_BT_L2CAP_DYNAMIC_CHANNEL)
        struct net_buf                  *_sdu;
        uint16_t                        _sdu_len;
#if defined(CONFIG_BT_L2CAP_SEG_RECV)
        uint16_t                        _sdu_len_done;
#endif /* CONFIG_BT_L2CAP_SEG_RECV */
 
        struct k_work                   rx_work;
        struct k_fifo                   rx_queue;
 
        bt_l2cap_chan_state_t           state;
        uint16_t                        psm;
        uint8_t                         ident;
        uint8_t                         pending_req;
        bt_security_t                   required_sec_level;
 
        /* Response Timeout eXpired (RTX) timer */
        struct k_work_delayable         rtx_work;
        struct k_work_sync              rtx_sync;
#endif
 
        sys_snode_t                     _pdu_ready;
        size_t                          _pdu_remaining;
};
 
#define BT_L2CAP_LE_CHAN(_ch) CONTAINER_OF(_ch, struct bt_l2cap_le_chan, chan)
 
#define BT_L2CAP_BR_LINK_MODE_BASIC  0x00
#define BT_L2CAP_BR_LINK_MODE_RET    0x01
#define BT_L2CAP_BR_LINK_MODE_FC     0x02
#define BT_L2CAP_BR_LINK_MODE_ERET   0x03
#define BT_L2CAP_BR_LINK_MODE_STREAM 0x04
 
#define BT_L2CAP_BR_FCS_NO    0x00
#define BT_L2CAP_BR_FCS_16BIT 0x01
 
struct bt_l2cap_br_endpoint {
        uint16_t                                cid;
        uint16_t                                mtu;
#if defined(CONFIG_BT_L2CAP_RET_FC) || defined(__DOXYGEN__)
        uint8_t                                 mode;
        bool                                    optional;
        uint8_t                                 max_transmit;
        uint16_t                                ret_timeout;
        uint16_t                                monitor_timeout;
        uint16_t                                mps;
        uint16_t                                max_window;
        uint8_t                                 fcs;
        bool                                    extended_control;
#endif /* CONFIG_BT_L2CAP_RET_FC */
};
 
struct bt_l2cap_br_window {
        sys_snode_t node;
 
        uint16_t tx_seq;
        uint16_t len;
        uint8_t *data;
        uint8_t transmit_counter;
        uint8_t sar;
        bool srej;
        /* Save PDU state */
        struct net_buf_simple_state sdu_state;
        struct net_buf *sdu;
        uint16_t sdu_total_len;
};
 
struct bt_l2cap_br_chan {
        struct bt_l2cap_chan            chan;
        struct bt_l2cap_br_endpoint     rx;
        struct bt_l2cap_br_endpoint     tx;
        /* For internal use only */
        atomic_t                        flags[1];
 
        bt_l2cap_chan_state_t           state;
        uint16_t                        psm;
        uint8_t                         ident;
        bt_security_t                   required_sec_level;
 
        /* Response Timeout eXpired (RTX) timer */
        struct k_work_delayable         rtx_work;
        struct k_work_sync              rtx_sync;
 
        sys_snode_t                     _pdu_ready;
        atomic_t                        _pdu_ready_lock;
        sys_slist_t                     _pdu_tx_queue;
 
#if defined(CONFIG_BT_L2CAP_RET_FC) || defined(__DOXYGEN__)
        uint16_t                        _sdu_total_len;
 
        size_t                          _pdu_remaining;
 
        struct net_buf                  *_pdu_buf;
 
        sys_slist_t                     _pdu_outstanding;
 
        struct net_buf_simple_state     _pdu_state;
 
        struct k_fifo                   _free_tx_win;
 
        struct bt_l2cap_br_window       tx_win[CONFIG_BT_L2CAP_MAX_WINDOW_SIZE];
 
        struct net_buf                  *_sdu;
        uint16_t                        _sdu_len;
#if defined(CONFIG_BT_L2CAP_SEG_RECV) || defined(__DOXYGEN__)
        uint16_t                        _sdu_len_done;
#endif /* CONFIG_BT_L2CAP_SEG_RECV */
        uint16_t                        tx_seq;
        uint16_t                        next_tx_seq;
        uint16_t                        expected_ack_seq;
        uint16_t                        req_seq;
        uint16_t                        expected_tx_seq;
        uint16_t                        buffer_seq;
 
        uint16_t                        retry_count;
        uint16_t                        srej_save_req_seq;
 
        struct k_work_delayable         ret_work;
        struct k_work_delayable         monitor_work;
#endif /* CONFIG_BT_L2CAP_RET_FC */
};
 
struct bt_l2cap_chan_ops {
        void (*connected)(struct bt_l2cap_chan *chan);
 
        void (*disconnected)(struct bt_l2cap_chan *chan);
 
        void (*encrypt_change)(struct bt_l2cap_chan *chan, uint8_t hci_status);
 
        struct net_buf *(*alloc_seg)(struct bt_l2cap_chan *chan);
 
        struct net_buf *(*alloc_buf)(struct bt_l2cap_chan *chan);
 
        int (*recv)(struct bt_l2cap_chan *chan, struct net_buf *buf);
 
        void (*sent)(struct bt_l2cap_chan *chan);
 
        void (*status)(struct bt_l2cap_chan *chan, atomic_t *status);
 
        /* @brief Channel released callback
         *
         * If this callback is set it is called when the stack has release all
         * references to the channel object.
         */
        void (*released)(struct bt_l2cap_chan *chan);
 
        void (*reconfigured)(struct bt_l2cap_chan *chan);
 
#if defined(CONFIG_BT_L2CAP_SEG_RECV)
        void (*seg_recv)(struct bt_l2cap_chan *chan, size_t sdu_len,
                         off_t seg_offset, struct net_buf_simple *seg);
#endif /* CONFIG_BT_L2CAP_SEG_RECV */
};
 
#define BT_L2CAP_CHAN_SEND_RESERVE (BT_L2CAP_BUF_SIZE(0))
 
#define BT_L2CAP_SDU_CHAN_SEND_RESERVE (BT_L2CAP_SDU_BUF_SIZE(0))
 
struct bt_l2cap_server {
        uint16_t                        psm;
 
        bt_security_t           sec_level;
 
        int (*accept)(struct bt_conn *conn, struct bt_l2cap_server *server,
                      struct bt_l2cap_chan **chan);
 
        sys_snode_t node;
};
 
int bt_l2cap_server_register(struct bt_l2cap_server *server);
 
int bt_l2cap_br_server_register(struct bt_l2cap_server *server);
 
int bt_l2cap_br_server_unregister(struct bt_l2cap_server *server);
 
int bt_l2cap_ecred_chan_connect(struct bt_conn *conn,
                                struct bt_l2cap_chan **chans, uint16_t psm);
 
int bt_l2cap_ecred_chan_reconfigure(struct bt_l2cap_chan **chans, uint16_t mtu);
 
int bt_l2cap_ecred_chan_reconfigure_explicit(struct bt_l2cap_chan **chans, size_t chan_count,
                                             uint16_t mtu, uint16_t mps);
 
int bt_l2cap_chan_connect(struct bt_conn *conn, struct bt_l2cap_chan *chan,
                          uint16_t psm);
 
int bt_l2cap_chan_disconnect(struct bt_l2cap_chan *chan);
 
int bt_l2cap_chan_send(struct bt_l2cap_chan *chan, struct net_buf *buf);
 
int bt_l2cap_chan_give_credits(struct bt_l2cap_chan *chan, uint16_t additional_credits);
 
int bt_l2cap_chan_recv_complete(struct bt_l2cap_chan *chan,
                                struct net_buf *buf);
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_BLUETOOTH_L2CAP_H_ */