$(LOCAL_PATH)/sys \
$(LOCAL_PATH)/dm \
$(LOCAL_PATH)/hh \
+ $(LOCAL_PATH)/../btcore/include \
$(LOCAL_PATH)/../gki/common \
$(LOCAL_PATH)/../gki/ulinux \
+ $(LOCAL_PATH)/../hci/include \
$(LOCAL_PATH)/../include \
$(LOCAL_PATH)/../stack/include \
$(LOCAL_PATH)/../stack/btm \
- $(LOCAL_PATH)/../hcis \
- $(LOCAL_PATH)/../hcis/patchram \
$(LOCAL_PATH)/../osi/include \
$(LOCAL_PATH)/../udrv/include \
$(LOCAL_PATH)/../vnd/include \
--- /dev/null
+/******************************************************************************
+ *
+ * Copyright (C) 2014 Google, Inc.
+ *
+ * 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.
+ *
+ ******************************************************************************/
+
+#pragma once
+
+#include <stdint.h>
+
+typedef struct {
+ uint8_t as_array[8];
+} bt_device_features_t;
--- /dev/null
+/******************************************************************************
+ *
+ * Copyright (C) 2014 Google, Inc.
+ *
+ * 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.
+ *
+ ******************************************************************************/
+
+#pragma once
+
+#include <stdint.h>
+
+typedef struct {
+ uint8_t as_array[8];
+} bt_event_mask_t;
--- /dev/null
+/******************************************************************************
+ *
+ * Copyright (C) 2014 Google, Inc.
+ *
+ * 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.
+ *
+ ******************************************************************************/
+
+#pragma once
+
+#include <stdint.h>
+
+typedef struct {
+ uint8_t hci_version;
+ uint16_t hci_revision;
+ uint8_t lmp_version;
+ uint16_t manufacturer;
+ uint16_t lmp_subversion;
+} bt_version_t;
#include "btif_api.h"
#include "btif_common.h"
-#include "bt_utils.h"
+#include "controller.h"
#include "module.h"
#include "osi.h"
#include "semaphore.h"
module_shut_down(get_module(BTIF_CONFIG_MODULE));
future_await(hack_future);
+ module_shut_down(get_module(CONTROLLER_MODULE)); // Doesn't do any work, just puts it in a restartable state
ALOGD("%s finished.", __func__);
btif_thread_post(event_signal_stack_down, NULL);
}
#pragma once
+#include <stdbool.h>
#include <stdint.h>
-#include "allocator.h"
+#include "bdaddr.h"
+#include "device_features.h"
#include "hci_layer.h"
#include "hci_packet_factory.h"
#include "hci_packet_parser.h"
-typedef void (*fetch_finished_cb)(void);
-
typedef struct controller_t {
- // Initialize the controller module. Does no work; no clean up required.
- void (*init)(const hci_t *hci_interface);
+ bool (*get_is_ready)(void);
+
+ const bt_bdaddr_t *(*get_address)(void);
+ const bt_version_t *(*get_bt_version)(void);
+
+ const bt_device_features_t *(*get_features_classic)(int index);
+ uint8_t (*get_last_features_classic_index)(void);
+
+ const bt_device_features_t *(*get_features_ble)(void);
+
+ bool (*supports_simple_pairing)(void);
+ bool (*supports_simultaneous_le_bredr)(void);
+ bool (*supports_reading_remote_extended_features)(void);
+ bool (*supports_interlaced_inquiry_scan)(void);
+ bool (*supports_rssi_with_inquiry_results)(void);
+ bool (*supports_extended_inquiry_response)(void);
+ bool (*supports_master_slave_role_switch)(void);
+
+ bool (*supports_ble)(void);
+ bool (*supports_ble_connection_parameters_request)(void);
+
+ // Get the cached acl data sizes for the controller.
+ uint16_t (*get_acl_data_size_classic)(void);
+ uint16_t (*get_acl_data_size_ble)(void);
- // Starts the acl buffer size fetch sequence. |callback| is called when
- // the process is complete.
- void (*begin_acl_size_fetch)(fetch_finished_cb callback);
+ // Get the cached acl packet sizes for the controller.
+ // This is a convenience function for the respective
+ // acl data size + size of the acl header.
+ uint16_t (*get_acl_packet_size_classic)(void);
+ uint16_t (*get_acl_packet_size_ble)(void);
- // Get the cached classic acl size for the controller.
- uint16_t (*get_acl_size_classic)(void);
- // Get the cached ble acl size of the controller.
- uint16_t (*get_acl_size_ble)(void);
+ // Get the number of acl packets the controller can buffer.
+ uint16_t (*get_acl_buffer_count_classic)(void);
+ uint8_t (*get_acl_buffer_count_ble)(void);
} controller_t;
+#define CONTROLLER_MODULE "controller_module"
const controller_t *controller_get_interface();
const controller_t *controller_get_test_interface(
- const allocator_t *buffer_allocator_interface,
+ const hci_t *hci_interface,
const hci_packet_factory_t *packet_factory_interface,
const hci_packet_parser_t *packet_parser_interface);
const allocator_t *buffer_allocator_interface,
const hci_hal_t *hal_interface,
const btsnoop_t *btsnoop_interface,
- const controller_t *controller,
const hci_inject_t *hci_inject_interface,
const packet_fragmenter_t *packet_fragmenter_interface,
const vendor_t *vendor_interface,
#pragma once
#include "bt_types.h"
+#include "event_mask.h"
typedef struct {
- BT_HDR *(*make_read_buffer_size_command)(void);
- BT_HDR *(*make_ble_read_buffer_size_command)(void);
+ BT_HDR *(*make_reset)(void);
+ BT_HDR *(*make_read_buffer_size)(void);
+ BT_HDR *(*make_host_buffer_size)(uint16_t acl_size, uint8_t sco_size, uint16_t acl_count, uint16_t sco_count);
+ BT_HDR *(*make_read_local_version_info)(void);
+ BT_HDR *(*make_read_bd_addr)(void);
+ BT_HDR *(*make_read_local_supported_commands)(void);
+ BT_HDR *(*make_read_local_extended_features)(uint8_t page_number);
+ BT_HDR *(*make_write_simple_pairing_mode)(uint8_t mode);
+ BT_HDR *(*make_set_event_mask)(const bt_event_mask_t *event_mask);
+ BT_HDR *(*make_ble_write_host_support)(uint8_t supported_host, uint8_t simultaneous_host);
+ BT_HDR *(*make_ble_read_white_list_size)(void);
+ BT_HDR *(*make_ble_read_buffer_size)(void);
+ BT_HDR *(*make_ble_read_supported_states)(void);
+ BT_HDR *(*make_ble_read_local_supported_features)(void);
+ BT_HDR *(*make_ble_set_event_mask)(const bt_event_mask_t *event_mask);
} hci_packet_factory_t;
const hci_packet_factory_t *hci_packet_factory_get_interface();
#pragma once
+#include <stdint.h>
+
+#include "allocator.h"
+#include "bdaddr.h"
#include "bt_types.h"
+#include "device_features.h"
+#include "features.h"
+#include "version.h"
typedef struct {
- void (*parse_read_buffer_size_response)(BT_HDR *response, uint8_t *status_ptr, uint16_t *data_size_ptr);
- void (*parse_ble_read_buffer_size_response)(BT_HDR *response, uint8_t *status_ptr, uint16_t *data_size_ptr);
+ void (*parse_generic_command_complete)(BT_HDR *response);
+
+ void (*parse_read_buffer_size_response)(
+ BT_HDR *response,
+ uint16_t *data_size_ptr,
+ uint16_t *acl_buffer_count_ptr
+ );
+
+ void (*parse_read_local_version_info_response)(
+ BT_HDR *response,
+ bt_version_t *bt_version_ptr
+ );
+
+ void (*parse_read_bd_addr_response)(
+ BT_HDR *response,
+ bt_bdaddr_t *address_ptr
+ );
+
+ void (*parse_read_local_supported_commands_response)(
+ BT_HDR *response,
+ uint8_t *supported_commands_ptr,
+ size_t supported_commands_length
+ );
+
+ void (*parse_read_local_extended_features_response)(
+ BT_HDR *response,
+ uint8_t *page_number_ptr,
+ uint8_t *max_page_number_ptr,
+ bt_device_features_t *feature_pages,
+ size_t feature_pages_count
+ );
+
+ void (*parse_ble_read_white_list_size_response)(
+ BT_HDR *response,
+ uint8_t *white_list_size_ptr
+ );
+
+ void (*parse_ble_read_buffer_size_response)(
+ BT_HDR *response,
+ uint16_t *data_size_ptr,
+ uint8_t *acl_buffer_count_ptr
+ );
+
+ void (*parse_ble_read_supported_states_response)(
+ BT_HDR *response,
+ uint8_t *supported_states,
+ size_t supported_states_size
+ );
+
+ void (*parse_ble_read_local_supported_features_response)(
+ BT_HDR *response,
+ bt_device_features_t *supported_features
+ );
} hci_packet_parser_t;
const hci_packet_parser_t *hci_packet_parser_get_interface();
+
+const hci_packet_parser_t *hci_packet_parser_get_test_interface(
+ allocator_t *buffer_allocator_interface
+);
*
******************************************************************************/
+#define LOG_TAG "bt_controller"
+
#include <assert.h>
#include <stdbool.h>
#include <utils/Log.h>
+#include "bdaddr.h"
#include "bt_types.h"
-#include "buffer_allocator.h"
+#include "btm_ble_api.h"
#include "controller.h"
+#include "event_mask.h"
+#include "future.h"
#include "hcimsgs.h"
#include "hci_layer.h"
#include "hci_packet_factory.h"
#include "hci_packet_parser.h"
+#include "module.h"
+#include "version.h"
+
+const bt_event_mask_t BLE_EVENT_MASK = { "\x00\x00\x00\x00\x00\x00\x00\x3f" };
+#if (BLE_INCLUDED)
+const bt_event_mask_t CLASSIC_EVENT_MASK = { HCI_DUMO_EVENT_MASK_EXT };
+#else
+const bt_event_mask_t CLASSIC_EVENT_MASK = { HCI_LISBON_EVENT_MASK_EXT };
+#endif
+
+// TODO(zachoverflow): factor out into common module
+const uint8_t SCO_HOST_BUFFER_SIZE = 0xff;
+
+#define HCI_SUPPORTED_COMMANDS_ARRAY_SIZE 64
+#define MAX_FEATURES_CLASSIC_PAGE_COUNT 3
+#define BLE_SUPPORTED_STATES_SIZE 8
+#define BLE_SUPPORTED_FEATURES_SIZE 8
static const hci_t *hci;
static const hci_packet_factory_t *packet_factory;
static const hci_packet_parser_t *packet_parser;
-static const allocator_t *buffer_allocator;
-static fetch_finished_cb fetch_finished_callback;
+static bt_bdaddr_t address;
+static bt_version_t bt_version;
+
+static uint8_t supported_commands[HCI_SUPPORTED_COMMANDS_ARRAY_SIZE];
+static bt_device_features_t features_classic[MAX_FEATURES_CLASSIC_PAGE_COUNT];
+static uint8_t last_features_classic_page_index;
+
+static uint16_t acl_data_size_classic;
+static uint16_t acl_data_size_ble;
+static uint16_t acl_buffer_count_classic;
+static uint8_t acl_buffer_count_ble;
+
+static uint8_t ble_white_list_size;
+static uint8_t ble_supported_states[BLE_SUPPORTED_STATES_SIZE];
+static bt_device_features_t features_ble;
+
+static bool readable;
+static bool ble_supported;
+static bool simple_pairing_supported;
+
+#define AWAIT_COMMAND(command) future_await(hci->transmit_command_futured(command))
+
+// Module lifecycle functions
+
+static future_t *start_up(void) {
+ BT_HDR *response;
+
+ // Send the initial reset command
+ response = AWAIT_COMMAND(packet_factory->make_reset());
+ packet_parser->parse_generic_command_complete(response);
+
+ // Request the classic buffer size next
+ response = AWAIT_COMMAND(packet_factory->make_read_buffer_size());
+ packet_parser->parse_read_buffer_size_response(
+ response, &acl_data_size_classic, &acl_buffer_count_classic);
+
+ // Tell the controller about our buffer sizes and buffer counts next
+ // TODO(zachoverflow): factor this out. eww l2cap contamination. And why just a hardcoded 10?
+ response = AWAIT_COMMAND(
+ packet_factory->make_host_buffer_size(
+ L2CAP_MTU_SIZE,
+ SCO_HOST_BUFFER_SIZE,
+ L2CAP_HOST_FC_ACL_BUFS,
+ 10
+ )
+ );
+
+ packet_parser->parse_generic_command_complete(response);
+
+ // Read the local version info off the controller next, including
+ // information such as manufacturer and supported HCI version
+ response = AWAIT_COMMAND(packet_factory->make_read_local_version_info());
+ packet_parser->parse_read_local_version_info_response(response, &bt_version);
+
+ // Read the bluetooth address off the controller next
+ response = AWAIT_COMMAND(packet_factory->make_read_bd_addr());
+ packet_parser->parse_read_bd_addr_response(response, &address);
+
+ // Request the controller's supported commands next
+ response = AWAIT_COMMAND(packet_factory->make_read_local_supported_commands());
+ packet_parser->parse_read_local_supported_commands_response(
+ response,
+ supported_commands,
+ HCI_SUPPORTED_COMMANDS_ARRAY_SIZE
+ );
+
+ // Read page 0 of the controller features next
+ uint8_t page_number = 0;
+ response = AWAIT_COMMAND(packet_factory->make_read_local_extended_features(page_number));
+ packet_parser->parse_read_local_extended_features_response(
+ response,
+ &page_number,
+ &last_features_classic_page_index,
+ features_classic,
+ MAX_FEATURES_CLASSIC_PAGE_COUNT
+ );
+
+ assert(page_number == 0);
+ page_number++;
+
+ // Inform the controller what page 0 features we support, based on what
+ // it told us it supports. We need to do this first before we request the
+ // next page, because the controller's response for page 1 may be
+ // dependent on what we configure from page 0
+ simple_pairing_supported = HCI_SIMPLE_PAIRING_SUPPORTED(features_classic[0].as_array);
+ if (simple_pairing_supported) {
+ response = AWAIT_COMMAND(packet_factory->make_write_simple_pairing_mode(HCI_SP_MODE_ENABLED));
+ packet_parser->parse_generic_command_complete(response);
+ }
+
+#if (BLE_INCLUDED == TRUE)
+ if (HCI_LE_SPT_SUPPORTED(features_classic[0].as_array)) {
+ uint8_t simultaneous_le_host = HCI_SIMUL_LE_BREDR_SUPPORTED(features_classic[0].as_array) ? BTM_BLE_SIMULTANEOUS_HOST : 0;
+ response = AWAIT_COMMAND(
+ packet_factory->make_ble_write_host_support(BTM_BLE_HOST_SUPPORT, simultaneous_le_host)
+ );
+
+ packet_parser->parse_generic_command_complete(response);
+ }
+#endif
+
+ // Done telling the controller about what page 0 features we support
+ // Request the remaining feature pages
+ while (page_number <= last_features_classic_page_index &&
+ page_number < MAX_FEATURES_CLASSIC_PAGE_COUNT) {
+ response = AWAIT_COMMAND(packet_factory->make_read_local_extended_features(1));
+ packet_parser->parse_read_local_extended_features_response(
+ response,
+ &page_number,
+ &last_features_classic_page_index,
+ features_classic,
+ MAX_FEATURES_CLASSIC_PAGE_COUNT
+ );
+
+ page_number++;
+ }
+
+#if (BLE_INCLUDED == TRUE)
+ ble_supported = last_features_classic_page_index >= 1 && HCI_LE_HOST_SUPPORTED(features_classic[1].as_array);
+ if (ble_supported) {
+ // Request the ble white list size next
+ response = AWAIT_COMMAND(packet_factory->make_ble_read_white_list_size());
+ packet_parser->parse_ble_read_white_list_size_response(response, &ble_white_list_size);
-static void on_read_buffer_size_complete(BT_HDR *response, void *context);
-static void on_ble_read_buffer_size_complete(BT_HDR *response, void *context);
+ // Request the ble buffer size next
+ response = AWAIT_COMMAND(packet_factory->make_ble_read_buffer_size());
+ packet_parser->parse_ble_read_buffer_size_response(
+ response,
+ &acl_data_size_ble,
+ &acl_buffer_count_ble
+ );
+
+ // Response of 0 indicates ble has the same buffer size as classic
+ if (acl_data_size_ble == 0)
+ acl_data_size_ble = acl_data_size_classic;
+
+ // Request the ble supported states next
+ response = AWAIT_COMMAND(packet_factory->make_ble_read_supported_states());
+ packet_parser->parse_ble_read_supported_states_response(
+ response,
+ ble_supported_states,
+ sizeof(ble_supported_states)
+ );
+
+ // Request the ble supported features next
+ response = AWAIT_COMMAND(packet_factory->make_ble_read_local_supported_features());
+ packet_parser->parse_ble_read_local_supported_features_response(
+ response,
+ &features_ble
+ );
+
+ // Set the ble event mask next
+ response = AWAIT_COMMAND(packet_factory->make_ble_set_event_mask(&BLE_EVENT_MASK));
+ packet_parser->parse_generic_command_complete(response);
+ }
+#endif
+
+ if (simple_pairing_supported) {
+ response = AWAIT_COMMAND(packet_factory->make_set_event_mask(&CLASSIC_EVENT_MASK));
+ packet_parser->parse_generic_command_complete(response);
+ }
+
+ readable = true;
+ return future_new_immediate(FUTURE_SUCCESS);
+}
+
+static future_t *shut_down(void) {
+ readable = false;
+ return future_new_immediate(FUTURE_SUCCESS);
+}
-static bool acl_sizes_fetched;
-static uint16_t acl_size_classic;
-static uint16_t acl_size_ble;
+const module_t controller_module = {
+ .name = CONTROLLER_MODULE,
+ .init = NULL,
+ .start_up = start_up,
+ .shut_down = shut_down,
+ .clean_up = NULL,
+ .dependencies = {
+ HCI_MODULE,
+ NULL
+ }
+};
// Interface functions
-static void init(const hci_t *hci_interface) {
- hci = hci_interface;
+static bool get_is_ready(void) {
+ return readable;
}
-static void begin_acl_size_fetch(fetch_finished_cb callback) {
- assert(fetch_finished_callback == NULL); // Must not already be fetching
- assert(callback != NULL);
+static const bt_bdaddr_t *get_address(void) {
+ assert(readable);
+ return &address;
+}
- fetch_finished_callback = callback;
+static const bt_version_t *get_bt_version(void) {
+ assert(readable);
+ return &bt_version;
+}
- hci->transmit_command(
- packet_factory->make_read_buffer_size_command(),
- on_read_buffer_size_complete,
- NULL,
- NULL
- );
+// TODO(zachoverflow): hide inside, move decoder inside too
+static const bt_device_features_t *get_features_classic(int index) {
+ assert(readable);
+ assert(index < MAX_FEATURES_CLASSIC_PAGE_COUNT);
+ return &features_classic[index];
}
-static uint16_t get_acl_size_classic(void) {
- assert(acl_sizes_fetched);
- return acl_size_classic;
+static uint8_t get_last_features_classic_index(void) {
+ assert(readable);
+ return last_features_classic_page_index;
}
-static uint16_t get_acl_size_ble(void) {
- assert(acl_sizes_fetched);
- return acl_size_ble;
+static const bt_device_features_t *get_features_ble(void) {
+ assert(readable);
+ assert(ble_supported);
+ return &features_ble;
}
-// Internal functions
+static bool supports_simple_pairing(void) {
+ assert(readable);
+ return simple_pairing_supported;
+}
-static void on_read_buffer_size_complete(BT_HDR *response, UNUSED_ATTR void *context) {
- uint8_t status;
- packet_parser->parse_read_buffer_size_response(response, &status, &acl_size_classic);
- assert(status == HCI_SUCCESS);
+static bool supports_simultaneous_le_bredr(void) {
+ assert(readable);
+ return HCI_SIMUL_LE_BREDR_SUPPORTED(features_classic[0].as_array);
+}
- buffer_allocator->free(response);
+static bool supports_reading_remote_extended_features(void) {
+ assert(readable);
+ return HCI_READ_REMOTE_EXT_FEATURES_SUPPORTED(supported_commands);
+}
- hci->transmit_command(
- packet_factory->make_ble_read_buffer_size_command(),
- on_ble_read_buffer_size_complete,
- NULL,
- NULL
- );
+static bool supports_interlaced_inquiry_scan(void) {
+ assert(readable);
+ return HCI_LMP_INTERLACED_INQ_SCAN_SUPPORTED(features_classic[0].as_array);
+}
+
+static bool supports_rssi_with_inquiry_results(void) {
+ assert(readable);
+ return HCI_LMP_INQ_RSSI_SUPPORTED(features_classic[0].as_array);
+}
+
+static bool supports_extended_inquiry_response(void) {
+ assert(readable);
+ return HCI_EXT_INQ_RSP_SUPPORTED(features_classic[0].as_array);
+}
+
+static bool supports_master_slave_role_switch(void) {
+ assert(readable);
+ return HCI_SWITCH_SUPPORTED(features_classic[0].as_array);
+}
+
+static bool supports_ble(void) {
+ assert(readable);
+ return ble_supported;
+}
+
+static bool supports_ble_connection_parameters_request(void) {
+ assert(readable);
+ assert(ble_supported);
+ return HCI_LE_CONN_PARAM_REQ_SUPPORTED(features_ble.as_array);
+}
+
+static uint16_t get_acl_data_size_classic(void) {
+ assert(readable);
+ return acl_data_size_classic;
}
-static void on_ble_read_buffer_size_complete(BT_HDR *response, UNUSED_ATTR void *context) {
- uint8_t status;
- packet_parser->parse_ble_read_buffer_size_response(response, &status, &acl_size_ble);
- assert(status == HCI_SUCCESS);
+static uint16_t get_acl_data_size_ble(void) {
+ assert(readable);
+ assert(ble_supported);
+ return acl_data_size_ble;
+}
- // Response of 0 indicates ble has the same buffer size as classic
- if (acl_size_ble == 0)
- acl_size_ble = acl_size_classic;
+static uint16_t get_acl_packet_size_classic(void) {
+ assert(readable);
+ return acl_data_size_classic + HCI_DATA_PREAMBLE_SIZE;
+}
- buffer_allocator->free(response);
+static uint16_t get_acl_packet_size_ble(void) {
+ assert(readable);
+ return acl_data_size_ble + HCI_DATA_PREAMBLE_SIZE;
+}
- acl_sizes_fetched = true;
- fetch_finished_callback();
+static uint16_t get_acl_buffer_count_classic(void) {
+ assert(readable);
+ return acl_buffer_count_classic;
+}
- // Null out the callback to indicate we are done fetching
- fetch_finished_callback = NULL;
+static uint8_t get_acl_buffer_count_ble(void) {
+ assert(readable);
+ assert(ble_supported);
+ return acl_buffer_count_ble;
}
static const controller_t interface = {
- init,
- begin_acl_size_fetch,
+ get_is_ready,
+
+ get_address,
+ get_bt_version,
- get_acl_size_classic,
- get_acl_size_ble
+ get_features_classic,
+ get_last_features_classic_index,
+
+ get_features_ble,
+
+ supports_simple_pairing,
+ supports_simultaneous_le_bredr,
+ supports_reading_remote_extended_features,
+ supports_interlaced_inquiry_scan,
+ supports_rssi_with_inquiry_results,
+ supports_extended_inquiry_response,
+ supports_master_slave_role_switch,
+
+ supports_ble,
+ supports_ble_connection_parameters_request,
+
+ get_acl_data_size_classic,
+ get_acl_data_size_ble,
+
+ get_acl_packet_size_classic,
+ get_acl_packet_size_ble,
+
+ get_acl_buffer_count_classic,
+ get_acl_buffer_count_ble
};
const controller_t *controller_get_interface() {
- buffer_allocator = buffer_allocator_get_interface();
- packet_factory = hci_packet_factory_get_interface();
- packet_parser = hci_packet_parser_get_interface();
+ static bool loaded = false;
+ if (!loaded) {
+ loaded = true;
+
+ hci = hci_layer_get_interface();
+ packet_factory = hci_packet_factory_get_interface();
+ packet_parser = hci_packet_parser_get_interface();
+ }
+
return &interface;
}
const controller_t *controller_get_test_interface(
- const allocator_t *buffer_allocator_interface,
+ const hci_t *hci_interface,
const hci_packet_factory_t *packet_factory_interface,
const hci_packet_parser_t *packet_parser_interface) {
- buffer_allocator = buffer_allocator_interface;
+ hci = hci_interface;
packet_factory = packet_factory_interface;
packet_parser = packet_parser_interface;
return &interface;
#include "buffer_allocator.h"
#include "btsnoop.h"
-#include "controller.h"
#include "fixed_queue.h"
+#include "future.h"
+#include "hcidefs.h"
#include "hcimsgs.h"
#include "hci_hal.h"
#include "hci_internals.h"
#include <hardware/bluetooth.h>
bt_bdaddr_t btif_local_bd_addr;
-#define HCI_COMMAND_COMPLETE_EVT 0x0E
-#define HCI_COMMAND_STATUS_EVT 0x0F
-
#define INBOUND_PACKET_TYPE_COUNT 3
#define PACKET_TYPE_TO_INBOUND_INDEX(type) ((type) - 2)
#define PACKET_TYPE_TO_INDEX(type) ((type) - 1)
// Modules we import and callbacks we export
static const allocator_t *buffer_allocator;
static const btsnoop_t *btsnoop;
-static const controller_t *controller;
static const hci_hal_t *hal;
static const hci_hal_callbacks_t hal_callbacks;
static const hci_inject_t *hci_inject;
memset(incoming_packets, 0, sizeof(incoming_packets));
- controller->init(&interface);
packet_fragmenter->init(&packet_fragmenter_callbacks);
fixed_queue_register_dequeue(command_queue, thread_get_reactor(thread), event_command_ready, NULL);
// If couldn't configure sco, we won't get the sco configuration callback
// so go pretend to do it now
sco_config_callback(false);
- }
-}
-static void on_controller_acl_size_fetch_finished(void) {
- ALOGI("%s postload finished.", __func__);
+ }
}
static void sco_config_callback(UNUSED_ATTR bool success) {
- controller->begin_acl_size_fetch(on_controller_acl_size_fetch_finished);
+ ALOGI("%s postload finished.", __func__);
}
// Epilog functions
buffer_allocator = buffer_allocator_get_interface();
hal = hci_hal_get_interface();
btsnoop = btsnoop_get_interface();
- controller = controller_get_interface();
hci_inject = hci_inject_get_interface();
packet_fragmenter = packet_fragmenter_get_interface();
vendor = vendor_get_interface();
const allocator_t *buffer_allocator_interface,
const hci_hal_t *hal_interface,
const btsnoop_t *btsnoop_interface,
- const controller_t *controller_interface,
const hci_inject_t *hci_inject_interface,
const packet_fragmenter_t *packet_fragmenter_interface,
const vendor_t *vendor_interface,
buffer_allocator = buffer_allocator_interface;
hal = hal_interface;
btsnoop = btsnoop_interface;
- controller = controller_interface;
hci_inject = hci_inject_interface;
packet_fragmenter = packet_fragmenter_interface;
vendor = vendor_interface;
static const allocator_t *buffer_allocator;
static BT_HDR *make_packet(size_t data_size);
+static BT_HDR *make_command_no_params(uint16_t opcode);
+static BT_HDR *make_command(uint16_t opcode, size_t parameter_size, uint8_t **stream_out);
// Interface functions
-static BT_HDR *make_read_buffer_size_command(void) {
- BT_HDR *packet = make_packet(HCI_COMMAND_PREAMBLE_SIZE);
+static BT_HDR *make_reset(void) {
+ return make_command_no_params(HCI_RESET);
+}
- uint8_t *stream = packet->data;
- UINT16_TO_STREAM(stream, HCI_READ_BUFFER_SIZE);
- UINT8_TO_STREAM(stream, 0); // no parameters
+static BT_HDR *make_read_buffer_size(void) {
+ return make_command_no_params(HCI_READ_BUFFER_SIZE);
+}
+static BT_HDR *make_host_buffer_size(uint16_t acl_size, uint8_t sco_size, uint16_t acl_count, uint16_t sco_count) {
+ uint8_t *stream;
+ const uint8_t parameter_size = 2 + 1 + 2 + 2; // from each of the parameters
+ BT_HDR *packet = make_command(HCI_HOST_BUFFER_SIZE, parameter_size, &stream);
+
+ UINT16_TO_STREAM(stream, acl_size);
+ UINT8_TO_STREAM(stream, sco_size);
+ UINT16_TO_STREAM(stream, acl_count);
+ UINT16_TO_STREAM(stream, sco_count);
return packet;
}
-static BT_HDR *make_ble_read_buffer_size_command(void) {
- BT_HDR *packet = make_packet(HCI_COMMAND_PREAMBLE_SIZE);
+static BT_HDR *make_read_local_version_info(void) {
+ return make_command_no_params(HCI_READ_LOCAL_VERSION_INFO);
+}
- uint8_t *stream = packet->data;
- UINT16_TO_STREAM(stream, HCI_BLE_READ_BUFFER_SIZE);
- UINT8_TO_STREAM(stream, 0); // no parameters
+static BT_HDR *make_read_bd_addr(void) {
+ return make_command_no_params(HCI_READ_BD_ADDR);
+}
+
+static BT_HDR *make_read_local_supported_commands(void) {
+ return make_command_no_params(HCI_READ_LOCAL_SUPPORTED_CMDS);
+}
+
+static BT_HDR *make_read_local_extended_features(uint8_t page_number) {
+ uint8_t *stream;
+ const uint8_t parameter_size = 1;
+ BT_HDR *packet = make_command(HCI_READ_LOCAL_EXT_FEATURES, parameter_size, &stream);
+
+ UINT8_TO_STREAM(stream, page_number);
+ return packet;
+}
+
+static BT_HDR *make_write_simple_pairing_mode(uint8_t mode) {
+ uint8_t *stream;
+ const uint8_t parameter_size = 1;
+ BT_HDR *packet = make_command(HCI_WRITE_SIMPLE_PAIRING_MODE, parameter_size, &stream);
+
+ UINT8_TO_STREAM(stream, mode);
+ return packet;
+}
+
+static BT_HDR *make_set_event_mask(const bt_event_mask_t *event_mask) {
+ uint8_t *stream;
+ uint8_t parameter_size = sizeof(bt_event_mask_t);
+ BT_HDR *packet = make_command(HCI_SET_EVENT_MASK, parameter_size, &stream);
+
+ ARRAY8_TO_STREAM(stream, event_mask->as_array);
+ return packet;
+}
+
+static BT_HDR *make_ble_write_host_support(uint8_t supported_host, uint8_t simultaneous_host) {
+ uint8_t *stream;
+ const uint8_t parameter_size = 1 + 1;
+ BT_HDR *packet = make_command(HCI_WRITE_LE_HOST_SUPPORT, parameter_size, &stream);
+ UINT8_TO_STREAM(stream, supported_host);
+ UINT8_TO_STREAM(stream, simultaneous_host);
+ return packet;
+}
+
+static BT_HDR *make_ble_read_white_list_size(void) {
+ return make_command_no_params(HCI_BLE_READ_WHITE_LIST_SIZE);
+}
+
+static BT_HDR *make_ble_read_buffer_size(void) {
+ return make_command_no_params(HCI_BLE_READ_BUFFER_SIZE);
+}
+
+static BT_HDR *make_ble_read_supported_states(void) {
+ return make_command_no_params(HCI_BLE_READ_SUPPORTED_STATES);
+}
+
+static BT_HDR *make_ble_read_local_supported_features(void) {
+ return make_command_no_params(HCI_BLE_READ_LOCAL_SPT_FEAT);
+}
+
+static BT_HDR *make_ble_set_event_mask(const bt_event_mask_t *event_mask) {
+ uint8_t *stream;
+ uint8_t parameter_size = sizeof(bt_event_mask_t);
+ BT_HDR *packet = make_command(HCI_BLE_SET_EVENT_MASK, parameter_size, &stream);
+
+ ARRAY8_TO_STREAM(stream, event_mask->as_array);
return packet;
}
// Internal functions
+static BT_HDR *make_command_no_params(uint16_t opcode) {
+ return make_command(opcode, 0, NULL);
+}
+
+static BT_HDR *make_command(uint16_t opcode, size_t parameter_size, uint8_t **stream_out) {
+ BT_HDR *packet = make_packet(HCI_COMMAND_PREAMBLE_SIZE + parameter_size);
+
+ uint8_t *stream = packet->data;
+ UINT16_TO_STREAM(stream, opcode);
+ UINT8_TO_STREAM(stream, parameter_size);
+
+ if (stream_out != NULL)
+ *stream_out = stream;
+
+ return packet;
+}
+
static BT_HDR *make_packet(size_t data_size) {
BT_HDR *ret = (BT_HDR *)buffer_allocator->alloc(sizeof(BT_HDR) + data_size);
assert(ret);
}
static const hci_packet_factory_t interface = {
- make_read_buffer_size_command,
- make_ble_read_buffer_size_command
+ make_reset,
+ make_read_buffer_size,
+ make_host_buffer_size,
+ make_read_local_version_info,
+ make_read_bd_addr,
+ make_read_local_supported_commands,
+ make_read_local_extended_features,
+ make_write_simple_pairing_mode,
+ make_set_event_mask,
+ make_ble_write_host_support,
+ make_ble_read_white_list_size,
+ make_ble_read_buffer_size,
+ make_ble_read_supported_states,
+ make_ble_read_local_supported_features,
+ make_ble_set_event_mask
};
const hci_packet_factory_t *hci_packet_factory_get_interface() {
#include <assert.h>
+#include "buffer_allocator.h"
#include "bt_types.h"
#include "hcimsgs.h"
#include "hci_layer.h"
#include "hci_packet_parser.h"
+static const command_opcode_t NO_OPCODE_CHECKING = 0;
+
+static const allocator_t *buffer_allocator;
+
+static uint8_t *read_command_complete_header(
+ BT_HDR *response,
+ command_opcode_t expected_opcode,
+ size_t minimum_bytes_after);
+
+static void parse_generic_command_complete(BT_HDR *response) {
+ read_command_complete_header(response, NO_OPCODE_CHECKING, 0 /* bytes after */);
+
+ buffer_allocator->free(response);
+}
+
static void parse_read_buffer_size_response(
BT_HDR *response,
- uint8_t *status_ptr,
- uint16_t *data_size_ptr) {
- uint8_t *stream = response->data + response->offset;
- command_opcode_t opcode;
+ uint16_t *data_size_ptr,
+ uint16_t *acl_buffer_count_ptr) {
- stream += 3; // skip the event header fields, and the number of hci command packets field
- STREAM_TO_UINT16(opcode, stream);
- STREAM_TO_UINT8(*status_ptr, stream);
+ uint8_t *stream = read_command_complete_header(response, HCI_READ_BUFFER_SIZE, 5 /* bytes after */);
STREAM_TO_UINT16(*data_size_ptr, stream);
+ STREAM_SKIP_UINT8(stream); // skip the sco packet length
+ STREAM_TO_UINT16(*acl_buffer_count_ptr, stream);
+
+ buffer_allocator->free(response);
+}
+
+static void parse_read_local_version_info_response(
+ BT_HDR *response,
+ bt_version_t *bt_version) {
+
+ uint8_t *stream = read_command_complete_header(response, HCI_READ_LOCAL_VERSION_INFO, 8 /* bytes after */);
+ STREAM_TO_UINT8(bt_version->hci_version, stream);
+ STREAM_TO_UINT16(bt_version->hci_revision, stream);
+ STREAM_TO_UINT8(bt_version->lmp_version, stream);
+ STREAM_TO_UINT16(bt_version->manufacturer, stream);
+ STREAM_TO_UINT16(bt_version->lmp_subversion, stream);
+
+ buffer_allocator->free(response);
+}
+
+static void parse_read_bd_addr_response(
+ BT_HDR *response,
+ bt_bdaddr_t *address_ptr) {
+
+ uint8_t *stream = read_command_complete_header(response, HCI_READ_BD_ADDR, sizeof(bt_bdaddr_t) /* bytes after */);
+ STREAM_TO_BDADDR(address_ptr->address, stream);
+
+ buffer_allocator->free(response);
+}
+
+static void parse_read_local_supported_commands_response(
+ BT_HDR *response,
+ uint8_t *supported_commands_ptr,
+ size_t supported_commands_length) {
+
+ uint8_t *stream = read_command_complete_header(response, HCI_READ_LOCAL_SUPPORTED_CMDS, supported_commands_length /* bytes after */);
+ STREAM_TO_ARRAY(supported_commands_ptr, stream, (int)supported_commands_length);
+
+ buffer_allocator->free(response);
+}
+
+static void parse_read_local_extended_features_response(
+ BT_HDR *response,
+ uint8_t *page_number_ptr,
+ uint8_t *max_page_number_ptr,
+ bt_device_features_t *feature_pages,
+ size_t feature_pages_count) {
+
+ uint8_t *stream = read_command_complete_header(response, HCI_READ_LOCAL_EXT_FEATURES, 2 + sizeof(bt_device_features_t) /* bytes after */);
+ STREAM_TO_UINT8(*page_number_ptr, stream);
+ STREAM_TO_UINT8(*max_page_number_ptr, stream);
+
+ assert(*page_number_ptr < feature_pages_count);
+ STREAM_TO_ARRAY(feature_pages[*page_number_ptr].as_array, stream, (int)sizeof(bt_device_features_t));
+
+ buffer_allocator->free(response);
+}
- assert(opcode == HCI_READ_BUFFER_SIZE);
+static void parse_ble_read_white_list_size_response(
+ BT_HDR *response,
+ uint8_t *white_list_size_ptr) {
+
+ uint8_t *stream = read_command_complete_header(response, HCI_BLE_READ_WHITE_LIST_SIZE, 1 /* byte after */);
+ STREAM_TO_UINT8(*white_list_size_ptr, stream);
+
+ buffer_allocator->free(response);
}
static void parse_ble_read_buffer_size_response(
BT_HDR *response,
- uint8_t *status_ptr,
- uint16_t *data_size_ptr) {
+ uint16_t *data_size_ptr,
+ uint8_t *acl_buffer_count_ptr) {
+
+ uint8_t *stream = read_command_complete_header(response, HCI_BLE_READ_BUFFER_SIZE, 3 /* bytes after */);
+ STREAM_TO_UINT16(*data_size_ptr, stream);
+ STREAM_TO_UINT8(*acl_buffer_count_ptr, stream);
+
+ buffer_allocator->free(response);
+}
+
+static void parse_ble_read_supported_states_response(
+ BT_HDR *response,
+ uint8_t *supported_states,
+ size_t supported_states_size) {
+
+ uint8_t *stream = read_command_complete_header(response, HCI_BLE_READ_SUPPORTED_STATES, supported_states_size /* bytes after */);
+ STREAM_TO_ARRAY(supported_states, stream, (int)supported_states_size);
+
+ buffer_allocator->free(response);
+}
+
+static void parse_ble_read_local_supported_features_response(
+ BT_HDR *response,
+ bt_device_features_t *supported_features) {
+
+ uint8_t *stream = read_command_complete_header(response, HCI_BLE_READ_LOCAL_SPT_FEAT, sizeof(bt_device_features_t) /* bytes after */);
+ STREAM_TO_ARRAY(supported_features->as_array, stream, (int)sizeof(bt_device_features_t));
+
+ buffer_allocator->free(response);
+}
+
+// Internal functions
+
+static uint8_t *read_command_complete_header(
+ BT_HDR *response,
+ command_opcode_t expected_opcode,
+ size_t minimum_bytes_after) {
+
uint8_t *stream = response->data + response->offset;
- command_opcode_t opcode;
- stream += 3; // skip the event header fields, and the number of hci command packets field
+ // Read the event header
+ uint8_t event_code;
+ uint8_t parameter_length;
+ STREAM_TO_UINT8(event_code, stream);
+ STREAM_TO_UINT8(parameter_length, stream);
+
+ const size_t parameter_bytes_we_read_here = 4;
+
+ // Check the event header values against what we expect
+ assert(event_code == HCI_COMMAND_COMPLETE_EVT);
+ assert(parameter_length >= (parameter_bytes_we_read_here + minimum_bytes_after));
+
+ // Read the command complete header
+ command_opcode_t opcode;
+ uint8_t status;
+ STREAM_SKIP_UINT8(stream); // skip the number of hci command packets field
STREAM_TO_UINT16(opcode, stream);
- STREAM_TO_UINT8(*status_ptr, stream);
- STREAM_TO_UINT16(*data_size_ptr, stream);
- assert(opcode == HCI_BLE_READ_BUFFER_SIZE);
+ // Check the command complete header values against what we expect
+ if (expected_opcode != NO_OPCODE_CHECKING) {
+ assert(opcode == expected_opcode);
+ }
+
+ // Assume the next field is the status field
+ STREAM_TO_UINT8(status, stream);
+ // Make sure it was successful
+ assert(status == HCI_SUCCESS);
+
+ return stream;
}
static const hci_packet_parser_t interface = {
+ parse_generic_command_complete,
parse_read_buffer_size_response,
- parse_ble_read_buffer_size_response
+ parse_read_local_version_info_response,
+ parse_read_bd_addr_response,
+ parse_read_local_supported_commands_response,
+ parse_read_local_extended_features_response,
+ parse_ble_read_white_list_size_response,
+ parse_ble_read_buffer_size_response,
+ parse_ble_read_supported_states_response,
+ parse_ble_read_local_supported_features_response
};
const hci_packet_parser_t *hci_packet_parser_get_interface() {
+ buffer_allocator = buffer_allocator_get_interface();
+ return &interface;
+}
+
+const hci_packet_parser_t *hci_packet_parser_get_test_interface(
+ allocator_t *buffer_allocator_interface) {
+ buffer_allocator = buffer_allocator_interface;
return &interface;
}
uint16_t max_data_size =
SUB_EVENT(packet->event) == LOCAL_BR_EDR_CONTROLLER_ID ?
- controller->get_acl_size_classic() :
- controller->get_acl_size_ble();
+ controller->get_acl_data_size_classic() :
+ controller->get_acl_data_size_ble();
uint16_t max_packet_size = max_data_size + HCI_ACL_PREAMBLE_SIZE;
uint16_t remaining_length = packet->len;
UNEXPECTED_CALL;
}
-STUB_FUNCTION(void, controller_init, (const hci_t *hci_interface))
- DURING(start_up_async) AT_CALL(0) {
- EXPECT_EQ(hci, hci_interface);
- return;
- }
-
- UNEXPECTED_CALL;
-}
-
-STUB_FUNCTION(void, controller_begin_acl_size_fetch, (fetch_finished_cb callback))
- DURING(postload) AT_CALL(0) {
- callback();
- return;
- }
-
- UNEXPECTED_CALL;
-}
-
-STUB_FUNCTION(uint16_t, controller_get_acl_size_classic, (void))
+STUB_FUNCTION(uint16_t, controller_get_acl_data_size_classic, (void))
return 2048;
}
-STUB_FUNCTION(uint16_t, controller_get_acl_size_ble, (void))
+STUB_FUNCTION(uint16_t, controller_get_acl_data_size_ble, (void))
return 2048;
}
RESET_CALL_COUNT(low_power_transmit_done);
RESET_CALL_COUNT(command_complete_callback);
RESET_CALL_COUNT(command_status_callback);
- RESET_CALL_COUNT(controller_init);
- RESET_CALL_COUNT(controller_begin_acl_size_fetch);
- RESET_CALL_COUNT(controller_get_acl_size_classic);
- RESET_CALL_COUNT(controller_get_acl_size_ble);
+ RESET_CALL_COUNT(controller_get_acl_data_size_classic);
+ RESET_CALL_COUNT(controller_get_acl_data_size_ble);
CURRENT_TEST_MODE = next;
}
&allocator_malloc,
&hal,
&btsnoop,
- &controller,
&hci_inject,
packet_fragmenter_get_test_interface(&controller, &allocator_malloc),
&vendor,
low_power_manager.cleanup = low_power_cleanup;
low_power_manager.wake_assert = low_power_wake_assert;
low_power_manager.transmit_done = low_power_transmit_done;
- controller.init = controller_init;
- controller.begin_acl_size_fetch = controller_begin_acl_size_fetch;
- controller.get_acl_size_classic = controller_get_acl_size_classic;
- controller.get_acl_size_ble = controller_get_acl_size_ble;
+ controller.get_acl_data_size_classic = controller_get_acl_data_size_classic;
+ controller.get_acl_data_size_ble = controller_get_acl_data_size_ble;
done = semaphore_new(0);
EXPECT_CALL_COUNT(hal_init, 1);
EXPECT_CALL_COUNT(low_power_init, 1);
EXPECT_CALL_COUNT(vendor_set_callback, 3);
- EXPECT_CALL_COUNT(controller_init, 1);
EXPECT_CALL_COUNT(hal_open, 1);
EXPECT_CALL_COUNT(vendor_send_async_command, 1);
}
flush_thread(internal_thread);
EXPECT_CALL_COUNT(vendor_send_async_command, 1);
- EXPECT_CALL_COUNT(controller_begin_acl_size_fetch, 1);
}
TEST_F(HciLayerTest, test_transmit_simple) {
UNEXPECTED_CALL;
}
-STUB_FUNCTION(uint16_t, get_acl_size_classic, (void))
+STUB_FUNCTION(uint16_t, get_acl_data_size_classic, (void))
DURING(no_fragmentation,
non_acl_passthrough_fragmentation,
no_reassembly) return 42;
return 0;
}
-STUB_FUNCTION(uint16_t, get_acl_size_ble, (void))
+STUB_FUNCTION(uint16_t, get_acl_data_size_ble, (void))
DURING(ble_no_fragmentation) return 42;
DURING(ble_fragmentation) return 10;
RESET_CALL_COUNT(fragmented_callback);
RESET_CALL_COUNT(reassembled_callback);
RESET_CALL_COUNT(transmit_finished_callback);
- RESET_CALL_COUNT(get_acl_size_classic);
- RESET_CALL_COUNT(get_acl_size_ble);
+ RESET_CALL_COUNT(get_acl_data_size_classic);
+ RESET_CALL_COUNT(get_acl_data_size_ble);
CURRENT_TEST_MODE = next;
}
callbacks.fragmented = fragmented_callback;
callbacks.reassembled = reassembled_callback;
callbacks.transmit_finished = transmit_finished_callback;
- controller.get_acl_size_classic = get_acl_size_classic;
- controller.get_acl_size_ble = get_acl_size_ble;
+ controller.get_acl_data_size_classic = get_acl_data_size_classic;
+ controller.get_acl_data_size_ble = get_acl_data_size_ble;
reset_for(init);
fragmenter->init(&callbacks);
LOCAL_MODULE := libbt-brcm_stack
LOCAL_MODULE_TAGS := optional
LOCAL_MODULE_CLASS := STATIC_LIBRARIES
+LOCAL_STATIC_LIBRARIES := libbt-hci
LOCAL_SHARED_LIBRARIES := libcutils libc
LOCAL_MULTILIB := 32
#include "bt_types.h"
#include "bt_target.h"
+#include "controller.h"
#include "gki.h"
#include "hcimsgs.h"
#include "btu.h"
&p->active_remote_addr_type);
#endif
- if (HCI_LE_SLAVE_INIT_FEAT_EXC_SUPPORTED(btm_cb.devcb.local_le_features)
+ if (HCI_LE_SLAVE_INIT_FEAT_EXC_SUPPORTED(controller_get_interface()->get_features_ble()->as_array)
|| link_role == HCI_ROLE_MASTER)
{
btsnd_hcic_ble_read_remote_feat(p->hci_handle);
remote_bd_addr[3], remote_bd_addr[4], remote_bd_addr[5]);
/* Make sure the local device supports switching */
- if (!(HCI_SWITCH_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_0])))
+ if (!controller_get_interface()->supports_master_slave_role_switch())
return(BTM_MODE_UNSUPPORTED);
if (btm_cb.devcb.p_switch_role_cb && p_cb)
HCI_FEATURE_BYTES_PER_PAGE);
if ((HCI_LMP_EXTENDED_SUPPORTED(p_acl_cb->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0])) &&
- (HCI_READ_REMOTE_EXT_FEATURES_SUPPORTED(btm_cb.devcb.supported_cmds)))
+ (controller_get_interface()->supports_reading_remote_extended_features()))
{
/* if the remote controller has extended features and local controller supports
** HCI_Read_Remote_Extended_Features command then start reading these feature starting
else
{
/* Special case for when info for the local device is requested */
- if (memcmp (btm_cb.devcb.local_addr, addr, BD_ADDR_LEN) == 0)
+ if (memcmp (controller_get_interface()->get_address(), addr, BD_ADDR_LEN) == 0)
{
pkt_types = btm_cb.btm_acl_pkt_types_supported;
}
#include "hcidefs.h"
#include "btm_ble_api.h"
#include "vendor_ble.h"
+#include "controller.h"
#define BTM_BLE_ADV_FILT_META_HDR_LENGTH 3
#define BTM_BLE_ADV_FILT_FEAT_SELN_LEN 13
(tBTM_BLE_PF_COUNT*) GKI_getbuf( sizeof(tBTM_BLE_PF_COUNT) * cmn_ble_vsc_cb.max_filter);
}
- if (!HCI_LE_HOST_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_1]))
+ if (!controller_get_interface()->supports_ble())
return;
}
#include "bt_utils.h"
#include "btu.h"
#include "btm_int.h"
+#include "controller.h"
#include "hcimsgs.h"
#if (BLE_INCLUDED == TRUE)
ble_batchscan_cb.cur_state, ref_value, batch_scan_full_max, batch_scan_trunc_max,
batch_scan_notify_threshold);
- if (!HCI_LE_HOST_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_1]))
+ if (!controller_get_interface()->supports_ble())
return BTM_ILLEGAL_VALUE;
BTM_BleGetVendorCapabilities(&cmn_ble_vsc_cb);
BTM_TRACE_EVENT (" BTM_BleEnableBatchScan: %d, %d, %d, %d, %d, %d",
scan_mode, scan_interval, scan_window, addr_type, discard_rule, ref_value);
- if (!HCI_LE_HOST_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_1]))
+ if (!controller_get_interface()->supports_ble())
return BTM_ILLEGAL_VALUE;
BTM_BleGetVendorCapabilities(&cmn_ble_vsc_cb);
tBTM_BLE_VSC_CB cmn_ble_vsc_cb;
BTM_TRACE_EVENT (" BTM_BleDisableBatchScan");
- if (!HCI_LE_HOST_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_1]))
+ if (!controller_get_interface()->supports_ble())
return BTM_ILLEGAL_VALUE;
BTM_BleGetVendorCapabilities(&cmn_ble_vsc_cb);
BTM_TRACE_EVENT (" BTM_BleReadScanReports; %d, %d", scan_mode, ref_value);
- if (!HCI_LE_HOST_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_1]))
+ if (!controller_get_interface()->supports_ble())
return BTM_ILLEGAL_VALUE;
BTM_BleGetVendorCapabilities(&cmn_ble_vsc_cb);
{
tBTM_BLE_VSC_CB cmn_ble_vsc_cb;
BTM_TRACE_EVENT (" BTM_BleTrackAdvertiser");
- if (!HCI_LE_HOST_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_1]))
+ if (!controller_get_interface()->supports_ble())
return BTM_ILLEGAL_VALUE;
BTM_BleGetVendorCapabilities(&cmn_ble_vsc_cb);
#include "btm_int.h"
#include "btm_ble_api.h"
#include "btu.h"
+#include "controller.h"
#include "hcimsgs.h"
#if (GAP_INCLUDED == TRUE)
#include "gap_api.h"
BTM_TRACE_EVENT ("BTM_BleUpdateAdvFilterPolicy");
- if (!HCI_LE_HOST_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_1]))
+ if (!controller_get_interface()->supports_ble())
return;
if (p_cb->afp != adv_policy)
BTM_TRACE_EVENT ("BTM_BleObserve : scan_type:%d",btm_cb.btm_inq_vars.scan_type);
- if (!HCI_LE_HOST_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_1]))
+ if (!controller_get_interface()->supports_ble())
return BTM_ILLEGAL_VALUE;
if (start)
tBTM_BLE_INQ_CB *p_cb = &btm_cb.ble_ctr_cb.inq_var;
UINT8 evt_type = p_cb->scan_rsp ? BTM_BLE_DISCOVER_EVT: BTM_BLE_NON_CONNECT_EVT;
- if (!HCI_LE_HOST_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_1]))
+ if (!controller_get_interface()->supports_ble())
return BTM_ILLEGAL_VALUE;
#ifdef BTM_BLE_PC_ADV_TEST_MODE
BOOLEAN started = TRUE;
BTM_TRACE_EVENT ("BTM_BleSetBgConnType ");
- if (!HCI_LE_HOST_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_1]))
+ if (!controller_get_interface()->supports_ble())
return FALSE;
if (btm_cb.ble_ctr_cb.bg_conn_type != bg_conn_type)
tBTM_BLE_INQ_CB *p_cb = &btm_cb.ble_ctr_cb.inq_var;
BTM_TRACE_EVENT ("BTM_BleSetConnMode is_directed = %d ", is_directed);
- if (!HCI_LE_HOST_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_1]))
+ if (!controller_get_interface()->supports_ble())
return BTM_ILLEGAL_VALUE;
p_cb->directed_conn = is_directed;
BTM_TRACE_EVENT ("BTM_BleSetAdvParams");
- if (!HCI_LE_HOST_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_1]))
+ if (!controller_get_interface()->supports_ble())
return BTM_ILLEGAL_VALUE;
if (!BTM_BLE_VALID_PRAM(adv_int_min, BTM_BLE_ADV_INT_MIN, BTM_BLE_ADV_INT_MAX) ||
tBTM_BLE_INQ_CB *p_cb = &btm_cb.ble_ctr_cb.inq_var;
BTM_TRACE_EVENT ("BTM_BleReadAdvParams ");
- if (!HCI_LE_HOST_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_1]))
+ if (!controller_get_interface()->supports_ble())
return ;
*adv_int_min = p_cb->adv_interval_min;
tBTM_BLE_INQ_CB *p_cb = &btm_cb.ble_ctr_cb.inq_var;
BTM_TRACE_EVENT (" BTM_BleSetScanParams");
- if (!HCI_LE_HOST_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_1]))
+ if (!controller_get_interface()->supports_ble())
return ;
if (BTM_BLE_VALID_PRAM(scan_interval, BTM_BLE_SCAN_INT_MIN, BTM_BLE_SCAN_INT_MAX) &&
BTM_TRACE_EVENT (" BTM_BleWriteScanRsp");
- if (!HCI_LE_HOST_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_1]))
+ if (!controller_get_interface()->supports_ble())
return BTM_ILLEGAL_VALUE;
memset(rsp_data, 0, BTM_BLE_AD_DATA_LEN);
BTM_TRACE_EVENT ("BTM_BleWriteAdvData ");
- if (!HCI_LE_HOST_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_1]))
+ if (!controller_get_interface()->supports_ble())
return BTM_ILLEGAL_VALUE;
memset(p_cb_data, 0, sizeof(tBTM_BLE_LOCAL_ADV_DATA));
flag &= ~BTM_BLE_BREDR_NOT_SPT;
/* if local controller support, mark both controller and host support in flag */
- if (HCI_SIMUL_LE_BREDR_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_0]))
+ if (controller_get_interface()->supports_simultaneous_le_bredr())
flag |= (BTM_BLE_DMT_CONTROLLER_SPT|BTM_BLE_DMT_HOST_SPT);
else
flag &= ~(BTM_BLE_DMT_CONTROLLER_SPT|BTM_BLE_DMT_HOST_SPT);
{
tBTM_INQUIRY_VAR_ST *p_inq = &btm_cb.btm_inq_vars;
- if (!HCI_LE_HOST_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_1]))
+ if (!controller_get_interface()->supports_ble())
return BTM_ERR_PROCESSING;
if (p_cur &&
******************************************************************************/
#include <string.h>
+
#include "bt_target.h"
+#include "controller.h"
#if (BLE_INCLUDED == TRUE)
#include "bt_types.h"
#endif
{
UINT8_TO_STREAM (pp, BLE_ADDR_PUBLIC);
- BDADDR_TO_STREAM (pp, btm_cb.devcb.local_addr);
+ BDADDR_TO_STREAM (pp, controller_get_interface()->get_address()->address);
}
BTM_TRACE_EVENT (" btm_ble_multi_adv_set_params,Min %d, Max %d,adv_type %d",
#include <stddef.h>
#include "bt_types.h"
+#include "controller.h"
#include "gki.h"
#include "hcimsgs.h"
#include "btu.h"
return(FALSE);
#endif
p_dev_rec = btm_find_dev (bd_addr);
- if (p_dev_rec && HCI_SWITCH_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_0]))
+ if (p_dev_rec && controller_get_interface()->supports_master_slave_role_switch())
{
if (HCI_SWITCH_SUPPORTED(p_dev_rec->features[HCI_EXT_FEATURES_PAGE_0]))
{
*
******************************************************************************/
+#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <stddef.h>
+#include <utils/Log.h>
#include "bt_types.h"
#include "bt_utils.h"
-#include "hcimsgs.h"
-#include "btu.h"
#include "btm_int.h"
+#include "btu.h"
+#include "controller.h"
+#include "hci_layer.h"
+#include "hcimsgs.h"
#include "l2c_int.h"
+#include "module.h"
+#include "thread.h"
#if BLE_INCLUDED == TRUE
#include "gatt_int.h"
-
#endif /* BLE_INCLUDED */
-#ifdef BTA_PRM_CHECK_FW_VER
-extern BOOLEAN BTA_PRM_CHECK_FW_VER(UINT8 *p);
-#endif
-
-#ifndef TT_DEV_RESET_MASK
-#define TT_DEV_RESET_MASK 0xff
-#endif
+extern thread_t *bt_workqueue_thread;
/********************************************************************************/
/* L O C A L D A T A D E F I N I T I O N S */
#define BTM_INFO_TIMEOUT 5 /* 5 seconds for info response */
-#ifndef BTM_SET_DEV_NAME_UPON_RESET
-#define BTM_SET_DEV_NAME_UPON_RESET TRUE
-#endif
-
-/* host SCO buffer size */
-#ifndef BTM_SCO_HOST_BUF_SIZE
-#define BTM_SCO_HOST_BUF_SIZE 0xff
-#endif
-
/********************************************************************************/
/* L O C A L F U N C T I O N P R O T O T Y P E S */
/********************************************************************************/
-static void btm_dev_reset (void);
-static void btm_continue_reset (void);
-static void btm_get_local_ext_features (UINT8 page_number);
static void btm_decode_ext_features_page (UINT8 page_number, const BD_FEATURES p_features);
-static void btm_read_all_lmp_features_complete (UINT8 max_page_number);
-static void btm_set_lmp_features_host_may_support (UINT8 max_page_number);
-static void btm_get_local_features (void);
-static void btm_issue_host_support_for_lmp_features (void);
-static void btm_read_local_supported_cmds (UINT8 local_controller_id);
-
-#if BLE_INCLUDED == TRUE
-static void btm_read_ble_local_supported_features (void);
-#endif
/*******************************************************************************
**
}
}
-/*******************************************************************************
-**
-** Function btm_dev_absent
-**
-** Description This function is called by when it is detected that the
-** device is not connected any more.
-**
-** Returns void
-**
-*******************************************************************************/
-void btm_dev_absent (void)
-{
- btm_cb.devcb.state = BTM_DEV_STATE_WAIT_RESET_CMPLT;
+static void reset_complete(void *result) {
+ assert(result == FUTURE_SUCCESS);
+ const controller_t *controller = controller_get_interface();
- btm_db_reset ();
- btm_inq_db_reset();
+ /* Tell L2CAP that all connections are gone */
+ l2cu_device_reset ();
- /* If anyone wants device status notifications, give him one */
- btm_report_device_status (BTM_DEV_STATUS_DOWN);
+ /* Clear current security state */
+ for (int devinx = 0; devinx < BTM_SEC_MAX_DEVICE_RECORDS; devinx++) {
+ btm_cb.sec_dev_rec[devinx].sec_state = BTM_SEC_STATE_IDLE;
+ }
- btu_stop_timer (&btm_cb.devcb.reset_timer);
-}
+ /* After the reset controller should restore all parameters to defaults. */
+ btm_cb.btm_inq_vars.inq_counter = 1;
+ btm_cb.btm_inq_vars.inq_scan_window = HCI_DEF_INQUIRYSCAN_WINDOW;
+ btm_cb.btm_inq_vars.inq_scan_period = HCI_DEF_INQUIRYSCAN_INTERVAL;
+ btm_cb.btm_inq_vars.inq_scan_type = HCI_DEF_SCAN_TYPE;
+ btm_cb.btm_inq_vars.page_scan_window = HCI_DEF_PAGESCAN_WINDOW;
+ btm_cb.btm_inq_vars.page_scan_period = HCI_DEF_PAGESCAN_INTERVAL;
+ btm_cb.btm_inq_vars.page_scan_type = HCI_DEF_SCAN_TYPE;
-/*******************************************************************************
-**
-** Function BTM_DeviceReset
-**
-** Description This function is called to reset the HCI. Callback function
-** if provided is called when startup of the device is
-** completed.
-**
-** Returns void
-**
-*******************************************************************************/
-void BTM_DeviceReset (tBTM_CMPL_CB *p_cb)
-{
- tBTM_STATUS status;
+#if (BLE_INCLUDED == TRUE)
+ btm_cb.ble_ctr_cb.conn_state = BLE_CONN_IDLE;
+ btm_cb.ble_ctr_cb.bg_dev_num = 0;
+ btm_cb.ble_ctr_cb.bg_conn_type = BTM_BLE_CONN_NONE;
+ btm_cb.ble_ctr_cb.p_select_cback = NULL;
+ memset(&btm_cb.ble_ctr_cb.bg_dev_list, 0, (sizeof(tBTM_LE_BG_CONN_DEV)*BTM_BLE_MAX_BG_CONN_DEV_NUM));
+ gatt_reset_bgdev_list();
+ btm_ble_multi_adv_init();
+#endif
- /* If device is already resetting, do not allow another */
- if ((!btm_cb.devcb.p_reset_cmpl_cb) || (btm_cb.devcb.p_reset_cmpl_cb == p_cb))
- {
- /* Flush all ACL connections */
- btm_acl_device_down();
+#if BTM_PWR_MGR_INCLUDED == TRUE
+ btm_pm_reset();
+#endif
+
+ l2c_link_processs_num_bufs(controller->get_acl_buffer_count_classic());
+#if (BLE_INCLUDED == TRUE)
+ if (controller->supports_ble()) {
+ l2c_link_processs_ble_num_bufs(controller->get_acl_buffer_count_ble());
+ }
+#endif
- /* Clear the callback, so application would not hang on reset */
- btm_db_reset();
+ BTM_SetPinType (btm_cb.cfg.pin_type, btm_cb.cfg.pin_code, btm_cb.cfg.pin_code_len);
- /* Save address of the completion routine, if provided */
- btm_cb.devcb.p_reset_cmpl_cb = p_cb;
+ for (int i = 0; i <= controller->get_last_features_classic_index(); i++) {
+ btm_decode_ext_features_page(i, controller->get_features_classic(i)->as_array);
+ }
- btm_dev_reset ();
- }
- else
- {
- /* pass an error to the bad callback, another one was already provided */
- if (p_cb)
- {
- status = BTM_ILLEGAL_VALUE;
- p_cb (&status);
- }
- }
+ btm_report_device_status(BTM_DEV_STATUS_UP);
}
+// TODO(zachoverflow): remove this function
+void BTM_DeviceReset (UNUSED_ATTR tBTM_CMPL_CB *p_cb) {
+ /* Flush all ACL connections */
+ btm_acl_device_down();
+
+ /* Clear the callback, so application would not hang on reset */
+ btm_db_reset();
+
+ module_start_up_callbacked_wrapper(
+ get_module(CONTROLLER_MODULE),
+ bt_workqueue_thread,
+ reset_complete
+ );
+}
/*******************************************************************************
**
*******************************************************************************/
BOOLEAN BTM_IsDeviceUp (void)
{
- return ((BOOLEAN) (btm_cb.devcb.state == BTM_DEV_STATE_READY));
+ return controller_get_interface()->get_is_ready();
}
/*******************************************************************************
first, btm_cb.first_disabled_channel, last,
btm_cb.last_disabled_channel);
+ const controller_t *controller = controller_get_interface();
/* Make sure the local device supports the feature before sending */
- if ((!HCI_LMP_AFH_CAP_MASTR_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_0])) &&
- (!HCI_LMP_AFH_CLASS_SLAVE_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_0])) &&
- (!HCI_LMP_AFH_CLASS_MASTR_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_0])))
+ if (!HCI_LMP_AFH_CAP_MASTR_SUPPORTED(controller->get_features_classic(0)->as_array) &&
+ !HCI_LMP_AFH_CLASS_SLAVE_SUPPORTED(controller->get_features_classic(0)->as_array) &&
+ !HCI_LMP_AFH_CLASS_MASTR_SUPPORTED(controller->get_features_classic(0)->as_array))
return (BTM_MODE_UNSUPPORTED);
if (!BTM_IsDeviceUp())
if ((btm_cb.first_disabled_channel != first)
|| (btm_cb.last_disabled_channel != last))
{
- if (btsnd_hcic_set_afh_channels (first, last))
- {
- btm_cb.first_disabled_channel = first;
- btm_cb.last_disabled_channel = last;
- }
- else
- return (BTM_NO_RESOURCES);
- }
- return (BTM_SUCCESS);
-}
-
-/*******************************************************************************
-**
-** Function BTM_SetAfhChannelAssessment
-**
-** Description This function is called to set the channel assessment mode on or off
-**
-** Returns none
-**
-*******************************************************************************/
-tBTM_STATUS BTM_SetAfhChannelAssessment (BOOLEAN enable_or_disable)
-{
- /* whatever app wants if device is not 1.2 scan type should be STANDARD */
- if (!HCI_LMP_AFH_CAP_SLAVE_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_0]))
- return (BTM_MODE_UNSUPPORTED);
-
- if (!btsnd_hcic_write_afh_channel_assessment_mode (enable_or_disable))
- return (BTM_NO_RESOURCES);
-
- return (BTM_SUCCESS);
-}
-
-/*******************************************************************************
-**
-** Function btm_dev_reset
-**
-** Description Local function called to send a reset command
-**
-** Returns void
-**
-*******************************************************************************/
-static void btm_dev_reset (void)
-{
- btm_cb.devcb.state = BTM_DEV_STATE_WAIT_RESET_CMPLT;
-
- /* Start reset timer. When timer expires we will send first command */
- /* from the setup sequence */
-
- btu_start_timer (&btm_cb.devcb.reset_timer, BTU_TTYPE_BTM_DEV_CTL,
- BTM_DEV_RESET_TIMEOUT);
- btsnd_hcic_reset (LOCAL_BR_EDR_CONTROLLER_ID);
-}
-
-
-/*******************************************************************************
-**
-** Function btm_get_hci_buf_size
-**
-** Description Local function called to send a read buffer size command
-**
-** Returns void
-**
-*******************************************************************************/
-void btm_get_hci_buf_size (void)
-{
-
- btu_start_timer (&btm_cb.devcb.reset_timer, BTU_TTYPE_BTM_DEV_CTL, BTM_DEV_REPLY_TIMEOUT);
-
- /* Send a Read Buffer Size message to the Host Controller. */
- btsnd_hcic_read_buffer_size ();
-
-}
-#if BLE_INCLUDED == TRUE
-/*******************************************************************************
-**
-** Function btm_read_ble_wl_size
-**
-** Description Local function called to send a read BLE buffer size command
-**
-** Returns void
-**
-*******************************************************************************/
-void btm_read_ble_wl_size(void)
-{
- BTM_TRACE_DEBUG("btm_read_ble_wl_size ");
- btu_start_timer (&btm_cb.devcb.reset_timer, BTU_TTYPE_BTM_DEV_CTL, BTM_DEV_REPLY_TIMEOUT);
-
- /* Send a Read Buffer Size message to the Host Controller. */
- btsnd_hcic_ble_read_white_list_size();
-}
-/*******************************************************************************
-**
-** Function btm_get_ble_buffer_size
-**
-** Description Local function called to send a read BLE buffer size command
-**
-** Returns void
-**
-*******************************************************************************/
-void btm_get_ble_buffer_size(void)
-{
- BTM_TRACE_DEBUG("btm_get_ble_buffer_size ");
- btu_start_timer (&btm_cb.devcb.reset_timer, BTU_TTYPE_BTM_DEV_CTL, BTM_DEV_REPLY_TIMEOUT);
-
- /* Send a Read Buffer Size message to the Host Controller. */
- btsnd_hcic_ble_read_buffer_size ();
-}
-
-/*******************************************************************************
-**
-** Function btm_read_ble_local_supported_features
-**
-** Description Local function called to send a read BLE local supported
-** features command
-**
-** Returns void
-**
-*******************************************************************************/
-static void btm_read_ble_local_supported_features(void)
-{
- BTM_TRACE_DEBUG("btm_read_ble_local_supported_features ");
- btu_start_timer (&btm_cb.devcb.reset_timer, BTU_TTYPE_BTM_DEV_CTL, BTM_DEV_REPLY_TIMEOUT);
-
- /* Send a Read Local Supported Features message to the Host Controller. */
- btsnd_hcic_ble_read_local_spt_feat ();
-}
-
-/*******************************************************************************
-**
-** Function btm_read_ble_local_supported_states
-**
-** Description Local function called to send a read BLE local supported
-** features command
-**
-** Returns void
-**
-*******************************************************************************/
-static void btm_read_ble_local_supported_states(void)
-{
- BTM_TRACE_DEBUG("btm_read_ble_local_supported_states ");
- btu_start_timer (&btm_cb.devcb.reset_timer, BTU_TTYPE_BTM_DEV_CTL, BTM_DEV_REPLY_TIMEOUT);
-
- /* Send a Read Local Supported states message to the Host Controller. */
- btsnd_hcic_ble_read_supported_states ();
-}
-#endif
-/*******************************************************************************
-**
-** Function btm_get_local_version
-**
-** Description Local function called to send a read local version to controller
-**
-** Returns void
-**
-*******************************************************************************/
-void btm_get_local_version (void)
-{
-
- btu_start_timer (&btm_cb.devcb.reset_timer, BTU_TTYPE_BTM_DEV_CTL, BTM_DEV_REPLY_TIMEOUT);
-
- /* Send a Read Local Version message to the Host Controller. */
- btsnd_hcic_read_local_ver (LOCAL_BR_EDR_CONTROLLER_ID);
- btsnd_hcic_read_bd_addr ();
-
-#if BTM_PWR_MGR_INCLUDED == TRUE
- btm_pm_reset();
-#endif
-
-}
-
-/*******************************************************************************
-**
-** Function btm_read_local_supported_cmds
-**
-** Description Local function called to send a read local supported commands
-**
-** Returns void
-**
-*******************************************************************************/
-static void btm_read_local_supported_cmds (UINT8 local_controller_id)
-{
- BTM_TRACE_DEBUG("Start reading local supported commands");
-
- btu_start_timer (&btm_cb.devcb.reset_timer, BTU_TTYPE_BTM_DEV_CTL, BTM_DEV_REPLY_TIMEOUT);
-
- btsnd_hcic_read_local_supported_cmds(local_controller_id);
-}
-
-/*******************************************************************************
-**
-** Function btm_get_local_features
-**
-** Description Local function called to send a read local features
-**
-** Returns void
-**
-*******************************************************************************/
-static void btm_get_local_features (void)
-{
- /* If this BT controller supports Read Extended Feature */
- if (btm_cb.devcb.local_version.hci_version >= HCI_PROTO_VERSION_2_0)
- {
- btm_get_local_ext_features(HCI_EXT_FEATURES_PAGE_0);
- }
- /* else, if this is a very old BT controller */
- else
-{
- btu_start_timer (&btm_cb.devcb.reset_timer, BTU_TTYPE_BTM_DEV_CTL, BTM_DEV_REPLY_TIMEOUT);
-
- /* Just read the basic features (legacy HCI command) */
- btsnd_hcic_read_local_features ();
-}
-}
-
-/*******************************************************************************
-**
-** Function btm_get_local_ext_features
-**
-** Description Local function called to send a read local extended features
-**
-** Returns void
-**
-*******************************************************************************/
-static void btm_get_local_ext_features (UINT8 page_number)
-{
- btu_start_timer (&btm_cb.devcb.reset_timer, BTU_TTYPE_BTM_DEV_CTL, BTM_DEV_REPLY_TIMEOUT);
-
- btsnd_hcic_read_local_ext_features(page_number);
-}
-
-/*******************************************************************************
-**
-** Function btm_dev_timeout
-**
-** Description This function is called when a timer list entry expires.
-**
-** Returns void
-**
-*******************************************************************************/
-void btm_dev_timeout (TIMER_LIST_ENT *p_tle)
-{
- TIMER_PARAM_TYPE timer_type = (TIMER_PARAM_TYPE)p_tle->param;
-
- if ((timer_type & TT_DEV_RESET_MASK) == TT_DEV_RESET)
- {
- /* Call device reset as long as there is timeout*/
- btm_dev_reset();
- }
- else if (timer_type == (TIMER_PARAM_TYPE)TT_DEV_RLN)
- {
- tBTM_CMPL_CB *p_cb = btm_cb.devcb.p_rln_cmpl_cb;
-
- btm_cb.devcb.p_rln_cmpl_cb = NULL;
-
- if (p_cb)
- (*p_cb)((void *) NULL);
- }
-}
-
-/*******************************************************************************
-**
-** Function btm_reset_complete
-**
-** Description This function is called when command complete for HCI_Reset
-** is received. It does not make sense to send next command
-** because device is resetting after command complete is
-** received. Just start timer and set required state.
-**
-** Returns void
-**
-*******************************************************************************/
-void btm_reset_complete (void)
-{
- int devinx;
-
- BTM_TRACE_EVENT ("btm_reset_complete");
-
- /* Handle if btm initiated the reset */
- if (btm_cb.devcb.state == BTM_DEV_STATE_WAIT_RESET_CMPLT)
- {
- /* Tell L2CAP that all connections are gone */
- l2cu_device_reset ();
-
- /* Clear current security state */
- for (devinx = 0; devinx < BTM_SEC_MAX_DEVICE_RECORDS; devinx++)
- {
- btm_cb.sec_dev_rec[devinx].sec_state = BTM_SEC_STATE_IDLE;
- }
-
- /* After the reset controller should restore all parameters to defaults. */
- btm_cb.btm_inq_vars.inq_counter = 1;
- btm_cb.btm_inq_vars.inq_scan_window = HCI_DEF_INQUIRYSCAN_WINDOW;
- btm_cb.btm_inq_vars.inq_scan_period = HCI_DEF_INQUIRYSCAN_INTERVAL;
- btm_cb.btm_inq_vars.inq_scan_type = HCI_DEF_SCAN_TYPE;
-
- btm_cb.btm_inq_vars.page_scan_window = HCI_DEF_PAGESCAN_WINDOW;
- btm_cb.btm_inq_vars.page_scan_period = HCI_DEF_PAGESCAN_INTERVAL;
- btm_cb.btm_inq_vars.page_scan_type = HCI_DEF_SCAN_TYPE;
-
- btm_cb.devcb.state = BTM_DEV_STATE_WAIT_AFTER_RESET;
- btu_stop_timer(&btm_cb.devcb.reset_timer);
- btm_continue_reset();
-
-#if (BLE_INCLUDED == TRUE)
- btm_cb.ble_ctr_cb.conn_state = BLE_CONN_IDLE;
- btm_cb.ble_ctr_cb.bg_dev_num = 0;
- btm_cb.ble_ctr_cb.bg_conn_type = BTM_BLE_CONN_NONE;
- btm_cb.ble_ctr_cb.p_select_cback = NULL;
- memset(&btm_cb.ble_ctr_cb.bg_dev_list, 0, (sizeof(tBTM_LE_BG_CONN_DEV)*BTM_BLE_MAX_BG_CONN_DEV_NUM));
- gatt_reset_bgdev_list();
-#endif
- }
-}
-
-/*******************************************************************************
-**
-** Function btm_continue_reset
-**
-** Description This function is called when wait period expired after
-** device reset or called by the application to continue
-** initialization after the application has completed its
-** vendor specific sequence.
-**
-** Returns void
-**
-*******************************************************************************/
-void btm_continue_reset (void)
-{
- btm_get_hci_buf_size ();
-
-#if (BTM_MAX_LOC_BD_NAME_LEN > 0) && (BTM_SET_DEV_NAME_UPON_RESET == TRUE)
- BTM_SetLocalDeviceName(btm_cb.cfg.bd_name);
-#endif
-
- BTM_SetPinType (btm_cb.cfg.pin_type, btm_cb.cfg.pin_code, btm_cb.cfg.pin_code_len);
-}
-
-/*******************************************************************************
-**
-** Function btm_read_hci_buf_size_complete
-**
-** Description This function is called when command complete for
-** get HCI buffer size is received. Start timer and send
-** read local features request
-**
-** Returns void
-**
-*******************************************************************************/
-void btm_read_hci_buf_size_complete (UINT8 *p, UINT16 evt_len)
-{
- UINT8 status;
- UINT8 lm_sco_buf_size;
- UINT16 lm_num_acl_bufs;
- UINT16 lm_num_sco_bufs;
- UINT16 acl_buf_size;
- UNUSED(evt_len);
-
- STREAM_TO_UINT8 (status, p);
- if (status == HCI_SUCCESS)
- {
- STREAM_TO_UINT16 (btu_cb.hcit_acl_data_size, p);
- STREAM_TO_UINT8 (lm_sco_buf_size, p);
- STREAM_TO_UINT16 (lm_num_acl_bufs, p);
- STREAM_TO_UINT16 (lm_num_sco_bufs, p);
-
- btu_cb.hcit_acl_pkt_size = btu_cb.hcit_acl_data_size + HCI_DATA_PREAMBLE_SIZE;
-
- l2c_link_processs_num_bufs (lm_num_acl_bufs);
-
-#if BTM_ACL_BUF_SIZE > 0
- acl_buf_size = (BTM_ACL_BUF_SIZE < L2CAP_MTU_SIZE) ? BTM_ACL_BUF_SIZE : L2CAP_MTU_SIZE;
-#else
- acl_buf_size = L2CAP_MTU_SIZE;
-#endif
- /* Tell the controller what our buffer sizes are. ?? Need SCO info */
- btsnd_hcic_set_host_buf_size (acl_buf_size, BTM_SCO_HOST_BUF_SIZE, L2CAP_HOST_FC_ACL_BUFS, 10);
- }
-
- btm_get_local_version ();
-}
-
-#if (BLE_INCLUDED == TRUE)
-/*******************************************************************************
-**
-** Function btm_read_ble_buf_size_complete
-**
-** Description This function is called when command complete for
-** get HCI buffer size is received. Start timer and send
-** read local supported features request
-**
-** Returns void
-**
-*******************************************************************************/
-void btm_read_ble_buf_size_complete (UINT8 *p, UINT16 evt_len)
-{
- UINT8 status;
- UINT16 lm_num_le_bufs;
- UNUSED(evt_len);
-
- BTM_TRACE_DEBUG("btm_read_ble_buf_size_complete ");
- STREAM_TO_UINT8 (status, p);
- if (status == HCI_SUCCESS)
- {
- STREAM_TO_UINT16 (btu_cb.hcit_ble_acl_data_size, p);
- STREAM_TO_UINT8 (lm_num_le_bufs, p);
-
- if (btu_cb.hcit_ble_acl_data_size == 0)
- btu_cb.hcit_ble_acl_data_size = btu_cb.hcit_acl_data_size;
-
- btu_cb.hcit_ble_acl_pkt_size = btu_cb.hcit_ble_acl_data_size + HCI_DATA_PREAMBLE_SIZE;
-
- l2c_link_processs_ble_num_bufs (lm_num_le_bufs);
- }
- btm_read_ble_local_supported_states();
-}
-/*******************************************************************************
-**
-** Function btm_read_ble_local_supported_states_complete
-**
-** Description This function is called when command complete for
-** Read LE Local Supported states complete is received.
-**
-** Returns void
-**
-*******************************************************************************/
-void btm_read_ble_local_supported_states_complete (UINT8 *p, UINT16 evt_len)
-{
- UINT8 status;
-
- UNUSED(evt_len);
- BTM_TRACE_DEBUG("btm_read_ble_local_supported_states_complete ");
-
- btu_stop_timer (&btm_cb.devcb.reset_timer);
-
- STREAM_TO_UINT8 (status, p);
- if (status == HCI_SUCCESS)
- {
- STREAM_TO_ARRAY(&btm_cb.devcb.le_supported_states, p, BTM_LE_SUPPORT_STATE_SIZE);
- }
- else
- {
- BTM_TRACE_WARNING ("btm_read_ble_local_supported_features_complete status = %d", status);
- }
-
- btm_read_ble_local_supported_features();
-}
-
-/*******************************************************************************
-**
-** Function btm_read_ble_local_supported_features_complete
-**
-** Description This function is called when command complete for
-** Read LE Local Supported Features is received. Start timer and send
-** read LMP local features request
-**
-** Returns void
-**
-*******************************************************************************/
-void btm_read_ble_local_supported_features_complete (UINT8 *p, UINT16 evt_len)
-{
- UINT8 status;
- UNUSED(evt_len);
-
- BTM_TRACE_DEBUG("btm_read_ble_local_supported_features_complete ");
-
- btu_stop_timer (&btm_cb.devcb.reset_timer);
-
- STREAM_TO_UINT8 (status, p);
- if (status == HCI_SUCCESS)
- {
- STREAM_TO_ARRAY(&btm_cb.devcb.local_le_features, p, HCI_FEATURE_BYTES_PER_PAGE);
- }
- else
- {
- BTM_TRACE_WARNING ("btm_read_ble_local_supported_features_complete status = %d", status);
- }
-
- btsnd_hcic_ble_set_evt_mask((UINT8 *)HCI_BLE_EVENT_MASK_DEF);
-
- btm_reset_ctrlr_complete();
-}
-
-/*******************************************************************************
-**
-** Function btm_read_white_list_size_complete
-**
-** Description This function read the current white list size.
-*******************************************************************************/
-void btm_read_white_list_size_complete(UINT8 *p, UINT16 evt_len)
-{
- UINT8 status;
- UNUSED(evt_len);
-
- BTM_TRACE_DEBUG("btm_read_white_list_size_complete ");
- STREAM_TO_UINT8 (status, p);
-
- if (status == HCI_SUCCESS)
- {
- STREAM_TO_UINT8(btm_cb.ble_ctr_cb.max_filter_entries, p);
- btm_cb.ble_ctr_cb.num_empty_filter = btm_cb.ble_ctr_cb.max_filter_entries;
- }
- /* write LE host support and simultatunous LE supported */
- btsnd_hcic_ble_write_host_supported(BTM_BLE_HOST_SUPPORT, BTM_BLE_SIMULTANEOUS_HOST);
-
- btm_get_ble_buffer_size();
-}
-
-#endif
-/*******************************************************************************
-**
-** Function btm_read_local_version_complete
-**
-** Description This function is called when local BD Addr read complete
-** message is received from the HCI.
-**
-** Returns void
-**
-*******************************************************************************/
-void btm_read_local_version_complete (UINT8 *p, UINT16 evt_len)
-{
- tBTM_VERSION_INFO *p_vi = &btm_cb.devcb.local_version;
- UINT8 status;
- UNUSED(evt_len);
-
-#ifdef BTA_PRM_CHECK_FW_VER
- if(BTA_PRM_CHECK_FW_VER(p))
- return;
-#endif
-
- STREAM_TO_UINT8 (status, p);
- if (status == HCI_SUCCESS)
- {
-
- STREAM_TO_UINT8 (p_vi->hci_version, p);
- STREAM_TO_UINT16 (p_vi->hci_revision, p);
- STREAM_TO_UINT8 (p_vi->lmp_version, p);
- STREAM_TO_UINT16 (p_vi->manufacturer, p);
- STREAM_TO_UINT16 (p_vi->lmp_subversion, p);
- }
-
- if (p_vi->hci_version >= HCI_PROTO_VERSION_1_2)
- {
- btm_read_local_supported_cmds(LOCAL_BR_EDR_CONTROLLER_ID);
- }
- else
- {
- btm_get_local_features ();
- }
-}
-
-/*******************************************************************************
-**
-** Function btm_decode_ext_features_page
-**
-** Description This function is decodes a features page.
-**
-** Returns void
-**
-*******************************************************************************/
-static void btm_decode_ext_features_page (UINT8 page_number, const UINT8 *p_features)
-{
- UINT8 last;
- UINT8 first;
-
- BTM_TRACE_DEBUG ("btm_decode_ext_features_page page: %d", page_number);
- switch (page_number)
- {
- /* Extended (Legacy) Page 0 */
- case HCI_EXT_FEATURES_PAGE_0:
-
- /* Create ACL supported packet types mask */
- btm_cb.btm_acl_pkt_types_supported = (BTM_ACL_PKT_TYPES_MASK_DH1 +
- BTM_ACL_PKT_TYPES_MASK_DM1);
-
- if (HCI_3_SLOT_PACKETS_SUPPORTED(p_features))
- btm_cb.btm_acl_pkt_types_supported |= (BTM_ACL_PKT_TYPES_MASK_DH3 +
- BTM_ACL_PKT_TYPES_MASK_DM3);
-
- if (HCI_5_SLOT_PACKETS_SUPPORTED(p_features))
- btm_cb.btm_acl_pkt_types_supported |= (BTM_ACL_PKT_TYPES_MASK_DH5 +
- BTM_ACL_PKT_TYPES_MASK_DM5);
-
- /* _NO_X_DXX masks are reserved before ver 2.0.
- Set them only for later versions of controller */
- if (btm_cb.devcb.local_version.hci_version >= HCI_PROTO_VERSION_2_0)
- {
- /* Add in EDR related ACL types */
- if (!HCI_EDR_ACL_2MPS_SUPPORTED(p_features))
- {
- btm_cb.btm_acl_pkt_types_supported |= (BTM_ACL_PKT_TYPES_MASK_NO_2_DH1 +
- BTM_ACL_PKT_TYPES_MASK_NO_2_DH3 +
- BTM_ACL_PKT_TYPES_MASK_NO_2_DH5);
- }
-
- if (!HCI_EDR_ACL_3MPS_SUPPORTED(p_features))
- {
- btm_cb.btm_acl_pkt_types_supported |= (BTM_ACL_PKT_TYPES_MASK_NO_3_DH1 +
- BTM_ACL_PKT_TYPES_MASK_NO_3_DH3 +
- BTM_ACL_PKT_TYPES_MASK_NO_3_DH5);
- }
-
- /* Check to see if 3 and 5 slot packets are available */
- if (HCI_EDR_ACL_2MPS_SUPPORTED(p_features) ||
- HCI_EDR_ACL_3MPS_SUPPORTED(p_features))
- {
- if (!HCI_3_SLOT_EDR_ACL_SUPPORTED(p_features))
- btm_cb.btm_acl_pkt_types_supported |= (BTM_ACL_PKT_TYPES_MASK_NO_2_DH3 +
- BTM_ACL_PKT_TYPES_MASK_NO_3_DH3);
-
- if (!HCI_5_SLOT_EDR_ACL_SUPPORTED(p_features))
- btm_cb.btm_acl_pkt_types_supported |= (BTM_ACL_PKT_TYPES_MASK_NO_2_DH5 +
- BTM_ACL_PKT_TYPES_MASK_NO_3_DH5);
- }
- }
-
- BTM_TRACE_DEBUG("Local supported ACL packet types: 0x%04x",
- btm_cb.btm_acl_pkt_types_supported);
-
- /* Create (e)SCO supported packet types mask */
- btm_cb.btm_sco_pkt_types_supported = 0;
-#if BTM_SCO_INCLUDED == TRUE
- btm_cb.sco_cb.esco_supported = FALSE;
-#endif
- if (HCI_SCO_LINK_SUPPORTED(p_features))
- {
- btm_cb.btm_sco_pkt_types_supported = BTM_SCO_PKT_TYPES_MASK_HV1;
-
- if (HCI_HV2_PACKETS_SUPPORTED(p_features))
- btm_cb.btm_sco_pkt_types_supported |= BTM_SCO_PKT_TYPES_MASK_HV2;
-
- if (HCI_HV3_PACKETS_SUPPORTED(p_features))
- btm_cb.btm_sco_pkt_types_supported |= BTM_SCO_PKT_TYPES_MASK_HV3;
- }
-
- if (HCI_ESCO_EV3_SUPPORTED(p_features))
- btm_cb.btm_sco_pkt_types_supported |= BTM_SCO_PKT_TYPES_MASK_EV3;
-
- if (HCI_ESCO_EV4_SUPPORTED(p_features))
- btm_cb.btm_sco_pkt_types_supported |= BTM_SCO_PKT_TYPES_MASK_EV4;
-
- if (HCI_ESCO_EV5_SUPPORTED(p_features))
- btm_cb.btm_sco_pkt_types_supported |= BTM_SCO_PKT_TYPES_MASK_EV5;
-#if BTM_SCO_INCLUDED == TRUE
- if (btm_cb.btm_sco_pkt_types_supported & BTM_ESCO_LINK_ONLY_MASK)
- {
- btm_cb.sco_cb.esco_supported = TRUE;
-
- /* Add in EDR related eSCO types */
- if (HCI_EDR_ESCO_2MPS_SUPPORTED(p_features))
- {
- if (!HCI_3_SLOT_EDR_ESCO_SUPPORTED(p_features))
- btm_cb.btm_sco_pkt_types_supported |= BTM_SCO_PKT_TYPES_MASK_NO_2_EV5;
- }
- else
- {
- btm_cb.btm_sco_pkt_types_supported |= (BTM_SCO_PKT_TYPES_MASK_NO_2_EV3 +
- BTM_SCO_PKT_TYPES_MASK_NO_2_EV5);
- }
-
- if (HCI_EDR_ESCO_3MPS_SUPPORTED(p_features))
- {
- if (!HCI_3_SLOT_EDR_ESCO_SUPPORTED(p_features))
- btm_cb.btm_sco_pkt_types_supported |= BTM_SCO_PKT_TYPES_MASK_NO_3_EV5;
- }
- else
- {
- btm_cb.btm_sco_pkt_types_supported |= (BTM_SCO_PKT_TYPES_MASK_NO_3_EV3 +
- BTM_SCO_PKT_TYPES_MASK_NO_3_EV5);
- }
- }
-#endif
-
- BTM_TRACE_DEBUG("Local supported SCO packet types: 0x%04x",
- btm_cb.btm_sco_pkt_types_supported);
-
- /* Create Default Policy Settings */
- if (HCI_SWITCH_SUPPORTED(p_features))
- btm_cb.btm_def_link_policy |= HCI_ENABLE_MASTER_SLAVE_SWITCH;
- else
- btm_cb.btm_def_link_policy &= ~HCI_ENABLE_MASTER_SLAVE_SWITCH;
-
- if (HCI_HOLD_MODE_SUPPORTED(p_features))
- btm_cb.btm_def_link_policy |= HCI_ENABLE_HOLD_MODE;
- else
- btm_cb.btm_def_link_policy &= ~HCI_ENABLE_HOLD_MODE;
-
- if (HCI_SNIFF_MODE_SUPPORTED(p_features))
- btm_cb.btm_def_link_policy |= HCI_ENABLE_SNIFF_MODE;
- else
- btm_cb.btm_def_link_policy &= ~HCI_ENABLE_SNIFF_MODE;
-
- if (HCI_PARK_MODE_SUPPORTED(p_features))
- btm_cb.btm_def_link_policy |= HCI_ENABLE_PARK_MODE;
- else
- btm_cb.btm_def_link_policy &= ~HCI_ENABLE_PARK_MODE;
-
- btm_sec_dev_reset ();
-#if ((BTM_EIR_SERVER_INCLUDED == TRUE)||(BTM_EIR_CLIENT_INCLUDED == TRUE))
- if (HCI_LMP_INQ_RSSI_SUPPORTED(p_features))
- {
- if (HCI_EXT_INQ_RSP_SUPPORTED(p_features))
- BTM_SetInquiryMode (BTM_INQ_RESULT_EXTENDED);
- else
- BTM_SetInquiryMode (BTM_INQ_RESULT_WITH_RSSI);
- }
-#else
- if (HCI_LMP_INQ_RSSI_SUPPORTED(p_features))
- BTM_SetInquiryMode (BTM_INQ_RESULT_WITH_RSSI);
-#endif
-#if L2CAP_NON_FLUSHABLE_PB_INCLUDED == TRUE
- if( HCI_NON_FLUSHABLE_PB_SUPPORTED(p_features))
- l2cu_set_non_flushable_pbf(TRUE);
- else
- l2cu_set_non_flushable_pbf(FALSE);
-#endif
- BTM_SetPageScanType (BTM_DEFAULT_SCAN_TYPE);
- BTM_SetInquiryScanType (BTM_DEFAULT_SCAN_TYPE);
-
- break;
-
- /* Extended Page 1 */
- case HCI_EXT_FEATURES_PAGE_1:
- /* Nothing to do for page 1 */
- break;
-
- /* Extended Page 2 */
- case HCI_EXT_FEATURES_PAGE_2:
- /* Nothing to do for page 2 */
- break;
-
- default:
- BTM_TRACE_ERROR("btm_decode_ext_features_page page=%d unknown", page_number);
- break;
- }
-}
-
-/*******************************************************************************
-**
-** Function btm_reset_ctrlr_complete
-**
-** Description This is the last step of BR/EDR controller startup sequence.
-**
-** Returns void
-**
-*******************************************************************************/
-void btm_reset_ctrlr_complete ()
-{
- tBTM_DEVCB *p_devcb = &btm_cb.devcb;
- tBTM_CMPL_CB *p_cb = p_devcb->p_reset_cmpl_cb;
- BOOLEAN found = FALSE;
- UINT8 i, j, max_page_number;
-
- btu_stop_timer (&btm_cb.devcb.reset_timer);
-
- /* find the highest feature page number which contains non-zero bits */
- for (i = HCI_EXT_FEATURES_PAGE_MAX; ; i--)
- {
- for (j = 0; j < HCI_FEATURE_BYTES_PER_PAGE; j++)
- {
- if (p_devcb->local_lmp_features[i][j] != 0)
- {
- found = TRUE;
- break;
- }
- }
- if (found || !i)
- {
- break;
- }
- }
-
- if (!found)
- BTM_TRACE_WARNING ("btm_reset_ctrlr_complete: NONE of local controller features is set");
-
- max_page_number = i;
-
- BTM_TRACE_DEBUG ("btm_reset_ctrlr_complete: max_page_number: %d", max_page_number);
-
- /*
- * Set State to Ready (needs to be done before btm_decode_ext_features_page
- * to allow it to send some HCI configuration commands)
- */
- p_devcb->state = BTM_DEV_STATE_READY;
-
- /* For every received/saved feature page */
- for (i = 0; i <= max_page_number; i++)
- {
- /* Decode the saved Feature Page */
- btm_decode_ext_features_page(i, p_devcb->local_lmp_features[i]);
- }
-
- /* If there was a callback address for reset complete, reset it */
- p_devcb->p_reset_cmpl_cb = NULL;
-
- /* If anyone wants device status notifications, give him one */
- btm_report_device_status(BTM_DEV_STATUS_UP);
-
- /* Reset sequence is complete. If this was an application originated */
- /* reset, tell him its done. */
- if (p_cb)
- (*p_cb)((void *) NULL);
-}
-
-/*******************************************************************************
-**
-** Function btm_issue_host_support_for_lmp_features
-**
-** Description This function:
-** - issues commands to set host supported LMP features (one at
-** a time);
-** - after this is done it issues command to re-read LMP features
-** page 1;
-** - after this is done it calls the last step of BR/EDR
-** controller startup sequence.
-**
-** Returns void
-**
-*******************************************************************************/
-static void btm_issue_host_support_for_lmp_features (void)
-{
- BTM_TRACE_DEBUG("btm_issue_host_support_for_lmp_features lmp_features_host_may_support: 0x%02x", btm_cb.devcb.lmp_features_host_may_support);
-
- if (btm_cb.devcb.lmp_features_host_may_support & BTM_HOST_MAY_SUPP_SSP)
- {
- btsnd_hcic_write_simple_pairing_mode(HCI_SP_MODE_ENABLED);
- return;
- }
-
-#if (BLE_INCLUDED == TRUE)
- if (btm_cb.devcb.lmp_features_host_may_support & BTM_HOST_MAY_SUPP_LE)
- {
- if (btm_cb.devcb.lmp_features_host_may_support & BTM_HOST_MAY_SUPP_SIMULT_BR_LE)
- {
- btsnd_hcic_ble_write_host_supported(BTM_BLE_HOST_SUPPORT, BTM_BLE_SIMULTANEOUS_HOST);
- }
- else
- {
- btsnd_hcic_ble_write_host_supported(BTM_BLE_HOST_SUPPORT, 0);
- }
- return;
- }
-#endif
-
- if (btm_cb.devcb.lmp_features_host_may_support & BTM_RE_READ_1ST_PAGE)
- {
- btm_get_local_ext_features(HCI_EXT_FEATURES_PAGE_1);
- return;
- }
-
- if (!btm_cb.devcb.lmp_features_host_may_support)
- {
-#if BLE_INCLUDED == TRUE
- if (HCI_LE_HOST_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_1]))
- {
- btm_read_ble_wl_size();
- }
- else
-#endif
- {
- btm_reset_ctrlr_complete();
- }
- return;
- }
-
- BTM_TRACE_ERROR("%s lmp_features_host_may_support: 0x%02x. This is unexpected.",__FUNCTION__,
- btm_cb.devcb.lmp_features_host_may_support);
-}
-
-/*******************************************************************************
-**
-** Function btm_set_lmp_features_host_may_support
-**
-** Description This function is called after all LMP features provided by
-** controller are read. It sets the mask that indicates LMP
-** features the host may support based on LMP features supported
-** by controller.
-** Example:
-** Host may set SSP (host support) bit only if SSP (controller
-** support) bit is set by controller.
-**
-** Returns void
-**
-*******************************************************************************/
-static void btm_set_lmp_features_host_may_support (UINT8 max_page_number)
-{
- btm_cb.devcb.lmp_features_host_may_support = 0;
-
- /* LMP page 0 is always read */
- if (HCI_SIMPLE_PAIRING_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_0]))
- {
- /* host may support SSP */
- btm_cb.devcb.lmp_features_host_may_support |= BTM_HOST_MAY_SUPP_SSP;
- }
-
-#if (BLE_INCLUDED == TRUE)
- if (HCI_LE_SPT_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_0]))
- {
- /* host may support LE */
- btm_cb.devcb.lmp_features_host_may_support |= BTM_HOST_MAY_SUPP_LE;
-
- if (HCI_SIMUL_LE_BREDR_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_0]))
- {
- /* host may support BR/EDR and LE simultaneously */
- btm_cb.devcb.lmp_features_host_may_support |= BTM_HOST_MAY_SUPP_SIMULT_BR_LE;
- }
- }
-#endif
-
- if (max_page_number >= HCI_EXT_FEATURES_PAGE_1)
- {
- /* nothing yet for HCI_EXT_FEATURES_PAGE_1 */
- }
-
- if (max_page_number >= HCI_EXT_FEATURES_PAGE_1)
- {
- /* nothing yet for HCI_EXT_FEATURES_PAGE_2 */
+ if (btsnd_hcic_set_afh_channels (first, last))
+ {
+ btm_cb.first_disabled_channel = first;
+ btm_cb.last_disabled_channel = last;
+ }
+ else
+ return (BTM_NO_RESOURCES);
}
-
- if (btm_cb.devcb.lmp_features_host_may_support)
- btm_cb.devcb.lmp_features_host_may_support |= BTM_RE_READ_1ST_PAGE;
+ return (BTM_SUCCESS);
}
/*******************************************************************************
**
-** Function btm_read_all_lmp_features_complete
+** Function BTM_SetAfhChannelAssessment
**
-** Description This function is called after all LMP features provided by
-** controller are read.
-** It works with controller supported LMP features which host
-** may support too.
+** Description This function is called to set the channel assessment mode on or off
**
-** Returns void
+** Returns none
**
*******************************************************************************/
-static void btm_read_all_lmp_features_complete (UINT8 max_page_number)
+tBTM_STATUS BTM_SetAfhChannelAssessment (BOOLEAN enable_or_disable)
{
- btm_set_lmp_features_host_may_support(max_page_number);
+ const controller_t *controller = controller_get_interface();
+ /* whatever app wants if device is not 1.2 scan type should be STANDARD */
+ if (!HCI_LMP_AFH_CAP_SLAVE_SUPPORTED(controller->get_features_classic(0)->as_array))
+ return (BTM_MODE_UNSUPPORTED);
- btm_issue_host_support_for_lmp_features();
+ if (!btsnd_hcic_write_afh_channel_assessment_mode (enable_or_disable))
+ return (BTM_NO_RESOURCES);
+
+ return (BTM_SUCCESS);
}
/*******************************************************************************
**
-** Function btm_read_local_features_complete
+** Function btm_dev_timeout
**
-** Description This function is called when local supported features read
-** is complete.
+** Description This function is called when a timer list entry expires.
**
** Returns void
**
*******************************************************************************/
-void btm_read_local_features_complete (UINT8 *p, UINT16 evt_len)
+void btm_dev_timeout (TIMER_LIST_ENT *p_tle)
{
- tBTM_DEVCB *p_devcb = &btm_cb.devcb;
- UINT8 status;
- UNUSED(evt_len);
-
- btu_stop_timer (&p_devcb->reset_timer);
+ TIMER_PARAM_TYPE timer_type = (TIMER_PARAM_TYPE)p_tle->param;
- STREAM_TO_UINT8 (status, p);
- if (status == HCI_SUCCESS)
+ if (timer_type == (TIMER_PARAM_TYPE)TT_DEV_RLN)
{
- /* Save the Feature Page 0 */
- STREAM_TO_ARRAY(p_devcb->local_lmp_features[0],
- p, HCI_FEATURE_BYTES_PER_PAGE);
+ tBTM_CMPL_CB *p_cb = btm_cb.devcb.p_rln_cmpl_cb;
- if ((HCI_LMP_EXTENDED_SUPPORTED(p_devcb->local_lmp_features[HCI_EXT_FEATURES_PAGE_0])) &&
- (HCI_READ_LOCAL_EXT_FEATURES_SUPPORTED(p_devcb->supported_cmds)))
- {
- /* if local controller has extended features and supports
- **HCI_Read_Local_Extended_Features command,
- ** then start reading these feature starting with extended features page 1 */
- BTM_TRACE_DEBUG ("Start reading local extended features");
- btm_get_local_ext_features(HCI_EXT_FEATURES_PAGE_1);
- }
- else
- {
- btm_read_all_lmp_features_complete (HCI_EXT_FEATURES_PAGE_0);
- }
+ btm_cb.devcb.p_rln_cmpl_cb = NULL;
+
+ if (p_cb)
+ (*p_cb)((void *) NULL);
}
}
/*******************************************************************************
**
-** Function btm_read_local_ext_features_complete
+** Function btm_decode_ext_features_page
**
-** Description This function is called when read local extended features
-** command complete message is received from the HCI.
+** Description This function is decodes a features page.
**
** Returns void
**
*******************************************************************************/
-void btm_read_local_ext_features_complete (UINT8 *p, UINT16 evt_len)
+static void btm_decode_ext_features_page (UINT8 page_number, const UINT8 *p_features)
{
- tBTM_DEVCB *p_devcb = &btm_cb.devcb;
- tBTM_CMPL_CB *p_cb = p_devcb->p_reset_cmpl_cb;
- UINT8 status;
- UINT8 page_number;
- UINT8 page_number_max;
- UNUSED(evt_len);
+ UINT8 last;
+ UINT8 first;
- btu_stop_timer (&btm_cb.devcb.reset_timer);
+ BTM_TRACE_DEBUG ("btm_decode_ext_features_page page: %d", page_number);
+ switch (page_number)
+ {
+ /* Extended (Legacy) Page 0 */
+ case HCI_EXT_FEATURES_PAGE_0:
- STREAM_TO_UINT8 (status, p);
+ /* Create ACL supported packet types mask */
+ btm_cb.btm_acl_pkt_types_supported = (BTM_ACL_PKT_TYPES_MASK_DH1 +
+ BTM_ACL_PKT_TYPES_MASK_DM1);
- if (status != HCI_SUCCESS)
- {
- BTM_TRACE_WARNING("btm_read_local_ext_features_complete status = 0x%02X", status);
- btm_read_all_lmp_features_complete (HCI_EXT_FEATURES_PAGE_0);
- return;
- }
+ if (HCI_3_SLOT_PACKETS_SUPPORTED(p_features))
+ btm_cb.btm_acl_pkt_types_supported |= (BTM_ACL_PKT_TYPES_MASK_DH3 +
+ BTM_ACL_PKT_TYPES_MASK_DM3);
- /* Extract Page number */
- STREAM_TO_UINT8 (page_number, p);
+ if (HCI_5_SLOT_PACKETS_SUPPORTED(p_features))
+ btm_cb.btm_acl_pkt_types_supported |= (BTM_ACL_PKT_TYPES_MASK_DH5 +
+ BTM_ACL_PKT_TYPES_MASK_DM5);
- /* Extract Page number Max */
- STREAM_TO_UINT8 (page_number_max, p);
+ /* Add in EDR related ACL types */
+ if (!HCI_EDR_ACL_2MPS_SUPPORTED(p_features))
+ {
+ btm_cb.btm_acl_pkt_types_supported |= (BTM_ACL_PKT_TYPES_MASK_NO_2_DH1 +
+ BTM_ACL_PKT_TYPES_MASK_NO_2_DH3 +
+ BTM_ACL_PKT_TYPES_MASK_NO_2_DH5);
+ }
- if (page_number > HCI_EXT_FEATURES_PAGE_MAX)
- {
- BTM_TRACE_ERROR("btm_read_local_ext_features_complete page=%d unknown",
- page_number);
- return;
- }
+ if (!HCI_EDR_ACL_3MPS_SUPPORTED(p_features))
+ {
+ btm_cb.btm_acl_pkt_types_supported |= (BTM_ACL_PKT_TYPES_MASK_NO_3_DH1 +
+ BTM_ACL_PKT_TYPES_MASK_NO_3_DH3 +
+ BTM_ACL_PKT_TYPES_MASK_NO_3_DH5);
+ }
- /* Save the extended features Page received */
- STREAM_TO_ARRAY(btm_cb.devcb.local_lmp_features[page_number],
- p, HCI_FEATURE_BYTES_PER_PAGE);
+ /* Check to see if 3 and 5 slot packets are available */
+ if (HCI_EDR_ACL_2MPS_SUPPORTED(p_features) ||
+ HCI_EDR_ACL_3MPS_SUPPORTED(p_features))
+ {
+ if (!HCI_3_SLOT_EDR_ACL_SUPPORTED(p_features))
+ btm_cb.btm_acl_pkt_types_supported |= (BTM_ACL_PKT_TYPES_MASK_NO_2_DH3 +
+ BTM_ACL_PKT_TYPES_MASK_NO_3_DH3);
- /* If this is re-read of the 1-st extended page after host supported LMP features are set */
- if ((page_number == HCI_EXT_FEATURES_PAGE_1) &&
- (btm_cb.devcb.lmp_features_host_may_support == BTM_RE_READ_1ST_PAGE))
- {
- btm_cb.devcb.lmp_features_host_may_support &= ~BTM_RE_READ_1ST_PAGE;
- btm_issue_host_support_for_lmp_features();
- return;
- }
+ if (!HCI_5_SLOT_EDR_ACL_SUPPORTED(p_features))
+ btm_cb.btm_acl_pkt_types_supported |= (BTM_ACL_PKT_TYPES_MASK_NO_2_DH5 +
+ BTM_ACL_PKT_TYPES_MASK_NO_3_DH5);
+ }
- /* If this is the last page supported by the local BT controller OR */
- /* if this is the last page supported by the Host */
- if ((page_number == page_number_max) ||
- (page_number == HCI_EXT_FEATURES_PAGE_MAX))
- {
- BTM_TRACE_DEBUG("BTM reached last extended features page (%d)", page_number);
- btm_read_all_lmp_features_complete(page_number);
- }
- /* Else (another page must be read) */
- else
- {
- /* Read the next features page */
- page_number++;
- BTM_TRACE_DEBUG("BTM reads next extended features page (%d)", page_number);
- btm_get_local_ext_features(page_number);
- }
-}
+ BTM_TRACE_DEBUG("Local supported ACL packet types: 0x%04x",
+ btm_cb.btm_acl_pkt_types_supported);
-/*******************************************************************************
-**
-** Function btm_read_local_supported_cmds_complete
-**
-** Description This function is called when local supported commands read
-** is complete.
-**
-** Returns void
-**
-*******************************************************************************/
-void btm_read_local_supported_cmds_complete (UINT8 *p)
-{
- tBTM_DEVCB *p_devcb = &btm_cb.devcb;
- UINT8 status;
+ /* Create (e)SCO supported packet types mask */
+ btm_cb.btm_sco_pkt_types_supported = 0;
+#if BTM_SCO_INCLUDED == TRUE
+ btm_cb.sco_cb.esco_supported = FALSE;
+#endif
+ if (HCI_SCO_LINK_SUPPORTED(p_features))
+ {
+ btm_cb.btm_sco_pkt_types_supported = BTM_SCO_PKT_TYPES_MASK_HV1;
- btu_stop_timer (&(p_devcb->reset_timer));
+ if (HCI_HV2_PACKETS_SUPPORTED(p_features))
+ btm_cb.btm_sco_pkt_types_supported |= BTM_SCO_PKT_TYPES_MASK_HV2;
- STREAM_TO_UINT8 (status, p);
- BTM_TRACE_DEBUG("btm_read_local_supported_cmds_complete status (0x%02x)", status);
+ if (HCI_HV3_PACKETS_SUPPORTED(p_features))
+ btm_cb.btm_sco_pkt_types_supported |= BTM_SCO_PKT_TYPES_MASK_HV3;
+ }
- if (status == HCI_SUCCESS)
- {
- /* Save the supported commands bit mask */
- STREAM_TO_ARRAY(p_devcb->supported_cmds, p, HCI_NUM_SUPP_COMMANDS_BYTES);
- }
+ if (HCI_ESCO_EV3_SUPPORTED(p_features))
+ btm_cb.btm_sco_pkt_types_supported |= BTM_SCO_PKT_TYPES_MASK_EV3;
- btm_get_local_features();
-}
+ if (HCI_ESCO_EV4_SUPPORTED(p_features))
+ btm_cb.btm_sco_pkt_types_supported |= BTM_SCO_PKT_TYPES_MASK_EV4;
-/*******************************************************************************
-**
-** Function btm_write_simple_paring_mode_complete
-**
-** Description This function is called when the command complete message
-** is received from the HCI for the write simple pairing mode
-** command.
-**
-** Returns void
-**
-*******************************************************************************/
-void btm_write_simple_paring_mode_complete (UINT8 *p)
-{
- UINT8 status;
+ if (HCI_ESCO_EV5_SUPPORTED(p_features))
+ btm_cb.btm_sco_pkt_types_supported |= BTM_SCO_PKT_TYPES_MASK_EV5;
+#if BTM_SCO_INCLUDED == TRUE
+ if (btm_cb.btm_sco_pkt_types_supported & BTM_ESCO_LINK_ONLY_MASK)
+ {
+ btm_cb.sco_cb.esco_supported = TRUE;
+
+ /* Add in EDR related eSCO types */
+ if (HCI_EDR_ESCO_2MPS_SUPPORTED(p_features))
+ {
+ if (!HCI_3_SLOT_EDR_ESCO_SUPPORTED(p_features))
+ btm_cb.btm_sco_pkt_types_supported |= BTM_SCO_PKT_TYPES_MASK_NO_2_EV5;
+ }
+ else
+ {
+ btm_cb.btm_sco_pkt_types_supported |= (BTM_SCO_PKT_TYPES_MASK_NO_2_EV3 +
+ BTM_SCO_PKT_TYPES_MASK_NO_2_EV5);
+ }
- STREAM_TO_UINT8 (status, p);
+ if (HCI_EDR_ESCO_3MPS_SUPPORTED(p_features))
+ {
+ if (!HCI_3_SLOT_EDR_ESCO_SUPPORTED(p_features))
+ btm_cb.btm_sco_pkt_types_supported |= BTM_SCO_PKT_TYPES_MASK_NO_3_EV5;
+ }
+ else
+ {
+ btm_cb.btm_sco_pkt_types_supported |= (BTM_SCO_PKT_TYPES_MASK_NO_3_EV3 +
+ BTM_SCO_PKT_TYPES_MASK_NO_3_EV5);
+ }
+ }
+#endif
- if (status != HCI_SUCCESS)
- {
- BTM_TRACE_WARNING("btm_write_simple_paring_mode_complete status: 0x%02x", status);
- }
+ BTM_TRACE_DEBUG("Local supported SCO packet types: 0x%04x",
+ btm_cb.btm_sco_pkt_types_supported);
- if (btm_cb.devcb.lmp_features_host_may_support & BTM_HOST_MAY_SUPP_SSP)
- {
- btm_cb.devcb.lmp_features_host_may_support &= ~BTM_HOST_MAY_SUPP_SSP;
- btm_issue_host_support_for_lmp_features();
- }
-}
+ /* Create Default Policy Settings */
+ if (HCI_SWITCH_SUPPORTED(p_features))
+ btm_cb.btm_def_link_policy |= HCI_ENABLE_MASTER_SLAVE_SWITCH;
+ else
+ btm_cb.btm_def_link_policy &= ~HCI_ENABLE_MASTER_SLAVE_SWITCH;
-/*******************************************************************************
-**
-** Function btm_write_le_host_supported_complete
-**
-** Description This function is called when the command complete message
-** is received from the HCI for the write LE host supported
-** command.
-**
-** Returns void
-**
-*******************************************************************************/
-void btm_write_le_host_supported_complete (UINT8 *p)
-{
- UINT8 status;
+ if (HCI_HOLD_MODE_SUPPORTED(p_features))
+ btm_cb.btm_def_link_policy |= HCI_ENABLE_HOLD_MODE;
+ else
+ btm_cb.btm_def_link_policy &= ~HCI_ENABLE_HOLD_MODE;
- STREAM_TO_UINT8 (status, p);
+ if (HCI_SNIFF_MODE_SUPPORTED(p_features))
+ btm_cb.btm_def_link_policy |= HCI_ENABLE_SNIFF_MODE;
+ else
+ btm_cb.btm_def_link_policy &= ~HCI_ENABLE_SNIFF_MODE;
- if (status != HCI_SUCCESS)
- {
- BTM_TRACE_WARNING("btm_write_le_host_supported_complete status: 0x%02x", status);
- }
+ if (HCI_PARK_MODE_SUPPORTED(p_features))
+ btm_cb.btm_def_link_policy |= HCI_ENABLE_PARK_MODE;
+ else
+ btm_cb.btm_def_link_policy &= ~HCI_ENABLE_PARK_MODE;
- if (btm_cb.devcb.lmp_features_host_may_support & BTM_HOST_MAY_SUPP_LE)
- {
- btm_cb.devcb.lmp_features_host_may_support &= ~BTM_HOST_MAY_SUPP_LE;
- if (btm_cb.devcb.lmp_features_host_may_support & BTM_HOST_MAY_SUPP_SIMULT_BR_LE)
+ btm_sec_dev_reset ();
+#if ((BTM_EIR_SERVER_INCLUDED == TRUE)||(BTM_EIR_CLIENT_INCLUDED == TRUE))
+ if (HCI_LMP_INQ_RSSI_SUPPORTED(p_features))
{
- btm_cb.devcb.lmp_features_host_may_support &= ~BTM_HOST_MAY_SUPP_SIMULT_BR_LE;
+ if (HCI_EXT_INQ_RSP_SUPPORTED(p_features))
+ BTM_SetInquiryMode (BTM_INQ_RESULT_EXTENDED);
+ else
+ BTM_SetInquiryMode (BTM_INQ_RESULT_WITH_RSSI);
}
- btm_issue_host_support_for_lmp_features();
- }
-}
+#else
+ if (HCI_LMP_INQ_RSSI_SUPPORTED(p_features))
+ BTM_SetInquiryMode (BTM_INQ_RESULT_WITH_RSSI);
+#endif
+#if L2CAP_NON_FLUSHABLE_PB_INCLUDED == TRUE
+ if( HCI_NON_FLUSHABLE_PB_SUPPORTED(p_features))
+ l2cu_set_non_flushable_pbf(TRUE);
+ else
+ l2cu_set_non_flushable_pbf(FALSE);
+#endif
+ BTM_SetPageScanType (BTM_DEFAULT_SCAN_TYPE);
+ BTM_SetInquiryScanType (BTM_DEFAULT_SCAN_TYPE);
-/*******************************************************************************
-**
-** Function btm_get_voice_coding_support
-**
-** Description This function is provides a way to get the voice coding schemes
-** supported the device.
-**
-** Returns A bit mask - Bit 0 if set indicates CVSD support
-** Bit 1 if set indicates PCM A-law support
-** Bit 2 if set indicates PCM Mu-law support
-**
-*******************************************************************************/
+ break;
-UINT8 btm_get_voice_coding_support( void )
-{
- UINT8 code = 0;
+ /* Extended Page 1 */
+ case HCI_EXT_FEATURES_PAGE_1:
+ /* Nothing to do for page 1 */
+ break;
- if( HCI_LMP_CVSD_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_0]) ) code |= 0x01 ;
- if( HCI_LMP_A_LAW_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_0]) ) code |= 0x02 ;
- if( HCI_LMP_U_LAW_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_0]) ) code |= 0x04 ;
+ /* Extended Page 2 */
+ case HCI_EXT_FEATURES_PAGE_2:
+ /* Nothing to do for page 2 */
+ break;
- return code ;
+ default:
+ BTM_TRACE_ERROR("btm_decode_ext_features_page page=%d unknown", page_number);
+ break;
+ }
}
/*******************************************************************************
if (!p_name || !p_name[0] || (strlen ((char *)p_name) > BD_NAME_LEN))
return (BTM_ILLEGAL_VALUE);
- if (btm_cb.devcb.state == BTM_DEV_STATE_WAIT_RESET_CMPLT ||
- btm_cb.devcb.state == BTM_DEV_STATE_WAIT_AFTER_RESET)
+ if (!controller_get_interface()->get_is_ready())
return (BTM_DEV_RESET);
#if BTM_MAX_LOC_BD_NAME_LEN > 0
}
}
-
+// TODO(zachoverflow):
+// These two functions do pretty much the same thing...just what is this I can't even whyyy
/*******************************************************************************
**
** Function BTM_GetLocalDeviceAddr
*******************************************************************************/
void BTM_GetLocalDeviceAddr (BD_ADDR bd_addr)
{
- memcpy (bd_addr, btm_cb.devcb.local_addr, BD_ADDR_LEN);
+ memcpy (bd_addr, controller_get_interface()->get_address(), BD_ADDR_LEN);
}
/*******************************************************************************
tBTM_STATUS BTM_ReadLocalDeviceAddr (tBTM_CMPL_CB *p_cb)
{
if(p_cb)
- (*p_cb)(btm_cb.devcb.local_addr);
+ (*p_cb)((void *)controller_get_interface()->get_address());
return (BTM_SUCCESS);
}
-
-/*******************************************************************************
-**
-** Function btm_read_local_addr_complete
-**
-** Description This function is called when local BD Addr read complete
-** message is received from the HCI.
-**
-** Returns void
-**
-*******************************************************************************/
-void btm_read_local_addr_complete (UINT8 *p, UINT16 evt_len)
-{
- UINT8 status;
- UNUSED(evt_len);
-
- STREAM_TO_UINT8 (status, p);
-
- if (status == HCI_SUCCESS)
- {
- STREAM_TO_BDADDR (btm_cb.devcb.local_addr, p);
- }
-}
-
/*******************************************************************************
**
** Function BTM_SetDeviceClass
memcpy (btm_cb.devcb.dev_class, dev_class, DEV_CLASS_LEN);
- if (btm_cb.devcb.state == BTM_DEV_STATE_WAIT_RESET_CMPLT ||
- btm_cb.devcb.state == BTM_DEV_STATE_WAIT_AFTER_RESET)
+ if (!controller_get_interface()->get_is_ready())
return (BTM_DEV_RESET);
if (!btsnd_hcic_write_dev_class (dev_class))
** Returns pointer to the local features string
**
*******************************************************************************/
+// TODO(zachoverflow): get rid of this function
UINT8 *BTM_ReadLocalFeatures (void)
{
- return (btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_0]);
-}
-
-/*******************************************************************************
-**
-** Function BTM_ReadLocalExtendedFeatures
-**
-** Description This function is called to read the local extended features
-**
-** Returns pointer to the local extended features mask or NULL if bad
-** page
-**
-*******************************************************************************/
-UINT8 *BTM_ReadLocalExtendedFeatures (UINT8 page_number)
-{
- if (page_number <= HCI_EXT_FEATURES_PAGE_MAX)
- return (btm_cb.devcb.local_lmp_features[page_number]);
-
- BTM_TRACE_ERROR("Warning: BTM_ReadLocalExtendedFeatures page %d unknown",
- page_number);
- return NULL;
+ // Discarding const modifier for now, until this function dies
+ return (UINT8 *)controller_get_interface()->get_features_classic(0)->as_array;
}
/*******************************************************************************
}
/* mask off all of event from controller */
- if (!btsnd_hcic_set_event_mask(LOCAL_BR_EDR_CONTROLLER_ID,
- (UINT8 *)"\x00\x00\x00\x00\x00\x00\x00\x00"))
- {
- return BTM_NO_RESOURCES;
- }
+ hci_layer_get_interface()->transmit_command(
+ hci_packet_factory_get_interface()->make_set_event_mask((const bt_event_mask_t *)(&"\x00\x00\x00\x00\x00\x00\x00\x00")),
+ NULL,
+ NULL,
+ NULL);
/* Send the HCI command */
if (btsnd_hcic_enable_test_mode ())
#include <stddef.h>
#include "bt_types.h"
+#include "controller.h"
#include "gki.h"
#include "hcimsgs.h"
#include "btu.h"
BTM_TRACE_API ("BTM_SetDiscoverability");
#if (BLE_INCLUDED == TRUE && BLE_INCLUDED == TRUE)
- if (HCI_LE_HOST_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_1]))
+ if (controller_get_interface()->supports_ble())
{
if (btm_ble_set_discoverability((UINT16)(inq_mode))
== BTM_SUCCESS)
return (BTM_ILLEGAL_VALUE);
/* Make sure the controller is active */
- if (btm_cb.devcb.state < BTM_DEV_STATE_READY)
+ if (!controller_get_interface()->get_is_ready())
return (BTM_DEV_RESET);
/* If the window and/or interval is '0', set to default values */
return (BTM_ILLEGAL_VALUE);
/* whatever app wants if device is not 1.2 scan type should be STANDARD */
- if (!HCI_LMP_INTERLACED_INQ_SCAN_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_0]))
+ if (!controller_get_interface()->supports_interlaced_inquiry_scan())
return (BTM_MODE_UNSUPPORTED);
/* Check for scan type if configuration has been changed */
return (BTM_ILLEGAL_VALUE);
/* whatever app wants if device is not 1.2 scan type should be STANDARD */
- if (!HCI_LMP_INTERLACED_PAGE_SCAN_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_0]))
+ if (!controller_get_interface()->supports_interlaced_inquiry_scan())
return (BTM_MODE_UNSUPPORTED);
/* Check for scan type if configuration has been changed */
*******************************************************************************/
tBTM_STATUS BTM_SetInquiryMode (UINT8 mode)
{
+ const controller_t *controller = controller_get_interface();
BTM_TRACE_API ("BTM_SetInquiryMode");
if (mode == BTM_INQ_RESULT_STANDARD)
{
}
else if (mode == BTM_INQ_RESULT_WITH_RSSI)
{
- if (!HCI_LMP_INQ_RSSI_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_0]))
- return (BTM_MODE_UNSUPPORTED);
+ if (!controller->supports_rssi_with_inquiry_results())
+ return (BTM_MODE_UNSUPPORTED);
}
#if (( BTM_EIR_CLIENT_INCLUDED == TRUE )||( BTM_EIR_SERVER_INCLUDED == TRUE ))
else if (mode == BTM_INQ_RESULT_EXTENDED)
{
- if (!HCI_EXT_INQ_RSP_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_0]))
+ if (!controller->supports_extended_inquiry_response())
return (BTM_MODE_UNSUPPORTED);
}
#endif
BTM_TRACE_API ("BTM_SetConnectability");
#if (BLE_INCLUDED == TRUE && BLE_INCLUDED == TRUE)
- if (HCI_LE_HOST_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_1]))
+ if (controller_get_interface()->supports_ble())
{
if (btm_ble_set_connectability(page_mode) != BTM_SUCCESS)
{
return (BTM_ILLEGAL_VALUE);
/* Make sure the controller is active */
- if (btm_cb.devcb.state < BTM_DEV_STATE_READY)
+ if (!controller_get_interface()->get_is_ready())
return (BTM_DEV_RESET);
/* If the window and/or interval is '0', set to default values */
BTM_TRACE_API("BTM:Starting LE Scan with duration %d and activeMode:0x%02x",
p_inqparms->duration, (p_inqparms->mode & BTM_BLE_INQUIRY_MASK));
#endif
- if (!HCI_LE_HOST_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_1]))
+ if (!controller_get_interface()->supports_ble())
{
p_inq->inqparms.mode &= ~ BTM_BLE_INQUIRY_MASK;
status = BTM_ILLEGAL_VALUE;
btm_clr_inq_result_flt();
if((p_inq->inq_cmpl_info.status == BTM_SUCCESS) &&
- HCI_LMP_INQ_RSSI_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_0]))
+ controller_get_interface()->supports_rssi_with_inquiry_results())
{
btm_sort_inq_result();
}
tBTM_STATUS BTM_WriteEIR( BT_HDR *p_buff )
{
#if (BTM_EIR_SERVER_INCLUDED == TRUE)
- if (HCI_EXT_INQ_RSP_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_0]))
+ if (controller_get_interface()->supports_extended_inquiry_response())
{
BTM_TRACE_API("Write Extended Inquiry Response to controller");
btsnd_hcic_write_ext_inquiry_response (p_buff, BTM_EIR_DEFAULT_FEC_REQUIRED);
HCI_PKT_TYPES_MASK_NO_3_DH5)
#define BTM_EPR_AVAILABLE(p) ((HCI_ATOMIC_ENCRYPT_SUPPORTED((p)->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0]) && \
- HCI_ATOMIC_ENCRYPT_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_0])) \
+ HCI_ATOMIC_ENCRYPT_SUPPORTED(controller_get_interface()->get_features_classic(0)->as_array)) \
? TRUE : FALSE)
-#define BTM_IS_BRCM_CONTROLLER() (btm_cb.devcb.local_version.manufacturer == LMP_COMPID_BROADCOM)
+#define BTM_IS_BRCM_CONTROLLER() (controller_get_interface()->get_bt_version()->manufacturer == LMP_COMPID_BROADCOM)
/* Define the ACL Management control structure
*/
tBTM_CMPL_CB *p_stored_link_key_cmpl_cb; /* Read/Write/Delete stored link key */
TIMER_LIST_ENT reset_timer;
- tBTM_CMPL_CB *p_reset_cmpl_cb; /* Callback function to be called */
- /* when startup of the device is done */
+
TIMER_LIST_ENT rln_timer;
tBTM_CMPL_CB *p_rln_cmpl_cb; /* Callback function to be called when */
/* read local name function complete */
TIMER_LIST_ENT tx_power_timer;
tBTM_CMPL_CB *p_tx_power_cmpl_cb;/* Callback function to be called */
- BD_ADDR local_addr; /* BD_ADDR of the local device */
- tBTM_VERSION_INFO local_version; /* Local Version Information */
DEV_CLASS dev_class; /* Local device class */
- /* Local LMP Extended features mask table for the device */
- BD_FEATURES local_lmp_features[HCI_EXT_FEATURES_PAGE_MAX + 1];
-
#if BLE_INCLUDED == TRUE
tBTM_CMPL_CB *p_le_test_cmd_cmpl_cb; /* Callback function to be called when
LE test mode command has been sent successfully */
BD_ADDR read_tx_pwr_addr; /* read TX power target address */
- BD_FEATURES local_le_features; /* Local LE Supported features mask for the device */
tBTM_BLE_LOCAL_ID_KEYS id_keys; /* local BLE ID keys */
BT_OCTET16 er; /* BLE encryption key */
#endif /* BLE_INCLUDED */
-#define BTM_DEV_STATE_WAIT_RESET_CMPLT 0
-#define BTM_DEV_STATE_WAIT_AFTER_RESET 1
-#define BTM_DEV_STATE_READY 2
-
- UINT8 state;
tBTM_IO_CAP loc_io_caps; /* IO capability of the local device */
tBTM_AUTH_REQ loc_auth_req; /* the auth_req flag */
-#define BTM_RELOAD_LE_HOST_FEATURE 0x10
-
-#define BTM_RE_READ_1ST_PAGE 0x01 /* Set it if you set at least one of "..._HOST_MAY_SUPP_..." bits */
-#define BTM_HOST_MAY_SUPP_SSP 0x02
-#define BTM_HOST_MAY_SUPP_LE 0x04
-#define BTM_HOST_MAY_SUPP_SIMULT_BR_LE 0x08
- UINT8 lmp_features_host_may_support; /* The flags of LMP features host may support via BR/EDR ctrlr + BTM_RE_READ_1ST_PAGE */
- UINT8 supported_cmds[HCI_NUM_SUPP_COMMANDS_BYTES]; /* Supported Commands bit field */
-
} tBTM_DEVCB;
**********************************************
*/
extern void btm_dev_init (void);
-extern void btm_dev_absent (void);
extern void btm_dev_timeout (TIMER_LIST_ENT *p_tle);
-extern void btm_reset_complete (void);
-extern void btm_read_local_version_complete (UINT8 *p, UINT16 evt_len);
-extern void btm_read_hci_buf_size_complete (UINT8 *p, UINT16 evt_len);
-extern void btm_read_local_supported_cmds_complete (UINT8 *p);
-extern void btm_read_local_features_complete (UINT8 *p, UINT16 evt_len);
-extern void btm_read_local_ext_features_complete (UINT8 *p, UINT16 evt_len);
extern void btm_read_local_name_complete (UINT8 *p, UINT16 evt_len);
-extern void btm_read_local_addr_complete (UINT8 *p, UINT16 evt_len);
-extern void btm_reset_ctrlr_complete (void);
-extern void btm_write_simple_paring_mode_complete (UINT8 *p);
-extern void btm_write_le_host_supported_complete (UINT8 *p);
#if (BLE_INCLUDED == TRUE)
-extern void btm_read_ble_buf_size_complete (UINT8 *p, UINT16 evt_len);
-extern void btm_read_ble_local_supported_features_complete (UINT8 *p, UINT16 evt_len);
-extern void btm_read_white_list_size_complete(UINT8 *p, UINT16 evt_len);
extern void btm_ble_add_2_white_list_complete(UINT8 status);
extern void btm_ble_remove_from_white_list_complete(UINT8 *p, UINT16 evt_len);
extern void btm_ble_clear_white_list_complete(UINT8 *p, UINT16 evt_len);
**********************************************
*/
extern BOOLEAN btm_dev_support_switch (BD_ADDR bd_addr);
-extern UINT8 btm_get_voice_coding_support (void);
extern tBTM_SEC_DEV_REC *btm_sec_alloc_dev (BD_ADDR bd_addr);
extern void btm_sec_free_dev (tBTM_SEC_DEV_REC *p_dev_rec);
******************************************************************************/
#include <string.h>
+
#include "bt_types.h"
+#include "controller.h"
#include "hcimsgs.h"
#include "btu.h"
#include "btm_int.h"
/* If device is not up security mode will be set as a part of startup */
if ( (btm_cb.cfg.pin_type != pin_type)
- && (btm_cb.devcb.state > BTM_DEV_STATE_WAIT_AFTER_RESET) )
+ && controller_get_interface()->get_is_ready() )
{
btsnd_hcic_write_pin_type (pin_type);
}
BTM_TRACE_DEBUG ("after update sec_flags=0x%x", p_dev_rec->sec_flags);
- if (!HCI_SIMPLE_PAIRING_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_0]))
+ if (!controller_get_interface()->supports_simple_pairing())
{
/* The special case when we authenticate keyboard. Set pin type to fixed */
/* It would be probably better to do it from the application, but it is */
}
BTM_TRACE_DEBUG ("sec mode: %d sm4:x%x", btm_cb.security_mode, p_dev_rec->sm4);
- if (!HCI_SIMPLE_PAIRING_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_0])
+ if (!controller_get_interface()->supports_simple_pairing()
|| (p_dev_rec->sm4 == BTM_SM4_KNOWN))
{
if ( btm_sec_check_prefetch_pin (p_dev_rec) )
{
/* add mandatory part */
UINT16_TO_STREAM(p, len);
- BDADDR_TO_STREAM(p, btm_cb.devcb.local_addr);
+ BDADDR_TO_STREAM(p, controller_get_interface()->get_address()->address);
len = BTM_OOB_MANDATORY_SIZE;
max_len -= len;
tBTM_SEC_DEV_REC *p_dev_rec = btm_find_dev (bda);
/* Some device may request a connection before we are done with the HCI_Reset sequence */
- if (btm_cb.devcb.state != BTM_DEV_STATE_READY)
+ if (!controller_get_interface()->get_is_ready())
{
BTM_TRACE_EVENT ("Security Manager: connect request when device not ready");
btsnd_hcic_reject_conn (bda, HCI_ERR_HOST_REJECT_DEVICE);
*******************************************************************************/
void btm_sec_dev_reset (void)
{
- /* btm_sec_dev_reset() is only called from btm_decode_ext_features_page(...)
- * right now. */
- if (HCI_SIMPLE_PAIRING_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_0]))
+ if (controller_get_interface()->supports_simple_pairing())
{
-#if BLE_INCLUDED == TRUE
- btsnd_hcic_set_event_mask(LOCAL_BR_EDR_CONTROLLER_ID,
- (UINT8 *)HCI_DUMO_EVENT_MASK_EXT);
-#else
- btsnd_hcic_set_event_mask(LOCAL_BR_EDR_CONTROLLER_ID,
- (UINT8 *)HCI_LISBON_EVENT_MASK_EXT);
-#endif
/* set the default IO capabilities */
btm_cb.devcb.loc_io_caps = BTM_LOCAL_IO_CAPS;
/* add mx service to use no security */
*
******************************************************************************/
+#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
{
switch (opcode)
{
- case HCI_RESET:
- btm_reset_complete (); /* BR/EDR */
- break;
-
case HCI_INQUIRY_CANCEL:
/* Tell inquiry processing that we are done */
btm_process_cancel_complete(HCI_SUCCESS, BTM_BR_INQUIRY_MASK);
btm_delete_stored_link_key_complete (p);
break;
- case HCI_READ_LOCAL_VERSION_INFO:
- btm_read_local_version_complete (p, evt_len);
- break;
-
case HCI_READ_POLICY_SETTINGS:
btm_read_link_policy_complete (p);
break;
- case HCI_READ_BUFFER_SIZE:
- btm_read_hci_buf_size_complete (p, evt_len);
- break;
-
- case HCI_READ_LOCAL_SUPPORTED_CMDS:
- btm_read_local_supported_cmds_complete (p);
- break;
-
- case HCI_READ_LOCAL_FEATURES:
- btm_read_local_features_complete (p, evt_len);
- break;
-
- case HCI_READ_LOCAL_EXT_FEATURES:
- btm_read_local_ext_features_complete (p, evt_len);
- break;
-
case HCI_READ_LOCAL_NAME:
btm_read_local_name_complete (p, evt_len);
break;
- case HCI_READ_BD_ADDR:
- btm_read_local_addr_complete (p, evt_len);
- break;
-
case HCI_GET_LINK_QUALITY:
btm_read_link_quality_complete (p);
break;
btm_read_linq_tx_power_complete (p);
break;
- case HCI_WRITE_SIMPLE_PAIRING_MODE:
- btm_write_simple_paring_mode_complete (p);
- break;
-
- case HCI_WRITE_LE_HOST_SUPPORTED:
- btm_write_le_host_supported_complete (p);
- break;
-
#if (BLE_INCLUDED == TRUE)
/* BLE Commands sComplete*/
- case HCI_BLE_READ_WHITE_LIST_SIZE :
- btm_read_white_list_size_complete(p, evt_len);
- break;
-
case HCI_BLE_ADD_WHITE_LIST:
btm_ble_add_2_white_list_complete(*p);
break;
btm_ble_rand_enc_complete (p, opcode, (tBTM_RAND_ENC_CB *)p_cplt_cback);
break;
- case HCI_BLE_READ_BUFFER_SIZE:
- btm_read_ble_buf_size_complete(p, evt_len);
- break;
-
- case HCI_BLE_READ_LOCAL_SPT_FEAT:
- btm_read_ble_local_supported_features_complete(p, evt_len);
- break;
-
case HCI_BLE_READ_ADV_CHNL_TX_POWER:
btm_read_tx_power_complete(p, TRUE);
break;
btm_ble_write_adv_enable_complete(p);
break;
- case HCI_BLE_READ_SUPPORTED_STATES:
- btm_read_ble_local_supported_states_complete(p, evt_len);
- break;
-
case HCI_BLE_CREATE_LL_CONN:
btm_ble_create_ll_conn_complete(*p);
break;
#include "dyn_mem.h"
#include "alarm.h"
+#include "controller.h"
#include "fixed_queue.h"
#include "hash_functions.h"
#include "hash_map.h"
void BTU_StartUp(void)
{
memset (&btu_cb, 0, sizeof (tBTU_CB));
- btu_cb.hcit_acl_pkt_size = BTU_DEFAULT_DATA_SIZE + HCI_DATA_PREAMBLE_SIZE;
-#if (BLE_INCLUDED == TRUE)
- btu_cb.hcit_ble_acl_pkt_size = BTU_DEFAULT_BLE_DATA_SIZE + HCI_DATA_PREAMBLE_SIZE;
-#endif
btu_cb.trace_level = HCI_INITIAL_TRACE_LEVEL;
btu_bta_msg_queue = fixed_queue_new(SIZE_MAX);
******************************************************************************/
UINT16 BTU_AclPktSize(void)
{
- return btu_cb.hcit_acl_pkt_size;
+ return controller_get_interface()->get_acl_packet_size_classic();
}
/*****************************************************************************
**
UINT16 BTU_BleAclPktSize(void)
{
#if BLE_INCLUDED == TRUE
- return btu_cb.hcit_ble_acl_pkt_size;
+ return controller_get_interface()->get_acl_packet_size_ble();
#else
return 0;
#endif
#if (defined BLE_INCLUDED) && (BLE_INCLUDED == TRUE)
-BOOLEAN btsnd_hcic_ble_set_evt_mask (BT_EVENT_MASK event_mask)
-{
- BT_HDR *p;
- UINT8 *pp;
-
- if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_SET_EVENT_MASK)) == NULL)
- return (FALSE);
-
- pp = (UINT8 *)(p + 1);
-
- p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_SET_EVENT_MASK;
- p->offset = 0;
-
- UINT16_TO_STREAM (pp, HCI_BLE_SET_EVENT_MASK);
- UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_SET_EVENT_MASK);
- ARRAY8_TO_STREAM (pp, event_mask);
-
- btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
- return (TRUE);
-}
-
-
-BOOLEAN btsnd_hcic_ble_read_buffer_size (void)
-{
- BT_HDR *p;
- UINT8 *pp;
-
- if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL)
- return (FALSE);
-
- pp = (UINT8 *)(p + 1);
-
- p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
- p->offset = 0;
-
- UINT16_TO_STREAM (pp, HCI_BLE_READ_BUFFER_SIZE);
- UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
-
- btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
- return (TRUE);
-}
-
-BOOLEAN btsnd_hcic_ble_read_local_spt_feat (void)
-{
- BT_HDR *p;
- UINT8 *pp;
-
- if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL)
- return (FALSE);
-
- pp = (UINT8 *)(p + 1);
-
- p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
- p->offset = 0;
-
- UINT16_TO_STREAM (pp, HCI_BLE_READ_LOCAL_SPT_FEAT);
- UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
-
- btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
- return (TRUE);
-}
-
BOOLEAN btsnd_hcic_ble_set_local_used_feat (UINT8 feat_set[8])
{
BT_HDR *p;
return (TRUE);
}
-BOOLEAN btsnd_hcic_ble_read_white_list_size (void)
-{
- BT_HDR *p;
- UINT8 *pp;
-
- if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL)
- return (FALSE);
-
- pp = (UINT8 *)(p + 1);
-
- p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
- p->offset = 0;
-
- UINT16_TO_STREAM (pp, HCI_BLE_READ_WHITE_LIST_SIZE);
- UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
-
- btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
- return (TRUE);
-}
-
BOOLEAN btsnd_hcic_ble_clear_white_list (void)
{
BT_HDR *p;
return (TRUE);
}
-BOOLEAN btsnd_hcic_ble_read_supported_states (void)
-{
- BT_HDR *p;
- UINT8 *pp;
-
- if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL)
- return (FALSE);
-
- pp = (UINT8 *)(p + 1);
-
- p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
- p->offset = 0;
-
- UINT16_TO_STREAM (pp, HCI_BLE_READ_SUPPORTED_STATES);
- UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
-
- btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
- return (TRUE);
-}
-
BOOLEAN btsnd_hcic_ble_receiver_test(UINT8 rx_freq)
{
BT_HDR *p;
p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
p->offset = 0;
- UINT16_TO_STREAM (pp, HCI_READ_LE_HOST_SUPPORTED);
+ UINT16_TO_STREAM (pp, HCI_READ_LE_HOST_SUPPORT);
UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
return (TRUE);
}
-BOOLEAN btsnd_hcic_ble_write_host_supported (UINT8 le_host_spt, UINT8 simul_le_host_spt)
-{
- BT_HDR *p;
- UINT8 *pp;
-
- if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_LE_HOST_SUPPORTED)) == NULL)
- return (FALSE);
-
- pp = (UINT8 *)(p + 1);
-
- p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_LE_HOST_SUPPORTED;
- p->offset = 0;
-
- UINT16_TO_STREAM (pp, HCI_WRITE_LE_HOST_SUPPORTED);
- UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_LE_HOST_SUPPORTED);
- UINT8_TO_STREAM (pp, le_host_spt);
- UINT8_TO_STREAM (pp, simul_le_host_spt);
-
- btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
- return (TRUE);
-}
-
#if (defined BLE_LLT_INCLUDED) && (BLE_LLT_INCLUDED == TRUE)
BOOLEAN btsnd_hcic_ble_rc_param_req_reply( UINT16 handle,
return (TRUE);
}
-BOOLEAN btsnd_hcic_set_event_mask(UINT8 local_controller_id, BT_EVENT_MASK event_mask)
-{
- BT_HDR *p;
- UINT8 *pp;
-
- if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_SET_EVENT_MASK)) == NULL)
- return (FALSE);
-
- pp = (UINT8 *)(p + 1);
-
- p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_SET_EVENT_MASK;
- p->offset = 0;
-
- UINT16_TO_STREAM (pp, HCI_SET_EVENT_MASK);
- UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_SET_EVENT_MASK);
- ARRAY8_TO_STREAM (pp, event_mask);
-
- btu_hcif_send_cmd (local_controller_id, p);
- return (TRUE);
-}
-
BOOLEAN btsnd_hcic_set_event_mask_page_2 (UINT8 local_controller_id, BT_EVENT_MASK event_mask)
{
BT_HDR *p;
return (TRUE);
}
-BOOLEAN btsnd_hcic_reset (UINT8 local_controller_id)
-{
- BT_HDR *p;
- UINT8 *pp;
-
- if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_RESET)) == NULL)
- return (FALSE);
-
- pp = (UINT8 *)(p + 1);
-
- p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_RESET;
- p->offset = 0;
-
- UINT16_TO_STREAM (pp, HCI_RESET);
- UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_RESET);
-
- btu_hcif_send_cmd (local_controller_id, p);
-/* If calling from LMP_TEST or ScriptEngine, then send HCI command immediately */
-#if (!defined (LMP_TEST) && !defined(BTISE))
- if (local_controller_id == LOCAL_BR_EDR_CONTROLLER_ID)
- {
- btm_acl_reset_paging ();
- btm_acl_set_discing (FALSE);
- }
-#endif
- return (TRUE);
-}
-
BOOLEAN btsnd_hcic_set_event_filter (UINT8 filt_type, UINT8 filt_cond_type,
UINT8 *filt_cond, UINT8 filt_cond_len)
{
return (TRUE);
}
-BOOLEAN btsnd_hcic_set_host_buf_size (UINT16 acl_len, UINT8 sco_len,
- UINT16 acl_num, UINT16 sco_num)
-{
- BT_HDR *p;
- UINT8 *pp;
-
- if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_SET_HOST_BUF_SIZE)) == NULL)
- return (FALSE);
-
- pp = (UINT8 *)(p + 1);
-
- p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_SET_HOST_BUF_SIZE;
- p->offset = 0;
-
- UINT16_TO_STREAM (pp, HCI_HOST_BUFFER_SIZE);
- UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_SET_HOST_BUF_SIZE);
-
- UINT16_TO_STREAM (pp, acl_len);
- UINT8_TO_STREAM (pp, sco_len);
- UINT16_TO_STREAM (pp, acl_num);
- UINT16_TO_STREAM (pp, sco_num);
-
- btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
- return (TRUE);
-}
-
BOOLEAN btsnd_hcic_host_num_xmitted_pkts (UINT8 num_handles, UINT16 *handle,
UINT16 *num_pkts)
{
}
#endif /* BTM_EIR_SERVER_INCLUDED == TRUE */
-/**** Simple Pairing Commands ****/
-BOOLEAN btsnd_hcic_write_simple_pairing_mode (UINT8 mode)
-{
- BT_HDR *p;
- UINT8 *pp;
-
- if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_W_SIMP_PAIR)) == NULL)
- return (FALSE);
-
- pp = (UINT8 *)(p + 1);
-
- p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_W_SIMP_PAIR;
- p->offset = 0;
-
- UINT16_TO_STREAM (pp, HCI_WRITE_SIMPLE_PAIRING_MODE);
- UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_W_SIMP_PAIR);
-
- UINT8_TO_STREAM (pp, mode);
-
- btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
- return (TRUE);
-}
-
BOOLEAN btsnd_hcic_read_simple_pairing_mode (void)
{
BT_HDR *p;
** End of Lisbon Commands
**************************/
-BOOLEAN btsnd_hcic_read_local_ver (UINT8 local_controller_id)
-{
- BT_HDR *p;
- UINT8 *pp;
-
- if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL)
- return (FALSE);
-
- pp = (UINT8 *)(p + 1);
-
- p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
- p->offset = 0;
-
- UINT16_TO_STREAM (pp, HCI_READ_LOCAL_VERSION_INFO);
- UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
-
- btu_hcif_send_cmd (local_controller_id, p);
- return (TRUE);
-}
-
-BOOLEAN btsnd_hcic_read_local_supported_cmds (UINT8 local_controller_id)
-{
- BT_HDR *p;
- UINT8 *pp;
-
- if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL)
- return (FALSE);
-
- pp = (UINT8 *)(p + 1);
-
- p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
- p->offset = 0;
-
- UINT16_TO_STREAM (pp, HCI_READ_LOCAL_SUPPORTED_CMDS);
- UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
-
- btu_hcif_send_cmd (local_controller_id, p);
- return (TRUE);
-}
-
-BOOLEAN btsnd_hcic_read_local_features (void)
-{
- BT_HDR *p;
- UINT8 *pp;
-
- if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL)
- return (FALSE);
-
- pp = (UINT8 *)(p + 1);
-
- p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
- p->offset = 0;
-
- UINT16_TO_STREAM (pp, HCI_READ_LOCAL_FEATURES);
- UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
-
- btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
- return (TRUE);
-}
-
-BOOLEAN btsnd_hcic_read_local_ext_features (UINT8 page_num)
-{
- BT_HDR *p;
- UINT8 *pp;
-
- if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_LOCAL_EXT_FEATURES)) == NULL)
- return (FALSE);
-
- pp = (UINT8 *)(p + 1);
-
- p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_LOCAL_EXT_FEATURES;
- p->offset = 0;
-
- UINT16_TO_STREAM (pp, HCI_READ_LOCAL_EXT_FEATURES);
- UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_LOCAL_EXT_FEATURES);
-
- UINT8_TO_STREAM (pp, page_num);
-
- btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
- return (TRUE);
-}
-
-BOOLEAN btsnd_hcic_read_buffer_size (void)
-{
- BT_HDR *p;
- UINT8 *pp;
-
- if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL)
- return (FALSE);
-
- pp = (UINT8 *)(p + 1);
-
- p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
- p->offset = 0;
-
- UINT16_TO_STREAM (pp, HCI_READ_BUFFER_SIZE);
- UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
-
- btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
- return (TRUE);
-}
-
BOOLEAN btsnd_hcic_read_country_code (void)
{
BT_HDR *p;
return (TRUE);
}
-BOOLEAN btsnd_hcic_read_bd_addr (void)
-{
- BT_HDR *p;
- UINT8 *pp;
-
- if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL)
- return (FALSE);
-
- pp = (UINT8 *)(p + 1);
-
- p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
- p->offset = 0;
-
- UINT16_TO_STREAM (pp, HCI_READ_BD_ADDR);
- UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
-
- btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
- return (TRUE);
-}
-
BOOLEAN btsnd_hcic_read_fail_contact_count (UINT8 local_controller_id, UINT16 handle)
{
BT_HDR *p;
/*******************************************************************************
**
-** Function BTM_ReadLocalExtendedFeatures
-**
-** Description This function is called to read the local extended features
-**
-** Returns pointer to the local extended features mask or NULL if bad
-** page
-**
-*******************************************************************************/
-extern UINT8 *BTM_ReadLocalExtendedFeatures (UINT8 page_number);
-
-/*******************************************************************************
-**
** Function BTM_RegisterForDeviceStatusNotif
**
** Description This function is called to register for device status
TIMER_LIST_ENT cmd_cmpl_timer; /* Command complete timer */
- UINT16 hcit_acl_data_size; /* Max ACL data size across HCI transport */
- UINT16 hcit_acl_pkt_size; /* Max ACL packet size across HCI transport */
- /* (this is data size plus 4 bytes overhead) */
-
-#if BLE_INCLUDED == TRUE
- UINT16 hcit_ble_acl_data_size; /* Max BLE ACL data size across HCI transport */
- UINT16 hcit_ble_acl_pkt_size; /* Max BLE ACL packet size across HCI transport */
- /* (this is data size plus 4 bytes overhead) */
-#endif
-
BOOLEAN reset_complete; /* TRUE after first ack from device received */
UINT8 trace_level; /* Trace level for HCI layer */
} tBTU_CB;
#define HCI_READ_BE_FLUSH_TOUT (0x0069 | HCI_GRP_HOST_CONT_BASEBAND_CMDS)
#define HCI_WRITE_BE_FLUSH_TOUT (0x006A | HCI_GRP_HOST_CONT_BASEBAND_CMDS)
#define HCI_SHORT_RANGE_MODE (0x006B | HCI_GRP_HOST_CONT_BASEBAND_CMDS) /* 802.11 only */
-#define HCI_READ_LE_HOST_SUPPORTED (0x006C | HCI_GRP_HOST_CONT_BASEBAND_CMDS)
-#define HCI_WRITE_LE_HOST_SUPPORTED (0x006D | HCI_GRP_HOST_CONT_BASEBAND_CMDS)
+#define HCI_READ_LE_HOST_SUPPORT (0x006C | HCI_GRP_HOST_CONT_BASEBAND_CMDS)
+#define HCI_WRITE_LE_HOST_SUPPORT (0x006D | HCI_GRP_HOST_CONT_BASEBAND_CMDS)
/* MWS coexistence */
/**** end of Simple Pairing Commands ****/
-
-extern BOOLEAN btsnd_hcic_set_event_mask(UINT8 local_controller_id, BT_EVENT_MASK evt_mask);
-
-#define HCIC_PARAM_SIZE_SET_EVENT_MASK 8
-#define HCI_EVENT_MASK_MASK_OFF 0
- /* Set Event Mask */
-
/* Reset */
extern BOOLEAN btsnd_hcic_set_event_mask_page_2 (UINT8 local_controller_id,
BT_EVENT_MASK event_mask);
#define HCI_EVENT_MASK_MASK_OFF 0
/* Set Event Mask Page 2 */
- /* Reset */
-extern BOOLEAN btsnd_hcic_reset(UINT8 local_controller_id);
-
-#define HCIC_PARAM_SIZE_RESET 0
- /* Reset */
-
/* Store Current Settings */
#define MAX_FILT_COND (sizeof (BD_ADDR) + 1)
extern BOOLEAN btsnd_hcic_read_local_ver (UINT8 local_controller_id); /* Read Local Version Info */
extern BOOLEAN btsnd_hcic_read_local_supported_cmds (UINT8 local_controller_id); /* Read Local Supported Commands */
extern BOOLEAN btsnd_hcic_read_local_features (void); /* Read Local Supported Features */
-extern BOOLEAN btsnd_hcic_read_buffer_size (void); /* Read Local buffer sizes */
extern BOOLEAN btsnd_hcic_read_country_code (void); /* Read Country Code */
extern BOOLEAN btsnd_hcic_read_bd_addr (void); /* Read Local BD_ADDR */
extern BOOLEAN btsnd_hcic_read_fail_contact_count (UINT8 local_controller_id, UINT16 handle); /* Read Failed Contact Counter */
#include "btu.h"
#include "btm_int.h"
#include "hcimsgs.h"
+#include "controller.h"
#if (BLE_INCLUDED == TRUE)
static void l2cble_start_conn_update (tL2C_LCB *p_lcb);
p_lcb->peer_chnl_mask[0] = L2CAP_FIXED_CHNL_ATT_BIT | L2CAP_FIXED_CHNL_BLE_SIG_BIT | L2CAP_FIXED_CHNL_SMP_BIT;
- if (!HCI_LE_SLAVE_INIT_FEAT_EXC_SUPPORTED(btm_cb.devcb.local_le_features))
+ if (!HCI_LE_SLAVE_INIT_FEAT_EXC_SUPPORTED(controller_get_interface()->get_features_ble()->as_array))
{
p_lcb->link_state = LST_CONNECTED;
l2cu_process_fixed_chnl_resp (p_lcb);
/* if both side 4.1, or we are master device, send HCI command */
if (p_lcb->link_role == HCI_ROLE_MASTER
#if (defined BLE_LLT_INCLUDED) && (BLE_LLT_INCLUDED == TRUE)
- || (HCI_LE_CONN_PARAM_REQ_SUPPORTED(btm_cb.devcb.local_le_features) &&
+ || (HCI_LE_CONN_PARAM_REQ_SUPPORTED(controller_get_interface()->get_features_ble()->as_array) &&
HCI_LE_CONN_PARAM_REQ_SUPPORTED(p_acl_cb->peer_le_features))
#endif
)
/* if both side 4.1, or we are master device, send HCI command */
if (p_lcb->link_role == HCI_ROLE_MASTER
#if (defined BLE_LLT_INCLUDED) && (BLE_LLT_INCLUDED == TRUE)
- || (HCI_LE_CONN_PARAM_REQ_SUPPORTED(btm_cb.devcb.local_le_features) &&
+ || (HCI_LE_CONN_PARAM_REQ_SUPPORTED(controller_get_interface()->get_features_ble()->as_array) &&
HCI_LE_CONN_PARAM_REQ_SUPPORTED(p_acl_cb->peer_le_features))
#endif
)
#include <string.h>
#include <stdio.h>
+#include "controller.h"
#include "gki.h"
#include "bt_types.h"
#include "bt_utils.h"
{
UINT16 num_segs;
UINT16 xmit_window, acl_data_size;
+ const controller_t *controller = controller_get_interface();
- if ((p_buf->len <= btu_cb.hcit_acl_pkt_size
+ if ((p_buf->len <= controller->get_acl_packet_size_classic()
#if (BLE_INCLUDED == TRUE)
&& (p_lcb->transport == BT_TRANSPORT_BR_EDR)) ||
- ((p_lcb->transport == BT_TRANSPORT_LE) && (p_buf->len <= btu_cb.hcit_ble_acl_pkt_size))
+ ((p_lcb->transport == BT_TRANSPORT_LE) && (p_buf->len <= controller->get_acl_packet_size_ble()))
#else
)
#endif
#if BLE_INCLUDED == TRUE
if (p_lcb->transport == BT_TRANSPORT_LE)
{
- acl_data_size = btu_cb.hcit_ble_acl_data_size;
+ acl_data_size = controller->get_acl_data_size_ble();
xmit_window = l2cb.controller_le_xmit_window;
}
else
#endif
{
- acl_data_size = btu_cb.hcit_acl_data_size;
+ acl_data_size = controller->get_acl_data_size_classic();
xmit_window = l2cb.controller_xmit_window;
}
num_segs = (p_buf->len - HCI_DATA_PREAMBLE_SIZE + acl_data_size - 1) / acl_data_size;
#include <string.h>
#include <stdio.h>
+#include "controller.h"
#include "gki.h"
#include "hcimsgs.h"
#include "l2cdefs.h"
/* First, the HCI transport header */
UINT16_TO_STREAM (p, 0x0050 | (L2CAP_PKT_START << 12) | (2 << 14));
+ uint16_t acl_data_size = controller_get_interface()->get_acl_data_size_classic();
/* The HCI transport will segment the buffers. */
- if (p_buf->len > btu_cb.hcit_acl_data_size)
+ if (p_buf->len > acl_data_size)
{
- UINT16_TO_STREAM (p, btu_cb.hcit_acl_data_size);
+ UINT16_TO_STREAM (p, acl_data_size);
}
else
{
p_buf->len += HCI_DATA_PREAMBLE_SIZE;
- if (p_buf->len <= btu_cb.hcit_acl_pkt_size)
+ if (p_buf->len <= controller_get_interface()->get_acl_packet_size_classic())
{
bte_main_hci_send(p_buf, BT_EVT_TO_LM_HCI_ACL);
}
#include <string.h>
#include <stdio.h>
+#include "controller.h"
#include "gki.h"
#include "bt_types.h"
#include "hcimsgs.h"
return;
}
+ uint16_t acl_data_size = controller_get_interface()->get_acl_data_size_classic();
+ uint16_t acl_packet_size = controller_get_interface()->get_acl_packet_size_classic();
/* Don't return data if it does not fit in ACL and L2CAP MTU */
- maxlen = (GKI_get_pool_bufsize(L2CAP_CMD_POOL_ID) > btu_cb.hcit_acl_pkt_size) ?
- btu_cb.hcit_acl_data_size : (UINT16)GKI_get_pool_bufsize(L2CAP_CMD_POOL_ID);
+ maxlen = (GKI_get_pool_bufsize(L2CAP_CMD_POOL_ID) > acl_packet_size) ?
+ acl_data_size : (UINT16)GKI_get_pool_bufsize(L2CAP_CMD_POOL_ID);
maxlen -= (UINT16)(BT_HDR_SIZE + HCI_DATA_PREAMBLE_SIZE + L2CAP_PKT_OVERHEAD +
L2CAP_CMD_OVERHEAD + L2CAP_ECHO_RSP_LEN);
if (transport == BT_TRANSPORT_LE)
{
- if (!HCI_LE_HOST_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_1]))
+ if (!controller_get_interface()->supports_ble())
return FALSE;
p_lcb->ble_addr_type = addr_type;
{
UINT16_TO_STREAM (p, p_ccb->p_lcb->handle | (L2CAP_PKT_START_NON_FLUSHABLE << L2CAP_PKT_TYPE_SHIFT));
+ uint16_t acl_data_size = controller_get_interface()->get_acl_data_size_ble();
/* The HCI transport will segment the buffers. */
- if (p_buf->len > btu_cb.hcit_ble_acl_data_size)
+ if (p_buf->len > acl_data_size)
{
- UINT16_TO_STREAM (p, btu_cb.hcit_ble_acl_data_size);
+ UINT16_TO_STREAM (p, acl_data_size);
}
else
{
UINT16_TO_STREAM (p, p_ccb->p_lcb->handle | (L2CAP_PKT_START << L2CAP_PKT_TYPE_SHIFT));
#endif
+ uint16_t acl_data_size = controller_get_interface()->get_acl_data_size_classic();
/* The HCI transport will segment the buffers. */
- if (p_buf->len > btu_cb.hcit_acl_data_size)
+ if (p_buf->len > acl_data_size)
{
- UINT16_TO_STREAM (p, btu_cb.hcit_acl_data_size);
+ UINT16_TO_STREAM (p, acl_data_size);
}
else
{
#include "vendor_ble.h"
#include "vendor_hcidefs.h"
#include "gatt_int.h"
+#include "controller.h"
/*** This needs to be moved to a VSC control block eventually per coding conventions ***/
#if VENDOR_DYNAMIC_MEMORY == FALSE
return BTM_MODE_UNSUPPORTED;
}
-
/*******************************************************************************
**
** Function btm_ble_vendor_init
btm_ble_vendor_cb.irk_avail_size = max_irk_list_sz;
- if (!HCI_LE_HOST_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_1]))
+ if (!controller_get_interface()->supports_ble())
return;
#endif
}
OSDN Git Service
