nimble_netif.h

Go to the documentation of this file.

/*
 * Copyright (C) 2018-2021 Freie Universität Berlin
 *
 * This file is subject to the terms and conditions of the GNU Lesser
 * General Public License v2.1. See the file LICENSE in the top level
 * directory for more details.
 */
 
#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