Merge "DRM 1.1: Add VINTF doc"
[android/platform-hardware-interfaces.git] / bluetooth / 1.0 / default / vendor_interface.cc
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 //
17 #include "vendor_interface.h"
19 #define LOG_TAG "android.hardware.bluetooth@1.0-impl"
20 #include <cutils/properties.h>
21 #include <utils/Log.h>
23 #include <dlfcn.h>
24 #include <fcntl.h>
26 #include "bluetooth_address.h"
27 #include "h4_protocol.h"
28 #include "mct_protocol.h"
30 static const char* VENDOR_LIBRARY_NAME = "libbt-vendor.so";
31 static const char* VENDOR_LIBRARY_SYMBOL_NAME =
32     "BLUETOOTH_VENDOR_LIB_INTERFACE";
34 static const int INVALID_FD = -1;
36 namespace {
38 using android::hardware::hidl_vec;
39 using android::hardware::bluetooth::V1_0::implementation::VendorInterface;
41 struct {
42   tINT_CMD_CBACK cb;
43   uint16_t opcode;
44 } internal_command;
46 // True when LPM is not enabled yet or wake is not asserted.
47 bool lpm_wake_deasserted;
48 uint32_t lpm_timeout_ms;
49 bool recent_activity_flag;
51 VendorInterface* g_vendor_interface = nullptr;
52 std::mutex wakeup_mutex_;
54 HC_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 }
67 bool 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   }
74   size_t opcode_offset = HCI_EVENT_PREAMBLE_SIZE + 1;  // Skip num packets.
76   uint16_t opcode = packet[opcode_offset] | (packet[opcode_offset + 1] << 8);
78   ALOGV("%s internal_command.opcode = %04X opcode = %04x", __func__,
79         internal_command.opcode, opcode);
80   return opcode == internal_command.opcode;
81 }
83 uint8_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 }
95 void firmware_config_cb(bt_vendor_op_result_t result) {
96   ALOGV("%s result: %d", __func__, result);
97   VendorInterface::get()->OnFirmwareConfigured(result);
98 }
100 void sco_config_cb(bt_vendor_op_result_t result) {
101   ALOGD("%s result: %d", __func__, result);
104 void low_power_mode_cb(bt_vendor_op_result_t result) {
105   ALOGD("%s result: %d", __func__, result);
108 void sco_audiostate_cb(bt_vendor_op_result_t result) {
109   ALOGD("%s result: %d", __func__, result);
112 void* 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;
118 void buffer_free_cb(void* buffer) {
119   ALOGV("%s ptr: %p", __func__, buffer);
120   delete[] reinterpret_cast<uint8_t*>(buffer);
123 void epilog_cb(bt_vendor_op_result_t result) {
124   ALOGD("%s result: %d", __func__, result);
127 void 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);
132 const 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};
138 }  // namespace
140 namespace android {
141 namespace hardware {
142 namespace bluetooth {
143 namespace V1_0 {
144 namespace implementation {
146 class FirmwareStartupTimer {
147  public:
148   FirmwareStartupTimer() : start_time_(std::chrono::steady_clock::now()) {}
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   }
158  private:
159   std::chrono::steady_clock::time_point start_time_;
160 };
162 bool 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);
175 void 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;
183 VendorInterface* VendorInterface::get() { return g_vendor_interface; }
185 bool 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;
191   // Initialize vendor interface
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   }
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   }
208   // Get the local BD address
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   }
220   ALOGD("%s vendor library loaded", __func__);
222   // Power on the controller
224   int power_state = BT_VND_PWR_ON;
225   lib_interface_->op(BT_VND_OP_POWER_CTRL, &power_state);
227   // Get the UART socket(s)
229   int fd_list[CH_MAX] = {0};
230   int fd_count = lib_interface_->op(BT_VND_OP_USERIAL_OPEN, &fd_list);
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   }
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   }
244   event_cb_ = event_cb;
245   PacketReadCallback intercept_events = [this](const hidl_vec<uint8_t>& event) {
246     HandleIncomingEvent(event);
247   };
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], [mct_hci](int fd) { mct_hci->OnAclDataReady(fd); });
262     hci_ = mct_hci;
263   }
265   // Initially, the power management is off.
266   lpm_wake_deasserted = true;
268   // Start configuring the firmware
269   firmware_startup_timer_ = new FirmwareStartupTimer();
270   lib_interface_->op(BT_VND_OP_FW_CFG, nullptr);
272   return true;
275 void VendorInterface::Close() {
276   // These callbacks may send HCI events (vendor-dependent), so make sure to
277   // StopWatching the file descriptor after this.
278   if (lib_interface_ != nullptr) {
279     bt_vendor_lpm_mode_t mode = BT_VND_LPM_DISABLE;
280     lib_interface_->op(BT_VND_OP_LPM_SET_MODE, &mode);
281   }
283   fd_watcher_.StopWatchingFileDescriptors();
285   if (hci_ != nullptr) {
286     delete hci_;
287     hci_ = nullptr;
288   }
290   if (lib_interface_ != nullptr) {
291     lib_interface_->op(BT_VND_OP_USERIAL_CLOSE, nullptr);
293     int power_state = BT_VND_PWR_OFF;
294     lib_interface_->op(BT_VND_OP_POWER_CTRL, &power_state);
296     lib_interface_->cleanup();
297   }
299   if (lib_handle_ != nullptr) {
300     dlclose(lib_handle_);
301     lib_handle_ = nullptr;
302   }
304   if (firmware_startup_timer_ != nullptr) {
305     delete firmware_startup_timer_;
306     firmware_startup_timer_ = nullptr;
307   }
310 size_t VendorInterface::Send(uint8_t type, const uint8_t* data, size_t length) {
311   std::unique_lock<std::mutex> lock(wakeup_mutex_);
312   recent_activity_flag = true;
314   if (lpm_wake_deasserted == true) {
315     // Restart the timer.
316     fd_watcher_.ConfigureTimeout(std::chrono::milliseconds(lpm_timeout_ms),
317                                  [this]() { OnTimeout(); });
318     // Assert wake.
319     lpm_wake_deasserted = false;
320     bt_vendor_lpm_wake_state_t wakeState = BT_VND_LPM_WAKE_ASSERT;
321     lib_interface_->op(BT_VND_OP_LPM_WAKE_SET_STATE, &wakeState);
322     ALOGV("%s: Sent wake before (%02x)", __func__, data[0] | (data[1] << 8));
323   }
325   return hci_->Send(type, data, length);
328 void VendorInterface::OnFirmwareConfigured(uint8_t result) {
329   ALOGD("%s result: %d", __func__, result);
331   if (firmware_startup_timer_ != nullptr) {
332     delete firmware_startup_timer_;
333     firmware_startup_timer_ = nullptr;
334   }
336   if (initialize_complete_cb_ != nullptr) {
337     initialize_complete_cb_(result == 0);
338     initialize_complete_cb_ = nullptr;
339   }
341   lib_interface_->op(BT_VND_OP_GET_LPM_IDLE_TIMEOUT, &lpm_timeout_ms);
342   ALOGI("%s: lpm_timeout_ms %d", __func__, lpm_timeout_ms);
344   bt_vendor_lpm_mode_t mode = BT_VND_LPM_ENABLE;
345   lib_interface_->op(BT_VND_OP_LPM_SET_MODE, &mode);
347   ALOGD("%s Calling StartLowPowerWatchdog()", __func__);
348   fd_watcher_.ConfigureTimeout(std::chrono::milliseconds(lpm_timeout_ms),
349                                [this]() { OnTimeout(); });
352 void VendorInterface::OnTimeout() {
353   ALOGV("%s", __func__);
354   std::unique_lock<std::mutex> lock(wakeup_mutex_);
355   if (recent_activity_flag == false) {
356     lpm_wake_deasserted = true;
357     bt_vendor_lpm_wake_state_t wakeState = BT_VND_LPM_WAKE_DEASSERT;
358     lib_interface_->op(BT_VND_OP_LPM_WAKE_SET_STATE, &wakeState);
359     fd_watcher_.ConfigureTimeout(std::chrono::seconds(0), []() {
360       ALOGE("Zero timeout! Should never happen.");
361     });
362   }
363   recent_activity_flag = false;
366 void VendorInterface::HandleIncomingEvent(const hidl_vec<uint8_t>& hci_packet) {
367   if (internal_command.cb != nullptr &&
368       internal_command_event_match(hci_packet)) {
369     HC_BT_HDR* bt_hdr = WrapPacketAndCopy(HCI_PACKET_TYPE_EVENT, hci_packet);
371     // The callbacks can send new commands, so don't zero after calling.
372     tINT_CMD_CBACK saved_cb = internal_command.cb;
373     internal_command.cb = nullptr;
374     saved_cb(bt_hdr);
375   } else {
376     event_cb_(hci_packet);
377   }
380 }  // namespace implementation
381 }  // namespace V1_0
382 }  // namespace bluetooth
383 }  // namespace hardware
384 }  // namespace android