rfcomm.h

Go to the documentation of this file.

 
/*
 * Copyright (c) 2015-2016 Intel Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef ZEPHYR_INCLUDE_BLUETOOTH_RFCOMM_H_
#define ZEPHYR_INCLUDE_BLUETOOTH_RFCOMM_H_
 
#include <zephyr/bluetooth/buf.h>
#include <zephyr/bluetooth/conn.h>
#include <zephyr/bluetooth/l2cap.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define BT_RFCOMM_HDR_MAX_SIZE 4
#define BT_RFCOMM_FCS_SIZE     1
 
#define BT_RFCOMM_BUF_SIZE(mtu)                                                                    \
        BT_L2CAP_BUF_SIZE(BT_RFCOMM_HDR_MAX_SIZE + BT_RFCOMM_FCS_SIZE + (mtu))
 
/* RFCOMM channels (1-30): pre-allocated for profiles to avoid conflicts */
enum {
        BT_RFCOMM_CHAN_HFP_HF = 1,
        BT_RFCOMM_CHAN_HFP_AG,
        BT_RFCOMM_CHAN_HSP_AG,
        BT_RFCOMM_CHAN_HSP_HS,
        BT_RFCOMM_CHAN_SPP,
        BT_RFCOMM_CHAN_DYNAMIC_START,
};
 
struct bt_rfcomm_dlc;
 
struct bt_rfcomm_dlc_ops {
        void (*connected)(struct bt_rfcomm_dlc *dlc);
 
        void (*disconnected)(struct bt_rfcomm_dlc *dlc);
 
        void (*recv)(struct bt_rfcomm_dlc *dlc, struct net_buf *buf);
 
        void (*sent)(struct bt_rfcomm_dlc *dlc, int err);
};
 
typedef enum bt_rfcomm_role {
        BT_RFCOMM_ROLE_ACCEPTOR,
        BT_RFCOMM_ROLE_INITIATOR
} __packed bt_rfcomm_role_t;
 
struct bt_rfcomm_dlc {
        /* Response Timeout eXpired (RTX) timer */
        struct k_work_delayable    rtx_work;
 
        /* Queue for outgoing data */
        struct k_fifo              tx_queue;
 
        /* TX credits, Reuse as a binary sem for MSC FC if CFC is not enabled */
        struct k_sem               tx_credits;
 
        struct bt_rfcomm_session  *session;
        struct bt_rfcomm_dlc_ops  *ops;
        struct bt_rfcomm_dlc      *_next;
 
        bt_security_t              required_sec_level;
        bt_rfcomm_role_t           role;
 
        uint16_t                      mtu;
        uint8_t                       dlci;
        uint8_t                       state;
        uint8_t                       rx_credit;
 
        /* Stack & kernel data for TX thread */
        struct k_thread            tx_thread;
#if defined(CONFIG_BT_RFCOMM_DLC_STACK_SIZE)
        K_KERNEL_STACK_MEMBER(stack, CONFIG_BT_RFCOMM_DLC_STACK_SIZE);
#endif /* CONFIG_BT_RFCOMM_DLC_STACK_SIZE */
};
 
struct bt_rfcomm_server {
        uint8_t channel;
 
        int (*accept)(struct bt_conn *conn, struct bt_rfcomm_server *server,
                      struct bt_rfcomm_dlc **dlc);
 
        struct bt_rfcomm_server *_next;
};
 
enum {
        BT_RFCOMM_RPN_BAUD_RATE_2400 = 0x0,
        BT_RFCOMM_RPN_BAUD_RATE_4800 = 0x1,
        BT_RFCOMM_RPN_BAUD_RATE_7200 = 0x2,
        BT_RFCOMM_RPN_BAUD_RATE_9600 = 0x3,
        BT_RFCOMM_RPN_BAUD_RATE_19200 = 0x4,
        BT_RFCOMM_RPN_BAUD_RATE_38400 = 0x5,
        BT_RFCOMM_RPN_BAUD_RATE_57600 = 0x6,
        BT_RFCOMM_RPN_BAUD_RATE_115200 = 0x7,
        BT_RFCOMM_RPN_BAUD_RATE_230400 = 0x8
};
 
enum {
        BT_RFCOMM_RPN_DATA_BITS_5 = 0x0,
        BT_RFCOMM_RPN_DATA_BITS_6 = 0x1,
        BT_RFCOMM_RPN_DATA_BITS_7 = 0x2,
        BT_RFCOMM_RPN_DATA_BITS_8 = 0x3
};
 
enum {
        BT_RFCOMM_RPN_STOP_BITS_1 = 0,
        BT_RFCOMM_RPN_STOP_BITS_1_5 = 1
};
 
enum {
        BT_RFCOMM_RPN_PARITY_NONE = 0x0,
        BT_RFCOMM_RPN_PARITY_ODD = 0x1,
        BT_RFCOMM_RPN_PARITY_EVEN = 0x3,
        BT_RFCOMM_RPN_PARITY_MARK = 0x5,
        BT_RFCOMM_RPN_PARITY_SPACE = 0x7
};
 
#define BT_RFCOMM_SET_LINE_SETTINGS(data, stop, parity) ((data & 0x3) | \
                                                         ((stop & 0x1) << 2) | \
                                                         ((parity & 0x7) << 3))
 
#define BT_RFCOMM_RPN_FLOW_NONE         0x00
#define BT_RFCOMM_RPN_XON_CHAR          0x11
#define BT_RFCOMM_RPN_XOFF_CHAR         0x13
 
/* Set 1 to all the param mask except reserved */
#define BT_RFCOMM_RPN_PARAM_MASK_ALL    0x3f7f
 
struct bt_rfcomm_rpn {
        uint8_t  dlci;
        uint8_t  baud_rate;
        uint8_t  line_settings;
        uint8_t  flow_control;
        uint8_t  xon_char;
        uint8_t  xoff_char;
        uint16_t param_mask;
} __packed;
 
int bt_rfcomm_server_register(struct bt_rfcomm_server *server);
 
int bt_rfcomm_dlc_connect(struct bt_conn *conn, struct bt_rfcomm_dlc *dlc,
                          uint8_t channel);
 
int bt_rfcomm_dlc_send(struct bt_rfcomm_dlc *dlc, struct net_buf *buf);
 
int bt_rfcomm_dlc_disconnect(struct bt_rfcomm_dlc *dlc);
 
struct net_buf *bt_rfcomm_create_pdu(struct net_buf_pool *pool);
 
int bt_rfcomm_send_rpn_cmd(struct bt_rfcomm_dlc *dlc, struct bt_rfcomm_rpn *rpn);
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_BLUETOOTH_RFCOMM_H_ */