hci.h

Go to the documentation of this file.

#pragma once
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
#include "FreeRTOS.h"
#include "semphr.h"
 
#include "powerblocks/core/system/system.h"
#include "powerblocks/core/ios/ios.h"
 
typedef struct {
    uint8_t address[6];
    uint8_t page_scan_repetition_mode;
    uint32_t class_of_device;
    uint16_t clock_offset;
} hci_discovered_device_info_t;
 
typedef struct {
    uint16_t acl_data_packet_length;
    uint8_t synchronous_data_packet_length;
    uint16_t total_num_acl_data_packets;         // Total ACL packets the hardware can store.
    uint16_t total_num_synchronous_data_packets; // Total Sync packets the hardware can store.
} hci_buffer_sizes_t;
 
 
// Tired of coding
// Felt like being evil with these names
// Feel free to refactor. I am sorry
typedef enum {
    HCI_ACL_PACKET_BOUNDARY_FLAG_FIRST_NON_AUTOMATICALLY_FLUSHABLE_PACKET,
    HCI_ACL_PACKET_BOUNDARY_FLAG_CONTINUING_FRAGMENT,
    HCI_ACL_PACKET_BOUNDARY_FLAG_FIRST_AUTOMATICALLY_FLUSHABLE_PACKET
} hci_acl_packet_boundary_flag_t;
 
typedef enum {
    HCI_ACL_PACKET_BROADCAST_FLAG_PTP,
    HCI_ACL_PACKET_BROADCAST_FLAG_ACTIVE_DEVICE,
    HCI_ACL_PACKET_BROADCAST_FLAG_PARKED_DEVICE,
} hci_acl_packet_broadcast_flag_t;
 
// HCI Defines multiple inquiry modes. We will probably ever use one.
#define HCI_INQUIRY_MODE_GENERAL_ACCESS 0x9E8B33
 
// Max size of a name from name request
#define HCI_MAX_NAME_REQUEST_LENGTH 254
 
// Max size of a ACL data section
// This must be at least greater than the max size
// Reported by the hardware. On the wii it reports 339 bytes.
#define HCI_MAX_ACL_DATA_LENGTH 512
 
// Defines the amount of data on the stack needed for the ACL receive, used to be kept around for async
#define HCI_ACL_RECEIVE_IPC_BUFFER_SIZE (32 + 32 + 32 + 32 + sizeof(ipc_message))
 
typedef struct {
    uint16_t handle;
    uint16_t size;
    uint8_t data[HCI_MAX_ACL_DATA_LENGTH];
} hci_acl_packet_t;
 
// Exposed HCI Buffer Sizes
// These are read from the controller when HCI is initialized.
// Used for knowing how big and how many ACL/SCL buffers you can send
extern hci_buffer_sizes_t hci_buffer_sizes;
 

typedef void (*hci_discovered_device_handler)(void* user_data, const hci_discovered_device_info_t* device);

typedef void (*hci_discovery_complete_handler)(void* user_data, uint8_t error);

extern int hci_initialize(const char* device);

extern void hci_close();

extern int hci_reset();

extern int hci_begin_discovery(
        uint32_t lap, uint8_t length, uint8_t responses,
        hci_discovered_device_handler on_discovered, hci_discovery_complete_handler on_complete, void *user_data);

extern int hci_cancel_discovery();

extern int hci_get_remote_name(const hci_discovered_device_info_t* device, uint8_t* name);

extern int hci_create_connection(const hci_discovered_device_info_t* device, uint16_t* handle);
 
// These 2 buffers have been statically allocated so that
// You can lower the amount of memcpys in ACL transactions
extern SemaphoreHandle_t hcl_acl_packet_out_lock;
extern hci_acl_packet_t hci_acl_packet_out ALIGN(32) MEM2;
extern hci_acl_packet_t hci_acl_packet_in_0 ALIGN(32) MEM2;
extern hci_acl_packet_t hci_acl_packet_in_1 ALIGN(32) MEM2;

extern int hci_send_acl(uint16_t handle, hci_acl_packet_boundary_flag_t pb, hci_acl_packet_broadcast_flag_t bc, uint16_t length);

extern int hci_receive_acl_async(hci_acl_packet_t* acl_buffer, uint8_t* ipc_buffer, ipc_async_handler_t handler, void* params);
 

extern void hci_decode_received_acl(uint16_t *handle, hci_acl_packet_boundary_flag_t *pb, hci_acl_packet_broadcast_flag_t *bc, uint16_t* length, const hci_acl_packet_t* acl_buffer);