Add default Bluetooth HAL implementation
Also added initial target-side functional test.
Test: bluetooth_hidl_hal_test
Bug: 31972505
Change-Id: I1f574a5b2b53d7fbf65dbb4e1aaa5f8b6c5a9448
diff --git a/bluetooth/1.0/default/vendor_interface.cc b/bluetooth/1.0/default/vendor_interface.cc
new file mode 100644
index 0000000..7efd5bd
--- /dev/null
+++ b/bluetooth/1.0/default/vendor_interface.cc
@@ -0,0 +1,351 @@
+//
+// Copyright 2016 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#include "vendor_interface.h"
+
+#define LOG_TAG "android.hardware.bluetooth@1.0-impl"
+#include <android-base/logging.h>
+#include <utils/Log.h>
+
+#include <dlfcn.h>
+
+static const char* VENDOR_LIBRARY_NAME = "libbt-vendor.so";
+static const char* VENDOR_LIBRARY_SYMBOL_NAME =
+ "BLUETOOTH_VENDOR_LIB_INTERFACE";
+
+static const int INVALID_FD = -1;
+
+namespace {
+
+using android::hardware::bluetooth::V1_0::implementation::VendorInterface;
+
+tINT_CMD_CBACK internal_command_cb;
+VendorInterface* g_vendor_interface = nullptr;
+
+const size_t preamble_size_for_type[] = {
+ 0, HCI_COMMAND_PREAMBLE_SIZE, HCI_ACL_PREAMBLE_SIZE, HCI_SCO_PREAMBLE_SIZE,
+ HCI_EVENT_PREAMBLE_SIZE};
+const size_t packet_length_offset_for_type[] = {
+ 0, HCI_LENGTH_OFFSET_CMD, HCI_LENGTH_OFFSET_ACL, HCI_LENGTH_OFFSET_SCO,
+ HCI_LENGTH_OFFSET_EVT};
+
+size_t HciGetPacketLengthForType(
+ HciPacketType type, const android::hardware::hidl_vec<uint8_t>& packet) {
+ size_t offset = packet_length_offset_for_type[type];
+ if (type == HCI_PACKET_TYPE_ACL_DATA) {
+ return (((packet[offset + 1]) << 8) | packet[offset]);
+ }
+ return packet[offset];
+}
+
+HC_BT_HDR* WrapPacketAndCopy(uint16_t event,
+ const android::hardware::hidl_vec<uint8_t>& data) {
+ size_t packet_size = data.size() + sizeof(HC_BT_HDR);
+ HC_BT_HDR* packet = reinterpret_cast<HC_BT_HDR*>(new uint8_t[packet_size]);
+ packet->offset = 0;
+ packet->len = data.size();
+ packet->layer_specific = 0;
+ packet->event = event;
+ // TODO(eisenbach): Avoid copy here; if BT_HDR->data can be enusred to
+ // be the only way the data is accessed, a pointer could be passed here...
+ memcpy(packet->data, data.data(), data.size());
+ return packet;
+}
+
+uint8_t transmit_cb(uint16_t opcode, void* buffer, tINT_CMD_CBACK callback) {
+ ALOGV("%s opcode: 0x%04x, ptr: %p", __func__, opcode, buffer);
+ HC_BT_HDR* bt_hdr = reinterpret_cast<HC_BT_HDR*>(buffer);
+
+ internal_command_cb = callback;
+ uint8_t type = HCI_PACKET_TYPE_COMMAND;
+ VendorInterface::get()->SendPrivate(&type, 1);
+ VendorInterface::get()->SendPrivate(bt_hdr->data, bt_hdr->len);
+ return true;
+}
+
+void firmware_config_cb(bt_vendor_op_result_t result) {
+ ALOGD("%s result: %d", __func__, result);
+ VendorInterface::get()->OnFirmwareConfigured(result);
+}
+
+void sco_config_cb(bt_vendor_op_result_t result) {
+ ALOGD("%s result: %d", __func__, result);
+}
+
+void low_power_mode_cb(bt_vendor_op_result_t result) {
+ ALOGD("%s result: %d", __func__, result);
+}
+
+void sco_audiostate_cb(bt_vendor_op_result_t result) {
+ ALOGD("%s result: %d", __func__, result);
+}
+
+void* buffer_alloc_cb(int size) {
+ void* p = new uint8_t[size];
+ ALOGV("%s pts: %p, size: %d", __func__, p, size);
+ return p;
+}
+
+void buffer_free_cb(void* buffer) {
+ ALOGV("%s ptr: %p", __func__, buffer);
+ delete[] reinterpret_cast<uint8_t*>(buffer);
+}
+
+void epilog_cb(bt_vendor_op_result_t result) {
+ ALOGD("%s result: %d", __func__, result);
+}
+
+void a2dp_offload_cb(bt_vendor_op_result_t result, bt_vendor_opcode_t op,
+ uint8_t av_handle) {
+ ALOGD("%s result: %d, op: %d, handle: %d", __func__, result, op, av_handle);
+}
+
+const bt_vendor_callbacks_t lib_callbacks = {
+ sizeof(lib_callbacks), firmware_config_cb, sco_config_cb,
+ low_power_mode_cb, sco_audiostate_cb, buffer_alloc_cb,
+ buffer_free_cb, transmit_cb, epilog_cb,
+ a2dp_offload_cb};
+
+} // namespace
+
+namespace android {
+namespace hardware {
+namespace bluetooth {
+namespace V1_0 {
+namespace implementation {
+
+bool VendorInterface::Initialize(PacketReadCallback packet_read_cb) {
+ assert(!g_vendor_interface);
+ g_vendor_interface = new VendorInterface();
+ return g_vendor_interface->Open(packet_read_cb);
+}
+
+void VendorInterface::Shutdown() {
+ CHECK(g_vendor_interface);
+ g_vendor_interface->Close();
+ delete g_vendor_interface;
+ g_vendor_interface = nullptr;
+}
+
+VendorInterface* VendorInterface::get() { return g_vendor_interface; }
+
+bool VendorInterface::Open(PacketReadCallback packet_read_cb) {
+ // TODO(eisenbach): P0 - get local BD address somehow
+ uint8_t local_bda[] = {0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff};
+
+ firmware_configured_ = false;
+ packet_read_cb_ = packet_read_cb;
+
+ // Initialize vendor interface
+
+ lib_handle_ = dlopen(VENDOR_LIBRARY_NAME, RTLD_NOW);
+ if (!lib_handle_) {
+ ALOGE("%s unable to open %s (%s)", __func__, VENDOR_LIBRARY_NAME,
+ dlerror());
+ return false;
+ }
+
+ lib_interface_ = reinterpret_cast<bt_vendor_interface_t*>(
+ dlsym(lib_handle_, VENDOR_LIBRARY_SYMBOL_NAME));
+ if (!lib_interface_) {
+ ALOGE("%s unable to find symbol %s in %s (%s)", __func__,
+ VENDOR_LIBRARY_SYMBOL_NAME, VENDOR_LIBRARY_NAME, dlerror());
+ return false;
+ }
+
+ int status = lib_interface_->init(&lib_callbacks, (unsigned char*)local_bda);
+ if (status) {
+ ALOGE("%s unable to initialize vendor library: %d", __func__, status);
+ return false;
+ }
+
+ ALOGD("%s vendor library loaded", __func__);
+
+ // Power cycle chip
+
+ int power_state = BT_VND_PWR_OFF;
+ lib_interface_->op(BT_VND_OP_POWER_CTRL, &power_state);
+ power_state = BT_VND_PWR_ON;
+ lib_interface_->op(BT_VND_OP_POWER_CTRL, &power_state);
+
+ // Get the UART socket
+
+ int fd_list[CH_MAX] = {0};
+ int fd_count = lib_interface_->op(BT_VND_OP_USERIAL_OPEN, &fd_list);
+
+ if (fd_count != 1) {
+ ALOGE("%s fd count %d != 1; we can't handle this currently...", __func__,
+ fd_count);
+ return false;
+ }
+
+ uart_fd_ = fd_list[0];
+ if (uart_fd_ == INVALID_FD) {
+ ALOGE("%s unable to determine UART fd", __func__);
+ return false;
+ }
+
+ ALOGD("%s UART fd: %d", __func__, uart_fd_);
+
+ fd_watcher_.WatchFdForNonBlockingReads(uart_fd_,
+ [this](int fd) { OnDataReady(fd); });
+
+ // Start configuring the firmware
+ lib_interface_->op(BT_VND_OP_FW_CFG, nullptr);
+
+ return true;
+}
+
+void VendorInterface::Close() {
+ fd_watcher_.StopWatchingFileDescriptor();
+
+ if (lib_interface_ != nullptr) {
+ lib_interface_->op(BT_VND_OP_USERIAL_CLOSE, nullptr);
+ uart_fd_ = INVALID_FD;
+ int power_state = BT_VND_PWR_OFF;
+ lib_interface_->op(BT_VND_OP_POWER_CTRL, &power_state);
+ }
+
+ if (lib_handle_ != nullptr) {
+ dlclose(lib_handle_);
+ lib_handle_ = nullptr;
+ }
+
+ firmware_configured_ = false;
+}
+
+size_t VendorInterface::Send(const uint8_t* data, size_t length) {
+ if (firmware_configured_ && queued_data_.size() == 0)
+ return SendPrivate(data, length);
+
+ if (!firmware_configured_) {
+ ALOGI("%s queueing command", __func__);
+ queued_data_.resize(queued_data_.size() + length);
+ uint8_t* append_ptr = &queued_data_[queued_data_.size() - length];
+ memcpy(append_ptr, data, length);
+ return length;
+ }
+
+ ALOGI("%s sending queued command", __func__);
+ SendPrivate(queued_data_.data(), queued_data_.size());
+ queued_data_.resize(0);
+
+ ALOGI("%s done sending queued command", __func__);
+
+ return SendPrivate(data, length);
+}
+
+size_t VendorInterface::SendPrivate(const uint8_t* data, size_t length) {
+ if (uart_fd_ == INVALID_FD) return 0;
+
+ size_t transmitted_length = 0;
+ while (length > 0) {
+ ssize_t ret =
+ TEMP_FAILURE_RETRY(write(uart_fd_, data + transmitted_length, length));
+
+ if (ret == -1) {
+ if (errno == EAGAIN) continue;
+ ALOGE("%s error writing to UART (%s)", __func__, strerror(errno));
+ break;
+
+ } else if (ret == 0) {
+ // Nothing written :(
+ ALOGE("%s zero bytes written - something went wrong...", __func__);
+ break;
+ }
+
+ transmitted_length += ret;
+ length -= ret;
+ }
+
+ return transmitted_length;
+}
+
+void VendorInterface::OnFirmwareConfigured(uint8_t result) {
+ ALOGI("%s: result = %d", __func__, result);
+ firmware_configured_ = true;
+ VendorInterface::get()->Send(NULL, 0);
+}
+
+void VendorInterface::OnDataReady(int fd) {
+ switch (hci_parser_state_) {
+ case HCI_IDLE: {
+ uint8_t buffer[1] = {0};
+ size_t bytes_read = TEMP_FAILURE_RETRY(read(fd, buffer, 1));
+ CHECK(bytes_read == 1);
+ hci_packet_type_ = static_cast<HciPacketType>(buffer[0]);
+ // TODO(eisenbach): Check for workaround(s)
+ CHECK(hci_packet_type_ >= HCI_PACKET_TYPE_ACL_DATA &&
+ hci_packet_type_ <= HCI_PACKET_TYPE_EVENT)
+ << "buffer[0] = " << buffer[0];
+ hci_parser_state_ = HCI_TYPE_READY;
+ hci_packet_.resize(HCI_PREAMBLE_SIZE_MAX);
+ hci_packet_bytes_remaining_ = preamble_size_for_type[hci_packet_type_];
+ hci_packet_bytes_read_ = 0;
+ break;
+ }
+
+ case HCI_TYPE_READY: {
+ size_t bytes_read = TEMP_FAILURE_RETRY(
+ read(fd, hci_packet_.data() + hci_packet_bytes_read_,
+ hci_packet_bytes_remaining_));
+ CHECK(bytes_read > 0);
+ hci_packet_bytes_remaining_ -= bytes_read;
+ hci_packet_bytes_read_ += bytes_read;
+ if (hci_packet_bytes_remaining_ == 0) {
+ size_t packet_length =
+ HciGetPacketLengthForType(hci_packet_type_, hci_packet_);
+ hci_packet_.resize(preamble_size_for_type[hci_packet_type_] +
+ packet_length);
+ hci_packet_bytes_remaining_ = packet_length;
+ hci_parser_state_ = HCI_PAYLOAD;
+ hci_packet_bytes_read_ = 0;
+ }
+ break;
+ }
+
+ case HCI_PAYLOAD: {
+ size_t bytes_read = TEMP_FAILURE_RETRY(
+ read(fd,
+ hci_packet_.data() + preamble_size_for_type[hci_packet_type_] +
+ hci_packet_bytes_read_,
+ hci_packet_bytes_remaining_));
+ hci_packet_bytes_remaining_ -= bytes_read;
+ hci_packet_bytes_read_ += bytes_read;
+ if (hci_packet_bytes_remaining_ == 0) {
+ if (firmware_configured_) {
+ if (packet_read_cb_ != nullptr) {
+ packet_read_cb_(hci_packet_type_, hci_packet_);
+ }
+ } else {
+ if (internal_command_cb != nullptr) {
+ HC_BT_HDR* bt_hdr =
+ WrapPacketAndCopy(HCI_PACKET_TYPE_EVENT, hci_packet_);
+ internal_command_cb(bt_hdr);
+ }
+ }
+ hci_parser_state_ = HCI_IDLE;
+ }
+ break;
+ }
+ }
+}
+
+} // namespace implementation
+} // namespace V1_0
+} // namespace bluetooth
+} // namespace hardware
+} // namespace android