// Copyright (c) 2017-2024, Mudita Sp. z.o.o. All rights reserved.
// For licensing, see https://github.com/mudita/MuditaOS/blob/master/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 <hci_dump.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