/******************************************************************************
*
* Copyright 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.
*
******************************************************************************/
#define LOG_TAG "bt_controller"
#include "device/include/controller.h"
#include <base/logging.h>
#include "bt_types.h"
#include "btcore/include/event_mask.h"
#include "btcore/include/module.h"
#include "btcore/include/version.h"
#include "hcimsgs.h"
#include "osi/include/future.h"
#include "stack/include/btm_ble_api.h"
const bt_event_mask_t BLE_EVENT_MASK = {{0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
#if (BLE_PRIVACY_SPT == TRUE)
0x1E,
#else
/* Disable "LE Enhanced Connection
Complete" when privacy is off */
0x1C,
#endif
0x7f}};
const bt_event_mask_t CLASSIC_EVENT_MASK = {HCI_DUMO_EVENT_MASK_EXT};
// 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
#define MAX_LOCAL_SUPPORTED_CODECS_SIZE 8
static const hci_t* hci;
static const hci_packet_factory_t* packet_factory;
static const hci_packet_parser_t* packet_parser;
static RawAddress 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_resolving_list_max_size;
static uint8_t ble_supported_states[BLE_SUPPORTED_STATES_SIZE];
static bt_device_features_t features_ble;
static uint16_t ble_suggested_default_data_length;
static uint16_t ble_supported_max_tx_octets;
static uint16_t ble_supported_max_tx_time;
static uint16_t ble_supported_max_rx_octets;
static uint16_t ble_supported_max_rx_time;
static uint16_t ble_maxium_advertising_data_length;
static uint8_t ble_number_of_supported_advertising_sets;
static uint8_t local_supported_codecs[MAX_LOCAL_SUPPORTED_CODECS_SIZE];
static uint8_t number_of_local_supported_codecs = 0;
static bool readable;
static bool ble_supported;
static bool simple_pairing_supported;
static bool secure_connections_supported;
#define AWAIT_COMMAND(command) \
static_cast<BT_HDR*>(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);
CHECK(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 (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);
// If we modified the BT_HOST_SUPPORT, we will need ext. feat. page 1
if (last_features_classic_page_index < 1)
last_features_classic_page_index = 1;
}
// 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(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);
page_number++;
}
#if (SC_MODE_INCLUDED == TRUE)
secure_connections_supported =
HCI_SC_CTRLR_SUPPORTED(features_classic[2].as_array);
if (secure_connections_supported) {
response = AWAIT_COMMAND(
packet_factory->make_write_secure_connections_host_support(
HCI_SC_MODE_ENABLED));
packet_parser->parse_generic_command_complete(response);
}
#endif
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);
// 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);
if (HCI_LE_ENHANCED_PRIVACY_SUPPORTED(features_ble.as_array)) {
response =
AWAIT_COMMAND(packet_factory->make_ble_read_resolving_list_size());
packet_parser->parse_ble_read_resolving_list_size_response(
response, &ble_resolving_list_max_size);
}
if (HCI_LE_DATA_LEN_EXT_SUPPORTED(features_ble.as_array)) {
response =
AWAIT_COMMAND(packet_factory->make_ble_read_maximum_data_length());
packet_parser->parse_ble_read_maximum_data_length_response(
response, &ble_supported_max_tx_octets, &ble_supported_max_tx_time,
&ble_supported_max_rx_octets, &ble_supported_max_rx_time);
response = AWAIT_COMMAND(
packet_factory->make_ble_read_suggested_default_data_length());
packet_parser->parse_ble_read_suggested_default_data_length_response(
response, &ble_suggested_default_data_length);
}
if (HCI_LE_EXTENDED_ADVERTISING_SUPPORTED(features_ble.as_array)) {
response = AWAIT_COMMAND(
packet_factory->make_ble_read_maximum_advertising_data_length());
packet_parser->parse_ble_read_maximum_advertising_data_length(
response, &ble_maxium_advertising_data_length);
response = AWAIT_COMMAND(
packet_factory->make_ble_read_number_of_supported_advertising_sets());
packet_parser->parse_ble_read_number_of_supported_advertising_sets(
response, &ble_number_of_supported_advertising_sets);
} else {
/* If LE Excended Advertising is not supported, use the default value */
ble_maxium_advertising_data_length = 31;
}
// 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);
}
if (simple_pairing_supported) {
response =
AWAIT_COMMAND(packet_factory->make_set_event_mask(&CLASSIC_EVENT_MASK));
packet_parser->parse_generic_command_complete(response);
}
// read local supported codecs
if (HCI_READ_LOCAL_CODECS_SUPPORTED(supported_commands)) {
response =
AWAIT_COMMAND(packet_factory->make_read_local_supported_codecs());
packet_parser->parse_read_local_supported_codecs_response(
response, &number_of_local_supported_codecs, local_supported_codecs);
}
if (!HCI_READ_ENCR_KEY_SIZE_SUPPORTED(supported_commands)) {
LOG(FATAL) << " Controller must support Read Encryption Key Size command";
}
readable = true;
return future_new_immediate(FUTURE_SUCCESS);
}
static future_t* shut_down(void) {
readable = false;
return future_new_immediate(FUTURE_SUCCESS);
}
EXPORT_SYMBOL extern 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 bool get_is_ready(void) { return readable; }
static const RawAddress* get_address(void) {
CHECK(readable);
return &address;
}
static const bt_version_t* get_bt_version(void) {
CHECK(readable);
return &bt_version;
}
// TODO(zachoverflow): hide inside, move decoder inside too
static const bt_device_features_t* get_features_classic(int index) {
CHECK(readable);
CHECK(index < MAX_FEATURES_CLASSIC_PAGE_COUNT);
return &features_classic[index];
}
static uint8_t get_last_features_classic_index(void) {
CHECK(readable);
return last_features_classic_page_index;
}
static uint8_t* get_local_supported_codecs(uint8_t* number_of_codecs) {
CHECK(readable);
if (number_of_local_supported_codecs) {
*number_of_codecs = number_of_local_supported_codecs;
return local_supported_codecs;
}
return NULL;
}
static const bt_device_features_t* get_features_ble(void) {
CHECK(readable);
CHECK(ble_supported);
return &features_ble;
}
static const uint8_t* get_ble_supported_states(void) {
CHECK(readable);
CHECK(ble_supported);
return ble_supported_states;
}
static bool supports_simple_pairing(void) {
CHECK(readable);
return simple_pairing_supported;
}
static bool supports_secure_connections(void) {
CHECK(readable);
return secure_connections_supported;
}
static bool supports_simultaneous_le_bredr(void) {
CHECK(readable);
return HCI_SIMUL_LE_BREDR_SUPPORTED(features_classic[0].as_array);
}
static bool supports_reading_remote_extended_features(void) {
CHECK(readable);
return HCI_READ_REMOTE_EXT_FEATURES_SUPPORTED(supported_commands);
}
static bool supports_interlaced_inquiry_scan(void) {
CHECK(readable);
return HCI_LMP_INTERLACED_INQ_SCAN_SUPPORTED(features_classic[0].as_array);
}
static bool supports_rssi_with_inquiry_results(void) {
CHECK(readable);
return HCI_LMP_INQ_RSSI_SUPPORTED(features_classic[0].as_array);
}
static bool supports_extended_inquiry_response(void) {
CHECK(readable);
return HCI_EXT_INQ_RSP_SUPPORTED(features_classic[0].as_array);
}
static bool supports_master_slave_role_switch(void) {
CHECK(readable);
return HCI_SWITCH_SUPPORTED(features_classic[0].as_array);
}
static bool supports_enhanced_setup_synchronous_connection(void) {
assert(readable);
return HCI_ENH_SETUP_SYNCH_CONN_SUPPORTED(supported_commands);
}
static bool supports_enhanced_accept_synchronous_connection(void) {
assert(readable);
return HCI_ENH_ACCEPT_SYNCH_CONN_SUPPORTED(supported_commands);
}
static bool supports_ble(void) {
CHECK(readable);
return ble_supported;
}
static bool supports_ble_privacy(void) {
CHECK(readable);
CHECK(ble_supported);
return HCI_LE_ENHANCED_PRIVACY_SUPPORTED(features_ble.as_array);
}
static bool supports_ble_set_privacy_mode() {
CHECK(readable);
CHECK(ble_supported);
return HCI_LE_ENHANCED_PRIVACY_SUPPORTED(features_ble.as_array) &&
HCI_LE_SET_PRIVACY_MODE_SUPPORTED(supported_commands);
}
static bool supports_ble_packet_extension(void) {
CHECK(readable);
CHECK(ble_supported);
return HCI_LE_DATA_LEN_EXT_SUPPORTED(features_ble.as_array);
}
static bool supports_ble_connection_parameters_request(void) {
CHECK(readable);
CHECK(ble_supported);
return HCI_LE_CONN_PARAM_REQ_SUPPORTED(features_ble.as_array);
}
static bool supports_ble_2m_phy(void) {
CHECK(readable);
CHECK(ble_supported);
return HCI_LE_2M_PHY_SUPPORTED(features_ble.as_array);
}
static bool supports_ble_coded_phy(void) {
CHECK(readable);
CHECK(ble_supported);
return HCI_LE_CODED_PHY_SUPPORTED(features_ble.as_array);
}
static bool supports_ble_extended_advertising(void) {
CHECK(readable);
CHECK(ble_supported);
return HCI_LE_EXTENDED_ADVERTISING_SUPPORTED(features_ble.as_array);
}
static bool supports_ble_periodic_advertising(void) {
CHECK(readable);
CHECK(ble_supported);
return HCI_LE_PERIODIC_ADVERTISING_SUPPORTED(features_ble.as_array);
}
static uint16_t get_acl_data_size_classic(void) {
CHECK(readable);
return acl_data_size_classic;
}
static uint16_t get_acl_data_size_ble(void) {
CHECK(readable);
CHECK(ble_supported);
return acl_data_size_ble;
}
static uint16_t get_acl_packet_size_classic(void) {
CHECK(readable);
return acl_data_size_classic + HCI_DATA_PREAMBLE_SIZE;
}
static uint16_t get_acl_packet_size_ble(void) {
CHECK(readable);
return acl_data_size_ble + HCI_DATA_PREAMBLE_SIZE;
}
static uint16_t get_ble_suggested_default_data_length(void) {
CHECK(readable);
CHECK(ble_supported);
return ble_suggested_default_data_length;
}
static uint16_t get_ble_maximum_tx_data_length(void) {
CHECK(readable);
CHECK(ble_supported);
return ble_supported_max_tx_octets;
}
static uint16_t get_ble_maxium_advertising_data_length(void) {
CHECK(readable);
CHECK(ble_supported);
return ble_maxium_advertising_data_length;
}
static uint8_t get_ble_number_of_supported_advertising_sets(void) {
CHECK(readable);
CHECK(ble_supported);
return ble_number_of_supported_advertising_sets;
}
static uint16_t get_acl_buffer_count_classic(void) {
CHECK(readable);
return acl_buffer_count_classic;
}
static uint8_t get_acl_buffer_count_ble(void) {
CHECK(readable);
CHECK(ble_supported);
return acl_buffer_count_ble;
}
static uint8_t get_ble_white_list_size(void) {
CHECK(readable);
CHECK(ble_supported);
return ble_white_list_size;
}
static uint8_t get_ble_resolving_list_max_size(void) {
CHECK(readable);
CHECK(ble_supported);
return ble_resolving_list_max_size;
}
static void set_ble_resolving_list_max_size(int resolving_list_max_size) {
// Setting "resolving_list_max_size" to 0 is done during cleanup,
// hence we ignore the "readable" flag already set to false during shutdown.
if (resolving_list_max_size != 0) {
CHECK(readable);
}
CHECK(ble_supported);
ble_resolving_list_max_size = resolving_list_max_size;
}
static uint8_t get_le_all_initiating_phys() {
uint8_t phy = PHY_LE_1M;
// TODO(jpawlowski): uncomment after next FW udpate
// if (supports_ble_2m_phy()) phy |= PHY_LE_2M;
// if (supports_ble_coded_phy()) phy |= PHY_LE_CODED;
return phy;
}
static const controller_t interface = {
get_is_ready,
get_address,
get_bt_version,
get_features_classic,
get_last_features_classic_index,
get_features_ble,
get_ble_supported_states,
supports_simple_pairing,
supports_secure_connections,
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_enhanced_setup_synchronous_connection,
supports_enhanced_accept_synchronous_connection,
supports_ble,
supports_ble_packet_extension,
supports_ble_connection_parameters_request,
supports_ble_privacy,
supports_ble_set_privacy_mode,
supports_ble_2m_phy,
supports_ble_coded_phy,
supports_ble_extended_advertising,
supports_ble_periodic_advertising,
get_acl_data_size_classic,
get_acl_data_size_ble,
get_acl_packet_size_classic,
get_acl_packet_size_ble,
get_ble_suggested_default_data_length,
get_ble_maximum_tx_data_length,
get_ble_maxium_advertising_data_length,
get_ble_number_of_supported_advertising_sets,
get_acl_buffer_count_classic,
get_acl_buffer_count_ble,
get_ble_white_list_size,
get_ble_resolving_list_max_size,
set_ble_resolving_list_max_size,
get_local_supported_codecs,
get_le_all_initiating_phys};
const controller_t* controller_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 hci_t* hci_interface,
const hci_packet_factory_t* packet_factory_interface,
const hci_packet_parser_t* packet_parser_interface) {
hci = hci_interface;
packet_factory = packet_factory_interface;
packet_parser = packet_parser_interface;
return &interface;
}