mirror of
https://github.com/mudita/MuditaOS.git
synced 2026-01-16 01:48:42 -05:00
238 lines
7.7 KiB
C++
238 lines
7.7 KiB
C++
// Copyright (c) 2017-2024, Mudita Sp. z.o.o. All rights reserved.
|
|
// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
|
|
|
|
#include "BluetoothDriverImpl.hpp"
|
|
|
|
extern "C"
|
|
{
|
|
#include <btstack_event.h>
|
|
#include <btstack_util.h>
|
|
#include <bluetooth_company_id.h>
|
|
#include <btstack_memory.h>
|
|
#include <btstack_run_loop.h>
|
|
#include <hci.h>
|
|
|
|
#include <btstack_chipset_cc256x.h>
|
|
#include <btstack_link_key_db_memory.h>
|
|
}
|
|
|
|
#include <service-bluetooth/ServiceBluetooth.hpp>
|
|
#include <BtKeysStorage.hpp>
|
|
|
|
#ifdef TARGET_RT1051
|
|
#include <Bluetooth/glucode/btstack_uart_block_rt1051.h>
|
|
#else
|
|
extern "C"
|
|
{
|
|
#include <btstack_uart.h>
|
|
#include <btstack_run_loop_posix.h>
|
|
#include <btstack_tlv_posix.h>
|
|
}
|
|
#endif
|
|
|
|
namespace bluetooth
|
|
{
|
|
hci_transport_config_uart_t Driver::config;
|
|
PowerOnCallback Driver::powerOnCallback = nullptr;
|
|
|
|
#ifdef TARGET_RT1051
|
|
auto Driver::runLoopInitTarget(const btstack_run_loop *loop) -> const btstack_uart_block_t *
|
|
{
|
|
btstack_run_loop_init(loop);
|
|
return btstack_uart_block_rt1051_instance();
|
|
}
|
|
#else
|
|
auto Driver::runLoopInitLinux([[maybe_unused]] const btstack_run_loop *loop) -> const btstack_uart_block_t *
|
|
{
|
|
btstack_run_loop_init(btstack_run_loop_posix_get_instance());
|
|
config.device_name = "/dev/telit";
|
|
LOG_INFO("H4 device: %s", config.device_name);
|
|
return btstack_uart_block_posix_instance();
|
|
}
|
|
#endif
|
|
|
|
Driver::Driver(const btstack_run_loop *runLoop, sys::Service *ownerService)
|
|
: runLoop{runLoop}, gap{std::make_unique<bluetooth::GAP>(ownerService)}
|
|
{}
|
|
|
|
auto Driver::init() -> Result::Code
|
|
{
|
|
btstack_memory_init();
|
|
config = {
|
|
.type = HCI_TRANSPORT_CONFIG_UART,
|
|
.baudrate_init = 115200,
|
|
.baudrate_main = 0,
|
|
.flowcontrol = 1,
|
|
.device_name = nullptr,
|
|
};
|
|
#ifdef TARGET_RT1051
|
|
auto uartDriver = runLoopInitTarget(runLoop);
|
|
#else
|
|
auto uartDriver = runLoopInitLinux(runLoop);
|
|
#endif
|
|
|
|
const auto transport = hci_transport_h4_instance_for_uart(uartDriver);
|
|
hci_init(transport, (void *)&config);
|
|
|
|
hci_set_link_key_db(bluetooth::KeyStorage::getKeyStorage());
|
|
hciEventCallbackRegistration.callback = &hciPacketHandler;
|
|
hci_add_event_handler(&hciEventCallbackRegistration);
|
|
|
|
gap_ssp_set_io_capability(SSP_IO_CAPABILITY_DISPLAY_YES_NO);
|
|
gap_ssp_set_auto_accept(false);
|
|
|
|
gap_set_class_of_device(0x64020C);
|
|
|
|
LOG_DEBUG("BT worker run success");
|
|
return Result::Code::Success;
|
|
}
|
|
|
|
void Driver::hciPacketHandler(std::uint8_t packet_type,
|
|
std::uint16_t channel,
|
|
std::uint8_t *packet,
|
|
std::uint16_t size)
|
|
{
|
|
bd_addr_t addr;
|
|
if (packet_type != HCI_EVENT_PACKET) {
|
|
return;
|
|
}
|
|
switch (hci_event_packet_get_type(packet)) {
|
|
case BTSTACK_EVENT_STATE:
|
|
if (btstack_event_state_get_state(packet) != HCI_STATE_WORKING) {
|
|
break;
|
|
}
|
|
gap_local_bd_addr(addr);
|
|
LOG_INFO("BTStack up and running");
|
|
bluetooth::KeyStorage::settings->setValue(bluetooth::Settings::State,
|
|
static_cast<int>(BluetoothStatus::State::On));
|
|
if (powerOnCallback) {
|
|
powerOnCallback();
|
|
}
|
|
break;
|
|
case HCI_EVENT_COMMAND_COMPLETE:
|
|
if (HCI_EVENT_IS_COMMAND_COMPLETE(packet, hci_read_local_name)) {
|
|
if (hci_event_command_complete_get_return_parameters(packet)[0] != 0u) {
|
|
break;
|
|
}
|
|
// Terminate, name 248 chars
|
|
packet[6 + 248] = 0;
|
|
}
|
|
if (HCI_EVENT_IS_COMMAND_COMPLETE(packet, hci_read_local_version_information)) {
|
|
localVersionInformationHandler(packet);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
void Driver::localVersionInformationHandler(uint8_t *packet)
|
|
{
|
|
const std::uint16_t hci_version = packet[6];
|
|
const std::uint16_t hci_revision = little_endian_read_16(packet, 7);
|
|
const std::uint16_t lmp_version = packet[9];
|
|
const std::uint16_t manufacturer = little_endian_read_16(packet, 10);
|
|
const std::uint16_t lmp_subversion = little_endian_read_16(packet, 12);
|
|
LOG_INFO("Local version information: HCI Version: 0x%04x, HCI Revision: 0x%04x, LMP Version: 0x%04x, LMP "
|
|
"Subversion: 0x%04x, Manufacturer: 0x%04x",
|
|
hci_version,
|
|
hci_revision,
|
|
lmp_version,
|
|
lmp_subversion,
|
|
manufacturer);
|
|
|
|
switch (manufacturer) {
|
|
case BLUETOOTH_COMPANY_ID_TEXAS_INSTRUMENTS_INC:
|
|
LOG_INFO("Texas Instruments - CC256x compatible chipset.");
|
|
if (lmp_subversion != btstack_chipset_cc256x_lmp_subversion()) {
|
|
LOG_INFO("Error: LMP Subversion does not match initscript! ");
|
|
LOG_INFO("Your initscripts is for %s chipset",
|
|
btstack_chipset_cc256x_lmp_subversion() < lmp_subversion ? "an older" : "a newer");
|
|
LOG_INFO("Please update Makefile to include the appropriate bluetooth_init_cc256???.c file");
|
|
return;
|
|
}
|
|
LOG_INFO("Using 921600 baud");
|
|
config.baudrate_main = 921600;
|
|
hci_set_chipset(btstack_chipset_cc256x_instance());
|
|
#ifdef ENABLE_EHCILL
|
|
LOG_INFO("eHCILL enabled.");
|
|
#else
|
|
LOG_INFO("eHCILL disable.");
|
|
#endif
|
|
|
|
break;
|
|
case BLUETOOTH_COMPANY_ID_NORDIC_SEMICONDUCTOR_ASA:
|
|
LOG_INFO("Nordic Semiconductor nRF5 chipset.");
|
|
break;
|
|
default:
|
|
LOG_INFO("Unknown manufacturer / manufacturer not supported yet.\n");
|
|
break;
|
|
}
|
|
}
|
|
|
|
auto Driver::run() -> Result::Code
|
|
{
|
|
auto ret = hci_power_control(HCI_POWER_ON);
|
|
if (ret != 0) {
|
|
LOG_ERROR("HCI power on failed, can't start Bluetooth!");
|
|
return Result::Code::LibraryError;
|
|
}
|
|
LOG_INFO("HCI turned on - run BtStack loop\n");
|
|
btstack_run_loop_execute();
|
|
return Result::Code::Success;
|
|
}
|
|
|
|
void Driver::registerErrorCallback(const ErrorCallback &newCallback)
|
|
{
|
|
static ErrorCallback callback;
|
|
callback = newCallback;
|
|
hci_set_hardware_error_callback([](uint8_t val) -> void {
|
|
LOG_ERROR("Bluetooth HW ERROR! %d", val);
|
|
if (callback) {
|
|
callback(val);
|
|
}
|
|
});
|
|
}
|
|
|
|
void Driver::registerPowerOnCallback(const PowerOnCallback &newCallback)
|
|
{
|
|
powerOnCallback = newCallback;
|
|
}
|
|
|
|
auto Driver::stop() -> Result::Code
|
|
{
|
|
auto ret = hci_power_control(HCI_POWER_OFF);
|
|
if (ret != 0) {
|
|
LOG_ERROR("Can't turn off Bluetooth Stack!");
|
|
}
|
|
bluetooth::KeyStorage::settings->setValue(bluetooth::Settings::State,
|
|
static_cast<int>(BluetoothStatus::State::Off));
|
|
return ret != 0 ? Result::Code::LibraryError : Result::Code::Success;
|
|
}
|
|
|
|
auto Driver::scan() -> Result
|
|
{
|
|
return gap->scan();
|
|
}
|
|
|
|
void Driver::stopScan()
|
|
{
|
|
gap->stopScan();
|
|
}
|
|
|
|
void Driver::setVisibility(bool visibility)
|
|
{
|
|
gap->setVisibility(visibility);
|
|
}
|
|
|
|
void Driver::pair(Devicei device, std::uint8_t protectionLevel)
|
|
{
|
|
LOG_INFO("Device: %s, addr: %s", device.name.data(), device.address_str());
|
|
gap->pair(device, protectionLevel);
|
|
}
|
|
|
|
void Driver::unpair(Devicei device)
|
|
{
|
|
gap->unpair(device);
|
|
}
|
|
} // namespace bluetooth
|