l2cap.h

Go to the documentation of this file.

 
#pragma once
 
#include <stdint.h>
 
#include "FreeRTOS.h"
#include "semphr.h"
 
// Every L2CAP device comes with 1 channel open
// That L2CAP uses for opening other channels and such
// So every device comes with the buffer for this.
// Must be a power of 2.
#define L2CAP_SIGNAL_CHANNEL_BUFFER_SIZE 256
 
#define L2CAP_CHANNEL_SIGNALS 0x0001
 
#define L2CAP_DEFAULT_MTU           185
#define L2CAP_DEFAULT_FLUSH_TIMEOUT 0xFFFF
 
typedef void (*l2cap_channel_event_t)(void* channel, void* user);
 
// Used internally by L2CAP when handling the signal channel.
typedef struct {
    uint8_t code; // Command Code
    uint8_t id; // Unique id for the request
    uint16_t length;
 
    uint8_t data[16]; // Arbitrary max size
} l2cap_signal_t;
 
typedef struct {
    void* device; // l2cap_device_t
    uint16_t sid; // Source ID, ID the endpoint will use when talking to us.
    uint16_t did; // Destination ID, ID we use when talking to the endpoint
 
    SemaphoreHandle_t on_complete_packet;
 
    // Stores multiple packets, each starting with a 16 byte size, then data.
    uint8_t* buffer;
    int buffer_length;
    int fifo_write_head;
    int fifo_write_head_packet; // Up to the last packet.
    int fifo_read_head;
 
    // Track incoming signals
    volatile l2cap_signal_t* incoming_signal;
    volatile uint8_t incoming_id;
    SemaphoreHandle_t signal_waiter;
 
    // Event for when a new received packet is made available.
    struct {
        l2cap_channel_event_t event;
        void* data;
    } event_packet_available;
 
    StaticSemaphore_t semaphore_data[2];
} l2cap_channel_t;
 
typedef struct {
    SemaphoreHandle_t lock;
    uint16_t handle;
    struct {
        l2cap_channel_t** array;
        size_t length;
    } open_channels;
 
    // Default open channel L2CAP must use
    l2cap_channel_t signal_channel;
    uint8_t signal_channel_buffer[L2CAP_SIGNAL_CHANNEL_BUFFER_SIZE];
 
    // L2CAP Reading into Handle State
    l2cap_channel_t* reading_channel;
    uint16_t reading_remaining;
 
    uint8_t mac_address[6];
 
    StaticSemaphore_t semaphore_data;
} l2cap_device_t;

extern int l2cap_initialize();

extern void l2cap_signal_close();

extern void l2cap_close();

extern int l2cap_open_device(l2cap_device_t* device_handle, uint16_t hci_device_handle, const uint8_t* mac_address);

extern void l2cap_close_device(l2cap_device_t* device_handle);

extern int l2cap_open_channel(l2cap_device_t* device_handle, l2cap_channel_t* channel, uint16_t protocol_id, uint8_t* rx_buffer, int rx_buffer_size);

extern void l2cap_close_channel(l2cap_channel_t* channel);

extern int l2cap_send_channel(l2cap_channel_t* channel, const void* data, uint16_t size);

extern int l2cap_receive_channel(l2cap_channel_t* channel, void* data, uint16_t size);

extern void l2cap_set_channel_receive_event(l2cap_channel_t* channel, l2cap_channel_event_t event, void* param);