nimble_netif.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2018-2021 Freie Universität Berlin
 * SPDX-License-Identifier: LGPL-2.1-only
 */
 
#pragma once

 
#include <stdint.h>
#include <errno.h>
 
#include "net/ble.h"
#include "nimble_riot.h"
 
#include "host/ble_hs.h"
 
#ifdef __cplusplus
extern "C" {
#endif

#ifndef NIMBLE_NETIF_MAX_CONN
#define NIMBLE_NETIF_MAX_CONN       (MYNEWT_VAL_BLE_MAX_CONNECTIONS)
#endif

#ifndef NIMBLE_NETIF_CID
#define NIMBLE_NETIF_CID            (BLE_L2CAP_CID_IPSP)
#endif

/* NOTE: We do not use the @ref IPV6_MIN_MTU define here, as the iov6.h header
         pulls in some other RIOT headers that clash with NimBLE header (e.g.
 *       byteorder.h vs. endian.h) */
#ifndef NIMBLE_NETIF_MTU
#define NIMBLE_NETIF_MTU            (1280U)
#endif

enum {
    NIMBLE_NETIF_FLAG_LEGACY    = 0x01,     
    NIMBLE_NETIF_FLAG_HD_MODE   = 0x02,     
};

typedef struct {
    uint8_t flags;              
    uint8_t channel_map;        
    uint8_t own_addr_type;      
    int8_t tx_power;            
    uint32_t adv_itvl_ms;       
    uint32_t timeout_ms;        
    nimble_phy_t primary_phy;   
    nimble_phy_t secondary_phy; 
} nimble_netif_accept_cfg_t;

typedef struct {
    uint16_t scan_itvl_ms;      
    uint16_t scan_window_ms;    
    uint16_t conn_itvl_min_ms;  
    uint16_t conn_itvl_max_ms;  
    uint16_t conn_supervision_timeout_ms;   
    uint16_t conn_slave_latency;
    uint32_t timeout_ms;        
    uint8_t phy_mode;           
    uint8_t own_addr_type;      
} nimble_netif_connect_cfg_t;

#ifndef NIMBLE_NETIF_CONN_ITVL_SPACING
#define NIMBLE_NETIF_CONN_ITVL_SPACING          0
#endif

typedef enum {
    NIMBLE_NETIF_ACCEPTING,         
    NIMBLE_NETIF_ACCEPT_STOP,       
    NIMBLE_NETIF_INIT_MASTER,       
    NIMBLE_NETIF_INIT_SLAVE,        
    NIMBLE_NETIF_CONNECTED_MASTER,  
    NIMBLE_NETIF_CONNECTED_SLAVE,   
    NIMBLE_NETIF_CLOSED_MASTER,     
    NIMBLE_NETIF_CLOSED_SLAVE,      
    NIMBLE_NETIF_ABORT_MASTER,      
    NIMBLE_NETIF_ABORT_SLAVE,       
    NIMBLE_NETIF_CONN_UPDATED,      
} nimble_netif_event_t;

enum {
    NIMBLE_NETIF_L2CAP_CLIENT       = 0x0001,   
    NIMBLE_NETIF_L2CAP_SERVER       = 0x0002,   
    NIMBLE_NETIF_L2CAP_CONNECTED    = 0x0003,   
    NIMBLE_NETIF_GAP_MASTER         = 0x0010,   
    NIMBLE_NETIF_GAP_SLAVE          = 0x0020,   
    NIMBLE_NETIF_GAP_CONNECTED      = 0x0030,   
    NIMBLE_NETIF_ADV                = 0x0100,   
    NIMBLE_NETIF_CONNECTING         = 0x4000,   
    NIMBLE_NETIF_UNUSED             = 0x8000,   
    NIMBLE_NETIF_ANY                = 0xffff,   
};

typedef void(*nimble_netif_eventcb_t)(int handle,
                                      nimble_netif_event_t event,
                                      const uint8_t *addr);

void nimble_netif_init(void);

void nimble_netif_eventcb(nimble_netif_eventcb_t cb);

int nimble_netif_connect(const ble_addr_t *addr,
                         const nimble_netif_connect_cfg_t *cfg);

int nimble_netif_close(int handle);

int nimble_netif_accept(const uint8_t *ad, size_t ad_len,
                        const nimble_netif_accept_cfg_t *cfg);

int nimble_netif_accept_direct(const ble_addr_t *addr,
                               const nimble_netif_accept_cfg_t *cfg);

int nimble_netif_accept_stop(void);

int nimble_netif_update(int handle,
                        const struct ble_gap_upd_params *conn_params);

int nimble_netif_used_chanmap(int handle, uint8_t map[5]);
 
#ifdef __cplusplus
}
#endif