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


#define BT_L2CAP_CID_BR_SIG             0x0001
#define BT_L2CAP_CID_ATT                0x0004
#define BT_L2CAP_CID_LE_SIG             0x0005
#define BT_L2CAP_CID_SMP                0x0006
#define BT_L2CAP_CID_BR_SMP             0x0007

 
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)

struct bt_l2cap_fixed_chan {
        uint16_t cid;

        int (*accept)(struct bt_conn *conn, struct bt_l2cap_chan **chan);
};

#define BT_L2CAP_FIXED_CHANNEL_DEFINE(_name)                                                       \
        static const STRUCT_SECTION_ITERABLE(bt_l2cap_fixed_chan,                                  \
                                             _CONCAT(bt_l2cap_fixed_chan, _name))

#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;
        bool retransmit;
        /* Save PDU state */
        struct net_buf_simple_state sdu_state;
        struct net_buf *sdu;
};

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;


        struct k_work_delayable         retry_work;


        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__)
        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) || defined(__DOXYGEN__)
        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_ */