1//
2// Copyright 2016 The Android Open Source Project
3//
4// Licensed under the Apache License, Version 2.0 (the "License");
5// you may not use this file except in compliance with the License.
6// You may obtain a copy of the License at
7//
8// http://www.apache.org/licenses/LICENSE-2.0
9//
10// Unless required by applicable law or agreed to in writing, software
11// distributed under the License is distributed on an "AS IS" BASIS,
12// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13// See the License for the specific language governing permissions and
14// limitations under the License.
15//
16
17#include "vendor_interface.h"
18
19#define LOG_TAG "android.hardware.bluetooth@1.0-impl"
20#include <cutils/properties.h>
21#include <utils/Log.h>
22
23#include <dlfcn.h>
24#include <fcntl.h>
25
26#include "bluetooth_address.h"
27#include "h4_protocol.h"
28#include "mct_protocol.h"
29
30static const char* VENDOR_LIBRARY_NAME = "libbt-vendor.so";
31static const char* VENDOR_LIBRARY_SYMBOL_NAME =
32    "BLUETOOTH_VENDOR_LIB_INTERFACE";
33
34static const int INVALID_FD = -1;
35
36namespace {
37
38using android::hardware::bluetooth::V1_0::implementation::VendorInterface;
39using android::hardware::hidl_vec;
40
41struct {
42  tINT_CMD_CBACK cb;
43  uint16_t opcode;
44} internal_command;
45
46// True when LPM is not enabled yet or wake is not asserted.
47bool lpm_wake_deasserted;
48uint32_t lpm_timeout_ms;
49bool recent_activity_flag;
50
51VendorInterface* g_vendor_interface = nullptr;
52std::mutex wakeup_mutex_;
53
54HC_BT_HDR* WrapPacketAndCopy(uint16_t event, const hidl_vec<uint8_t>& data) {
55  size_t packet_size = data.size() + sizeof(HC_BT_HDR);
56  HC_BT_HDR* packet = reinterpret_cast<HC_BT_HDR*>(new uint8_t[packet_size]);
57  packet->offset = 0;
58  packet->len = data.size();
59  packet->layer_specific = 0;
60  packet->event = event;
61  // TODO(eisenbach): Avoid copy here; if BT_HDR->data can be ensured to
62  // be the only way the data is accessed, a pointer could be passed here...
63  memcpy(packet->data, data.data(), data.size());
64  return packet;
65}
66
67bool internal_command_event_match(const hidl_vec<uint8_t>& packet) {
68  uint8_t event_code = packet[0];
69  if (event_code != HCI_COMMAND_COMPLETE_EVENT) {
70    ALOGE("%s: Unhandled event type %02X", __func__, event_code);
71    return false;
72  }
73
74  size_t opcode_offset = HCI_EVENT_PREAMBLE_SIZE + 1;  // Skip num packets.
75
76  uint16_t opcode = packet[opcode_offset] | (packet[opcode_offset + 1] << 8);
77
78  ALOGV("%s internal_command.opcode = %04X opcode = %04x", __func__,
79        internal_command.opcode, opcode);
80  return opcode == internal_command.opcode;
81}
82
83uint8_t transmit_cb(uint16_t opcode, void* buffer, tINT_CMD_CBACK callback) {
84  ALOGV("%s opcode: 0x%04x, ptr: %p, cb: %p", __func__, opcode, buffer,
85        callback);
86  internal_command.cb = callback;
87  internal_command.opcode = opcode;
88  uint8_t type = HCI_PACKET_TYPE_COMMAND;
89  HC_BT_HDR* bt_hdr = reinterpret_cast<HC_BT_HDR*>(buffer);
90  VendorInterface::get()->Send(type, bt_hdr->data, bt_hdr->len);
91  delete[] reinterpret_cast<uint8_t*>(buffer);
92  return true;
93}
94
95void firmware_config_cb(bt_vendor_op_result_t result) {
96  ALOGV("%s result: %d", __func__, result);
97  VendorInterface::get()->OnFirmwareConfigured(result);
98}
99
100void sco_config_cb(bt_vendor_op_result_t result) {
101  ALOGD("%s result: %d", __func__, result);
102}
103
104void low_power_mode_cb(bt_vendor_op_result_t result) {
105  ALOGD("%s result: %d", __func__, result);
106}
107
108void sco_audiostate_cb(bt_vendor_op_result_t result) {
109  ALOGD("%s result: %d", __func__, result);
110}
111
112void* buffer_alloc_cb(int size) {
113  void* p = new uint8_t[size];
114  ALOGV("%s pts: %p, size: %d", __func__, p, size);
115  return p;
116}
117
118void buffer_free_cb(void* buffer) {
119  ALOGV("%s ptr: %p", __func__, buffer);
120  delete[] reinterpret_cast<uint8_t*>(buffer);
121}
122
123void epilog_cb(bt_vendor_op_result_t result) {
124  ALOGD("%s result: %d", __func__, result);
125}
126
127void a2dp_offload_cb(bt_vendor_op_result_t result, bt_vendor_opcode_t op,
128                     uint8_t av_handle) {
129  ALOGD("%s result: %d, op: %d, handle: %d", __func__, result, op, av_handle);
130}
131
132const bt_vendor_callbacks_t lib_callbacks = {
133    sizeof(lib_callbacks), firmware_config_cb, sco_config_cb,
134    low_power_mode_cb,     sco_audiostate_cb,  buffer_alloc_cb,
135    buffer_free_cb,        transmit_cb,        epilog_cb,
136    a2dp_offload_cb};
137
138}  // namespace
139
140namespace android {
141namespace hardware {
142namespace bluetooth {
143namespace V1_0 {
144namespace implementation {
145
146class FirmwareStartupTimer {
147 public:
148  FirmwareStartupTimer() : start_time_(std::chrono::steady_clock::now()) {}
149
150  ~FirmwareStartupTimer() {
151    std::chrono::duration<double> duration =
152        std::chrono::steady_clock::now() - start_time_;
153    double s = duration.count();
154    if (s == 0) return;
155    ALOGI("Firmware configured in %.3fs", s);
156  }
157
158 private:
159  std::chrono::steady_clock::time_point start_time_;
160};
161
162bool VendorInterface::Initialize(
163    InitializeCompleteCallback initialize_complete_cb,
164    PacketReadCallback event_cb, PacketReadCallback acl_cb,
165    PacketReadCallback sco_cb) {
166  if (g_vendor_interface) {
167    ALOGE("%s: No previous Shutdown()?", __func__);
168    return false;
169  }
170  g_vendor_interface = new VendorInterface();
171  return g_vendor_interface->Open(initialize_complete_cb, event_cb, acl_cb,
172                                  sco_cb);
173}
174
175void VendorInterface::Shutdown() {
176  LOG_ALWAYS_FATAL_IF(!g_vendor_interface, "%s: No Vendor interface!",
177                      __func__);
178  g_vendor_interface->Close();
179  delete g_vendor_interface;
180  g_vendor_interface = nullptr;
181}
182
183VendorInterface* VendorInterface::get() { return g_vendor_interface; }
184
185bool VendorInterface::Open(InitializeCompleteCallback initialize_complete_cb,
186                           PacketReadCallback event_cb,
187                           PacketReadCallback acl_cb,
188                           PacketReadCallback sco_cb) {
189  initialize_complete_cb_ = initialize_complete_cb;
190
191  // Initialize vendor interface
192
193  lib_handle_ = dlopen(VENDOR_LIBRARY_NAME, RTLD_NOW);
194  if (!lib_handle_) {
195    ALOGE("%s unable to open %s (%s)", __func__, VENDOR_LIBRARY_NAME,
196          dlerror());
197    return false;
198  }
199
200  lib_interface_ = reinterpret_cast<bt_vendor_interface_t*>(
201      dlsym(lib_handle_, VENDOR_LIBRARY_SYMBOL_NAME));
202  if (!lib_interface_) {
203    ALOGE("%s unable to find symbol %s in %s (%s)", __func__,
204          VENDOR_LIBRARY_SYMBOL_NAME, VENDOR_LIBRARY_NAME, dlerror());
205    return false;
206  }
207
208  // Get the local BD address
209
210  uint8_t local_bda[BluetoothAddress::kBytes];
211  if (!BluetoothAddress::get_local_address(local_bda)) {
212    LOG_ALWAYS_FATAL("%s: No Bluetooth Address!", __func__);
213  }
214  int status = lib_interface_->init(&lib_callbacks, (unsigned char*)local_bda);
215  if (status) {
216    ALOGE("%s unable to initialize vendor library: %d", __func__, status);
217    return false;
218  }
219
220  ALOGD("%s vendor library loaded", __func__);
221
222  // Power on the controller
223
224  int power_state = BT_VND_PWR_ON;
225  lib_interface_->op(BT_VND_OP_POWER_CTRL, &power_state);
226
227  // Get the UART socket(s)
228
229  int fd_list[CH_MAX] = {0};
230  int fd_count = lib_interface_->op(BT_VND_OP_USERIAL_OPEN, &fd_list);
231
232  if (fd_count < 1 || fd_count > CH_MAX - 1) {
233    ALOGE("%s: fd_count %d is invalid!", __func__, fd_count);
234    return false;
235  }
236
237  for (int i = 0; i < fd_count; i++) {
238    if (fd_list[i] == INVALID_FD) {
239      ALOGE("%s: fd %d is invalid!", __func__, fd_list[i]);
240      return false;
241    }
242  }
243
244  event_cb_ = event_cb;
245  PacketReadCallback intercept_events = [this](const hidl_vec<uint8_t>& event) {
246    HandleIncomingEvent(event);
247  };
248
249  if (fd_count == 1) {
250    hci::H4Protocol* h4_hci =
251        new hci::H4Protocol(fd_list[0], intercept_events, acl_cb, sco_cb);
252    fd_watcher_.WatchFdForNonBlockingReads(
253        fd_list[0], [h4_hci](int fd) { h4_hci->OnDataReady(fd); });
254    hci_ = h4_hci;
255  } else {
256    hci::MctProtocol* mct_hci =
257        new hci::MctProtocol(fd_list, intercept_events, acl_cb);
258    fd_watcher_.WatchFdForNonBlockingReads(
259        fd_list[CH_EVT], [mct_hci](int fd) { mct_hci->OnEventDataReady(fd); });
260    fd_watcher_.WatchFdForNonBlockingReads(
261        fd_list[CH_ACL_IN],
262        [mct_hci](int fd) { mct_hci->OnAclDataReady(fd); });
263    hci_ = mct_hci;
264  }
265
266  // Initially, the power management is off.
267  lpm_wake_deasserted = true;
268
269  // Start configuring the firmware
270  firmware_startup_timer_ = new FirmwareStartupTimer();
271  lib_interface_->op(BT_VND_OP_FW_CFG, nullptr);
272
273  return true;
274}
275
276void VendorInterface::Close() {
277  // These callbacks may send HCI events (vendor-dependent), so make sure to
278  // StopWatching the file descriptor after this.
279  if (lib_interface_ != nullptr) {
280    bt_vendor_lpm_mode_t mode = BT_VND_LPM_DISABLE;
281    lib_interface_->op(BT_VND_OP_LPM_SET_MODE, &mode);
282  }
283
284  fd_watcher_.StopWatchingFileDescriptors();
285
286  if (hci_ != nullptr) {
287    delete hci_;
288    hci_ = nullptr;
289  }
290
291  if (lib_interface_ != nullptr) {
292    lib_interface_->op(BT_VND_OP_USERIAL_CLOSE, nullptr);
293
294    int power_state = BT_VND_PWR_OFF;
295    lib_interface_->op(BT_VND_OP_POWER_CTRL, &power_state);
296
297    lib_interface_->cleanup();
298  }
299
300  if (lib_handle_ != nullptr) {
301    dlclose(lib_handle_);
302    lib_handle_ = nullptr;
303  }
304
305  if (firmware_startup_timer_ != nullptr) {
306    delete firmware_startup_timer_;
307    firmware_startup_timer_ = nullptr;
308  }
309}
310
311size_t VendorInterface::Send(uint8_t type, const uint8_t* data, size_t length) {
312  std::unique_lock<std::mutex> lock(wakeup_mutex_);
313  recent_activity_flag = true;
314
315  if (lpm_wake_deasserted == true) {
316    // Restart the timer.
317    fd_watcher_.ConfigureTimeout(std::chrono::milliseconds(lpm_timeout_ms),
318                                 [this]() { OnTimeout(); });
319    // Assert wake.
320    lpm_wake_deasserted = false;
321    bt_vendor_lpm_wake_state_t wakeState = BT_VND_LPM_WAKE_ASSERT;
322    lib_interface_->op(BT_VND_OP_LPM_WAKE_SET_STATE, &wakeState);
323    ALOGV("%s: Sent wake before (%02x)", __func__, data[0] | (data[1] << 8));
324  }
325
326  return hci_->Send(type, data, length);
327}
328
329void VendorInterface::OnFirmwareConfigured(uint8_t result) {
330  ALOGD("%s result: %d", __func__, result);
331
332  if (firmware_startup_timer_ != nullptr) {
333    delete firmware_startup_timer_;
334    firmware_startup_timer_ = nullptr;
335  }
336
337  if (initialize_complete_cb_ != nullptr) {
338    initialize_complete_cb_(result == 0);
339    initialize_complete_cb_ = nullptr;
340  }
341
342  lib_interface_->op(BT_VND_OP_GET_LPM_IDLE_TIMEOUT, &lpm_timeout_ms);
343  ALOGI("%s: lpm_timeout_ms %d", __func__, lpm_timeout_ms);
344
345  bt_vendor_lpm_mode_t mode = BT_VND_LPM_ENABLE;
346  lib_interface_->op(BT_VND_OP_LPM_SET_MODE, &mode);
347
348  ALOGD("%s Calling StartLowPowerWatchdog()", __func__);
349  fd_watcher_.ConfigureTimeout(std::chrono::milliseconds(lpm_timeout_ms),
350                               [this]() { OnTimeout(); });
351}
352
353void VendorInterface::OnTimeout() {
354  ALOGV("%s", __func__);
355  std::unique_lock<std::mutex> lock(wakeup_mutex_);
356  if (recent_activity_flag == false) {
357    lpm_wake_deasserted = true;
358    bt_vendor_lpm_wake_state_t wakeState = BT_VND_LPM_WAKE_DEASSERT;
359    lib_interface_->op(BT_VND_OP_LPM_WAKE_SET_STATE, &wakeState);
360    fd_watcher_.ConfigureTimeout(std::chrono::seconds(0), []() {
361      ALOGE("Zero timeout! Should never happen.");
362    });
363  }
364  recent_activity_flag = false;
365}
366
367void VendorInterface::HandleIncomingEvent(const hidl_vec<uint8_t>& hci_packet) {
368  if (internal_command.cb != nullptr &&
369      internal_command_event_match(hci_packet)) {
370    HC_BT_HDR* bt_hdr = WrapPacketAndCopy(HCI_PACKET_TYPE_EVENT, hci_packet);
371
372    // The callbacks can send new commands, so don't zero after calling.
373    tINT_CMD_CBACK saved_cb = internal_command.cb;
374    internal_command.cb = nullptr;
375    saved_cb(bt_hdr);
376  } else {
377    event_cb_(hci_packet);
378  }
379}
380
381}  // namespace implementation
382}  // namespace V1_0
383}  // namespace bluetooth
384}  // namespace hardware
385}  // namespace android
386