* [PATCHv2 02/15] android: Add Adapter Bluetooth HAL template
From: Andrei Emeltchenko @ 2013-10-08 10:33 UTC (permalink / raw)
To: linux-bluetooth
In-Reply-To: <1381228437-5553-1-git-send-email-Andrei.Emeltchenko.news@gmail.com>
From: Andrei Emeltchenko <andrei.emeltchenko@intel.com>
Add template for bluetooth.h Android HAL.
---
android/Android.mk | 19 +++
android/hal_bluetooth.c | 348 +++++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 367 insertions(+)
create mode 100644 android/hal_bluetooth.c
diff --git a/android/Android.mk b/android/Android.mk
index 5498b41..7adbbcd 100644
--- a/android/Android.mk
+++ b/android/Android.mk
@@ -32,3 +32,22 @@ LOCAL_SHARED_LIBRARIES := \
LOCAL_MODULE := bluetoothd
include $(BUILD_EXECUTABLE)
+
+#
+# bluetooth.default.so HAL
+#
+
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := \
+ hal_bluetooth.c \
+
+LOCAL_SHARED_LIBRARIES := \
+ libcutils \
+
+LOCAL_MODULE := bluetooth.default
+LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw
+LOCAL_MODULE_TAGS := optional
+LOCAL_MODULE_CLASS := SHARED_LIBRARIES
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/android/hal_bluetooth.c b/android/hal_bluetooth.c
new file mode 100644
index 0000000..9970374
--- /dev/null
+++ b/android/hal_bluetooth.c
@@ -0,0 +1,348 @@
+/*
+ * Copyright (C) 2013 Intel Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <stdbool.h>
+
+#include <hardware/bluetooth.h>
+
+#define LOG_TAG "BlueZ"
+#include <cutils/log.h>
+
+bt_callbacks_t *bt_hal_cbacks = NULL;
+
+static bool interface_ready(void)
+{
+ return bt_hal_cbacks != NULL;
+}
+
+static int init(bt_callbacks_t *callbacks)
+{
+ ALOGD(__func__);
+
+ if (interface_ready() == true)
+ return BT_STATUS_SUCCESS;
+
+ /* store reference to user callbacks */
+ bt_hal_cbacks = callbacks;
+
+ /* TODO: Init here bluezd task */
+
+ return BT_STATUS_UNSUPPORTED;
+}
+
+static int enable(void)
+{
+ ALOGD(__func__);
+
+ return BT_STATUS_UNSUPPORTED;
+}
+
+static int disable(void)
+{
+ ALOGD(__func__);
+
+ if (interface_ready() == false)
+ return BT_STATUS_NOT_READY;
+
+ return BT_STATUS_UNSUPPORTED;
+}
+
+static void cleanup(void)
+{
+ ALOGD(__func__);
+
+ if (interface_ready() == false)
+ return;
+
+ bt_hal_cbacks = NULL;
+}
+
+static int get_adapter_properties(void)
+{
+ ALOGD(__func__);
+
+ if (interface_ready() == false)
+ return BT_STATUS_NOT_READY;
+
+ return BT_STATUS_UNSUPPORTED;
+}
+
+static int get_adapter_property(bt_property_type_t type)
+{
+ ALOGD(__func__);
+
+ if (interface_ready() == false)
+ return BT_STATUS_NOT_READY;
+
+ return BT_STATUS_UNSUPPORTED;
+}
+
+static int set_adapter_property(const bt_property_t *property)
+{
+ ALOGD(__func__);
+
+ if (interface_ready() == false)
+ return BT_STATUS_NOT_READY;
+
+ if (property == NULL)
+ return BT_STATUS_PARM_INVALID;
+
+ return BT_STATUS_UNSUPPORTED;
+}
+
+static int get_remote_device_properties(bt_bdaddr_t *remote_addr)
+{
+ ALOGD(__func__);
+
+ if (interface_ready() == false)
+ return BT_STATUS_NOT_READY;
+
+ return BT_STATUS_UNSUPPORTED;
+}
+
+static int get_remote_device_property(bt_bdaddr_t *remote_addr,
+ bt_property_type_t type)
+{
+ ALOGD(__func__);
+
+ if (interface_ready() == false)
+ return BT_STATUS_NOT_READY;
+
+ return BT_STATUS_UNSUPPORTED;
+}
+
+static int set_remote_device_property(bt_bdaddr_t *remote_addr,
+ const bt_property_t *property)
+{
+ ALOGD(__func__);
+
+ /* sanity check */
+ if (interface_ready() == false)
+ return BT_STATUS_NOT_READY;
+
+ return BT_STATUS_UNSUPPORTED;
+}
+
+static int get_remote_service_record(bt_bdaddr_t *remote_addr, bt_uuid_t *uuid)
+{
+ ALOGD(__func__);
+
+ if (interface_ready() == false)
+ return BT_STATUS_NOT_READY;
+
+ return BT_STATUS_UNSUPPORTED;
+}
+
+static int get_remote_services(bt_bdaddr_t *remote_addr)
+{
+ ALOGD(__func__);
+
+ if (interface_ready() == false)
+ return BT_STATUS_NOT_READY;
+
+ return BT_STATUS_UNSUPPORTED;
+}
+
+static int start_discovery(void)
+{
+ ALOGD(__func__);
+
+ if (interface_ready() == false)
+ return BT_STATUS_NOT_READY;
+
+ return BT_STATUS_UNSUPPORTED;
+}
+
+static int cancel_discovery(void)
+{
+ ALOGD(__func__);
+
+ if (interface_ready() == false)
+ return BT_STATUS_NOT_READY;
+
+ return BT_STATUS_UNSUPPORTED;
+}
+
+static int create_bond(const bt_bdaddr_t *bd_addr)
+{
+ ALOGD(__func__);
+
+ if (interface_ready() == false)
+ return BT_STATUS_NOT_READY;
+
+ if (bd_addr == NULL)
+ return BT_STATUS_PARM_INVALID;
+
+ return BT_STATUS_UNSUPPORTED;
+}
+
+static int cancel_bond(const bt_bdaddr_t *bd_addr)
+{
+ ALOGD(__func__);
+
+ if (interface_ready() == false)
+ return BT_STATUS_NOT_READY;
+
+ return BT_STATUS_UNSUPPORTED;
+}
+
+static int remove_bond(const bt_bdaddr_t *bd_addr)
+{
+ ALOGD(__func__);
+
+ if (interface_ready() == false)
+ return BT_STATUS_NOT_READY;
+
+ return BT_STATUS_UNSUPPORTED;
+}
+
+static int pin_reply(const bt_bdaddr_t *bd_addr, uint8_t accept,
+ uint8_t pin_len, bt_pin_code_t *pin_code)
+{
+ ALOGD(__func__);
+
+ if (interface_ready() == false)
+ return BT_STATUS_NOT_READY;
+
+ return BT_STATUS_UNSUPPORTED;
+}
+
+static int ssp_reply(const bt_bdaddr_t *bd_addr, bt_ssp_variant_t variant,
+ uint8_t accept, uint32_t passkey)
+{
+
+ ALOGD(__func__);
+
+ if (interface_ready() == false)
+ return BT_STATUS_NOT_READY;
+
+ if (bd_addr == NULL)
+ return BT_STATUS_PARM_INVALID;
+
+ return BT_STATUS_UNSUPPORTED;
+}
+
+static const void *get_profile_interface(const char *profile_id)
+{
+ ALOGD("%s: %s", __func__, profile_id);
+
+ if (interface_ready() == false)
+ return NULL;
+
+ return NULL;
+}
+
+static int dut_mode_configure(uint8_t enable)
+{
+ ALOGD(__func__);
+
+ if (interface_ready() == false)
+ return BT_STATUS_NOT_READY;
+
+ return BT_STATUS_UNSUPPORTED;
+}
+
+static int dut_mode_send(uint16_t opcode, uint8_t *buf, uint8_t len)
+{
+ ALOGD(__func__);
+
+ if (interface_ready() == false)
+ return BT_STATUS_NOT_READY;
+
+ return BT_STATUS_UNSUPPORTED;
+}
+
+/**
+ * HAL Interface declaration
+ */
+static const bt_interface_t bluetooth_if = {
+ sizeof(bt_interface_t),
+ init,
+ enable,
+ disable,
+ cleanup,
+ get_adapter_properties,
+ get_adapter_property,
+ set_adapter_property,
+ get_remote_device_properties,
+ get_remote_device_property,
+ set_remote_device_property,
+ get_remote_service_record,
+ get_remote_services,
+ start_discovery,
+ cancel_discovery,
+ create_bond,
+ remove_bond,
+ cancel_bond,
+ pin_reply,
+ ssp_reply,
+ get_profile_interface,
+ dut_mode_configure,
+ dut_mode_send
+};
+
+static const bt_interface_t *get_bluetooth_interface(void)
+{
+ ALOGD(__func__);
+
+ return &bluetooth_if;
+}
+
+static int close_bluetooth(struct hw_device_t *device)
+{
+ ALOGD(__func__);
+
+ cleanup();
+
+ return 0;
+}
+
+static int open_bluetooth(const struct hw_module_t *module, char const *name,
+ struct hw_device_t **device)
+{
+ bluetooth_device_t *dev = malloc(sizeof(bluetooth_device_t));
+
+ ALOGD(__func__);
+
+ memset(dev, 0, sizeof(bluetooth_device_t));
+ dev->common.tag = HARDWARE_DEVICE_TAG;
+ dev->common.version = 0;
+ dev->common.module = (struct hw_module_t *) module;
+ dev->common.close = close_bluetooth;
+ dev->get_bluetooth_interface = get_bluetooth_interface;
+
+ *device = (struct hw_device_t *) dev;
+
+ return 0;
+}
+
+static struct hw_module_methods_t bluetooth_module_methods = {
+ .open = open_bluetooth,
+};
+
+struct hw_module_t HAL_MODULE_INFO_SYM = {
+ .tag = HARDWARE_MODULE_TAG,
+ .version_major = 1,
+ .version_minor = 0,
+ .id = BT_HARDWARE_MODULE_ID,
+ .name = "BlueZ Bluetooth stack",
+ .author = "Intel Corporation",
+ .methods = &bluetooth_module_methods
+};
--
1.7.10.4
^ permalink raw reply related
* [PATCHv2 01/15] android: Supress missing initializers warnings
From: Andrei Emeltchenko @ 2013-10-08 10:33 UTC (permalink / raw)
To: linux-bluetooth
In-Reply-To: <1381228437-5553-1-git-send-email-Andrei.Emeltchenko.news@gmail.com>
From: Andrei Emeltchenko <andrei.emeltchenko@intel.com>
These types of warnings are disabled in BlueZ makeifiles
main.c:67:2: warning: missing initializer [-Wmissing-field-initializers]
main.c:67:2: warning: (near initialization for 'options[1].short_name')
[-Wmissing-field-initializers]
---
android/Android.mk | 3 +++
1 file changed, 3 insertions(+)
diff --git a/android/Android.mk b/android/Android.mk
index ec820ac..5498b41 100644
--- a/android/Android.mk
+++ b/android/Android.mk
@@ -23,6 +23,9 @@ LOCAL_C_INCLUDES := \
LOCAL_CFLAGS := -DVERSION=\"$(BLUEZ_VERSION)\"
+# to suppress the "warning: missing initializer near initialization.." warning
+LOCAL_CFLAGS += -Wno-missing-field-initializers
+
LOCAL_SHARED_LIBRARIES := \
libglib \
--
1.7.10.4
^ permalink raw reply related
* [PATCHv2 00/15] Basic code for Android BlueZ
From: Andrei Emeltchenko @ 2013-10-08 10:33 UTC (permalink / raw)
To: linux-bluetooth
In-Reply-To: <1381131496-9417-1-git-send-email-Andrei.Emeltchenko.news@gmail.com>
From: Andrei Emeltchenko <andrei.emeltchenko@intel.com>
Skeletons for Android Bluetooth and Socket HALs and BlueZ daemon.
Code is located also here:
https://code.google.com/p/android-bluez.bluez/
Getting Started
https://code.google.com/p/android-bluez/wiki/GettingStarted
Changes:
* PATCHv2: Fixed Szymon's comments from review.
* PATCHv1: Rebased against applied fdanis patch set, moved SDP init from
adapter start to daemon start, other minor fixes.
* RFCv3: Rebased against recent FDanis patch set, fixed library build,
corrected process capabilities, corrected API header.
* RFCv2: Took comments from mailing list reviewers. Use single
makefile, remove mgmt library and directly link, remove adapter
code and use default_adapter pointer and other style changes.
Dropped some patches due to major changes.
Andrei Emeltchenko (15):
android: Supress missing initializers warnings
android: Add Adapter Bluetooth HAL template
android: Add Socket Bluetooth HAL template
android: Enable Socket interface
android: Start Android Bluetooth daemon
android: Add basic mgmt initialization sequence
android: Create HAL API header skeleton
android: Add adapter and device struct for BlueZ daemon
android: Add Android Makefile for libbluetooth
android: sdp: Reuse BlueZ SDP server in Android
android: Add cap to bind to port < 1024
android: Implement read_info_complete callback
android: Handle mgmt changed events
android: Add makefile for hciconfig
android: Add makefile for hcitool
Makefile.android | 9 +-
android/Android.mk | 166 +++++++++++++++
android/bt_adapter.c | 54 +++++
android/bt_adapter.h | 60 ++++++
android/hal.h | 18 ++
android/hal_bluetooth.c | 403 ++++++++++++++++++++++++++++++++++++
android/hal_bt_sock.c | 84 ++++++++
android/hal_msg.h | 255 +++++++++++++++++++++++
android/main.c | 519 +++++++++++++++++++++++++++++++++++++++++++++++
configure.ac | 4 +
10 files changed, 1570 insertions(+), 2 deletions(-)
create mode 100644 android/bt_adapter.c
create mode 100644 android/bt_adapter.h
create mode 100644 android/hal.h
create mode 100644 android/hal_bluetooth.c
create mode 100644 android/hal_bt_sock.c
create mode 100644 android/hal_msg.h
--
1.7.10.4
^ permalink raw reply
* Re: [PATCH 1/2] Bluetooth: Make LE scan interval and window a controller option
From: Marcel Holtmann @ 2013-10-07 22:19 UTC (permalink / raw)
To: Andre Guedes; +Cc: linux-bluetooth
In-Reply-To: <52532774.60903@openbossa.org>
Hi Andre,
>>>> The scan interval and window for LE passive scanning and connection
>>>> establishment should be configurable on a per controller basis. So
>>>> introduce a setting that later on will allow modifying it.
>>>
>>> Each remote device has their particular set of parameters based on the profiles it support. So, these parameters should be per device, not per controller.
>>>
>>> IIRC, we discussed about this in New Orleans and the connection parameters will be informed to the kernel through the Mgmt command to load the connection list. This way, we'll have the parameters set per device.
>>>
>>> So I don't understand exactly what is the purpose of this command you are introducing. Am I missing something?
>>
>> I looked through the core specification and also the scan parameters profile. And actually the way I read it is that these two values are pretty much controller centric.
>>
>> So yes, depending on the profile you are running you can change them. Or if you are running on an active device or if your device is in sleep mode. However at the end of day, the kernel does not really care much what these two values are. It can not make any smart decision about it.
>
> The way I see it, for connection (including background scan), the scan window and interval are Peripheral centric. I'll explain.
>
> Each profile specification recommends the set of parameters for connection establishment (see the "Connection Establishment" section of the profiles specification, for instance HoGP, PXP, FMP). At that section we find the advertising parameters the profile recommends for those who are implementing the Peripheral side and the connection parameters (scan window, scan interval, connection maximum and minimum interval) recommended for those who are implementing the Central side. The profiles may have different connection parameters (e.g. HoGP and FMP).
>
> So, based on the scanning parameters defined by the profiles the Central supports, we should configure the background scan. For instance, let's say we have three devices with the following scanning parameters:
> - Device A (HoGP): interval 22.5ms window 11.25ms
> - Device B (PXP): interval 60ms window 30ms
> - Device C (FMP): interval 60ms window 30ms
>
> For that list of devices, the background scan should be configured with interval 22.5ms window 11.25ms. Now, let's say Device A connects. Then the background scan should be configured with interval 60ms window 30ms.
so I wonder if it is worth it to put this into the kernel. Or let userspace just configure it. And if needed just change it.
Regards
Marcel
^ permalink raw reply
* Re: [PATCH v3 1/2] Bluetooth: Use HCI request for LE connection
From: Marcel Holtmann @ 2013-10-07 22:13 UTC (permalink / raw)
To: Andre Guedes; +Cc: linux-bluetooth
In-Reply-To: <52532B6D.2020504@openbossa.org>
Hi Andre,
>>> This patch introduces a new helper, which uses the HCI request
>>> framework, for creating LE connectons. All the handling is now
>>> done by this function so we can remove the hci_cs_le_create_conn()
>>> event handler.
>>>
>>> This patch also removes the old hci_le_create_connection() since
>>> it is not used anymore.
>>>
>>> Signed-off-by: Andre Guedes <andre.guedes@openbossa.org>
>>> ---
>>> include/net/bluetooth/hci_core.h | 2 ++
>>> net/bluetooth/hci_conn.c | 30 +++++-----------------
>>> net/bluetooth/hci_core.c | 55 ++++++++++++++++++++++++++++++++++++++++
>>> net/bluetooth/hci_event.c | 31 ----------------------
>>> 4 files changed, 63 insertions(+), 55 deletions(-)
>>>
>>> diff --git a/include/net/bluetooth/hci_core.h b/include/net/bluetooth/hci_core.h
>>> index c065527..6ac542c 100644
>>> --- a/include/net/bluetooth/hci_core.h
>>> +++ b/include/net/bluetooth/hci_core.h
>>> @@ -1188,6 +1188,8 @@ void hci_le_start_enc(struct hci_conn *conn, __le16 ediv, __u8 rand[8],
>>>
>>> u8 bdaddr_to_le(u8 bdaddr_type);
>>>
>>> +int hci_create_le_conn(struct hci_dev *hdev, bdaddr_t *addr, u8 type);
>>> +
>>> #define SCO_AIRMODE_MASK 0x0003
>>> #define SCO_AIRMODE_CVSD 0x0000
>>> #define SCO_AIRMODE_TRANSP 0x0003
>>> diff --git a/net/bluetooth/hci_conn.c b/net/bluetooth/hci_conn.c
>>> index 2a220a8..31f6712 100644
>>> --- a/net/bluetooth/hci_conn.c
>>> +++ b/net/bluetooth/hci_conn.c
>>> @@ -49,29 +49,6 @@ static const struct sco_param sco_param_wideband[] = {
>>> { EDR_ESCO_MASK | ESCO_EV3, 0x0008 }, /* T1 */
>>> };
>>>
>>> -static void hci_le_create_connection(struct hci_conn *conn)
>>> -{
>>> - struct hci_dev *hdev = conn->hdev;
>>> - struct hci_cp_le_create_conn cp;
>>> -
>>> - memset(&cp, 0, sizeof(cp));
>>> - cp.scan_interval = __constant_cpu_to_le16(0x0060);
>>> - cp.scan_window = __constant_cpu_to_le16(0x0030);
>>> - bacpy(&cp.peer_addr, &conn->dst);
>>> - cp.peer_addr_type = conn->dst_type;
>>> - if (bacmp(&hdev->bdaddr, BDADDR_ANY))
>>> - cp.own_address_type = ADDR_LE_DEV_PUBLIC;
>>> - else
>>> - cp.own_address_type = ADDR_LE_DEV_RANDOM;
>>> - cp.conn_interval_min = __constant_cpu_to_le16(0x0028);
>>> - cp.conn_interval_max = __constant_cpu_to_le16(0x0038);
>>> - cp.supervision_timeout = __constant_cpu_to_le16(0x002a);
>>> - cp.min_ce_len = __constant_cpu_to_le16(0x0000);
>>> - cp.max_ce_len = __constant_cpu_to_le16(0x0000);
>>> -
>>> - hci_send_cmd(hdev, HCI_OP_LE_CREATE_CONN, sizeof(cp), &cp);
>>> -}
>>> -
>>> static void hci_le_create_connection_cancel(struct hci_conn *conn)
>>> {
>>> hci_send_cmd(conn->hdev, HCI_OP_LE_CREATE_CONN_CANCEL, 0, NULL);
>>> @@ -549,6 +526,7 @@ static struct hci_conn *hci_connect_le(struct hci_dev *hdev, bdaddr_t *dst,
>>> u8 dst_type, u8 sec_level, u8 auth_type)
>>> {
>>> struct hci_conn *conn;
>>> + int err;
>>>
>>> if (test_bit(HCI_ADVERTISING, &hdev->flags))
>>> return ERR_PTR(-ENOTSUPP);
>>> @@ -569,7 +547,11 @@ static struct hci_conn *hci_connect_le(struct hci_dev *hdev, bdaddr_t *dst,
>>> conn->link_mode |= HCI_LM_MASTER;
>>> conn->sec_level = BT_SECURITY_LOW;
>>>
>>> - hci_le_create_connection(conn);
>>> + err = hci_create_le_conn(hdev, &conn->dst, conn->dst_type);
>>> + if (err) {
>>> + hci_conn_del(conn);
>>> + return ERR_PTR(err);
>>> + }
>>
>> I am wondering why we do not keep the void function here and handle the error directly in hci_create_le_conn.
>>
>> Any reason why you are doing it this way?
>
> Yes, hci_create_le_conn() may return error if hci_req_run() returns error (e.g. ENOMEM). For that case, we have to destroy the hci_conn object created by hci_conn_add() otherwise this object will leak. Besides, if the HCI command could not be sent to controller we should notify the caller about this (e.g. connect() returns error to the user or MGMT_OP_PAIR_DEVICE completes with error)
you are not answering my question. Why is the error handling not done directly in hci_create_le_conn? Do it where hci_req_run fails and not some other place.
Regards
Marcel
^ permalink raw reply
* Re: [PATCH v3 1/2] Bluetooth: Use HCI request for LE connection
From: Andre Guedes @ 2013-10-07 21:45 UTC (permalink / raw)
To: Marcel Holtmann; +Cc: linux-bluetooth
In-Reply-To: <1A822672-4ED1-4124-89EA-357325B6AF1B@holtmann.org>
Hi Marcel,
On 10/07/2013 06:16 PM, Marcel Holtmann wrote:
> Hi Andre,
>
>> This patch introduces a new helper, which uses the HCI request
>> framework, for creating LE connectons. All the handling is now
>> done by this function so we can remove the hci_cs_le_create_conn()
>> event handler.
>>
>> This patch also removes the old hci_le_create_connection() since
>> it is not used anymore.
>>
>> Signed-off-by: Andre Guedes <andre.guedes@openbossa.org>
>> ---
>> include/net/bluetooth/hci_core.h | 2 ++
>> net/bluetooth/hci_conn.c | 30 +++++-----------------
>> net/bluetooth/hci_core.c | 55 ++++++++++++++++++++++++++++++++++++++++
>> net/bluetooth/hci_event.c | 31 ----------------------
>> 4 files changed, 63 insertions(+), 55 deletions(-)
>>
>> diff --git a/include/net/bluetooth/hci_core.h b/include/net/bluetooth/hci_core.h
>> index c065527..6ac542c 100644
>> --- a/include/net/bluetooth/hci_core.h
>> +++ b/include/net/bluetooth/hci_core.h
>> @@ -1188,6 +1188,8 @@ void hci_le_start_enc(struct hci_conn *conn, __le16 ediv, __u8 rand[8],
>>
>> u8 bdaddr_to_le(u8 bdaddr_type);
>>
>> +int hci_create_le_conn(struct hci_dev *hdev, bdaddr_t *addr, u8 type);
>> +
>> #define SCO_AIRMODE_MASK 0x0003
>> #define SCO_AIRMODE_CVSD 0x0000
>> #define SCO_AIRMODE_TRANSP 0x0003
>> diff --git a/net/bluetooth/hci_conn.c b/net/bluetooth/hci_conn.c
>> index 2a220a8..31f6712 100644
>> --- a/net/bluetooth/hci_conn.c
>> +++ b/net/bluetooth/hci_conn.c
>> @@ -49,29 +49,6 @@ static const struct sco_param sco_param_wideband[] = {
>> { EDR_ESCO_MASK | ESCO_EV3, 0x0008 }, /* T1 */
>> };
>>
>> -static void hci_le_create_connection(struct hci_conn *conn)
>> -{
>> - struct hci_dev *hdev = conn->hdev;
>> - struct hci_cp_le_create_conn cp;
>> -
>> - memset(&cp, 0, sizeof(cp));
>> - cp.scan_interval = __constant_cpu_to_le16(0x0060);
>> - cp.scan_window = __constant_cpu_to_le16(0x0030);
>> - bacpy(&cp.peer_addr, &conn->dst);
>> - cp.peer_addr_type = conn->dst_type;
>> - if (bacmp(&hdev->bdaddr, BDADDR_ANY))
>> - cp.own_address_type = ADDR_LE_DEV_PUBLIC;
>> - else
>> - cp.own_address_type = ADDR_LE_DEV_RANDOM;
>> - cp.conn_interval_min = __constant_cpu_to_le16(0x0028);
>> - cp.conn_interval_max = __constant_cpu_to_le16(0x0038);
>> - cp.supervision_timeout = __constant_cpu_to_le16(0x002a);
>> - cp.min_ce_len = __constant_cpu_to_le16(0x0000);
>> - cp.max_ce_len = __constant_cpu_to_le16(0x0000);
>> -
>> - hci_send_cmd(hdev, HCI_OP_LE_CREATE_CONN, sizeof(cp), &cp);
>> -}
>> -
>> static void hci_le_create_connection_cancel(struct hci_conn *conn)
>> {
>> hci_send_cmd(conn->hdev, HCI_OP_LE_CREATE_CONN_CANCEL, 0, NULL);
>> @@ -549,6 +526,7 @@ static struct hci_conn *hci_connect_le(struct hci_dev *hdev, bdaddr_t *dst,
>> u8 dst_type, u8 sec_level, u8 auth_type)
>> {
>> struct hci_conn *conn;
>> + int err;
>>
>> if (test_bit(HCI_ADVERTISING, &hdev->flags))
>> return ERR_PTR(-ENOTSUPP);
>> @@ -569,7 +547,11 @@ static struct hci_conn *hci_connect_le(struct hci_dev *hdev, bdaddr_t *dst,
>> conn->link_mode |= HCI_LM_MASTER;
>> conn->sec_level = BT_SECURITY_LOW;
>>
>> - hci_le_create_connection(conn);
>> + err = hci_create_le_conn(hdev, &conn->dst, conn->dst_type);
>> + if (err) {
>> + hci_conn_del(conn);
>> + return ERR_PTR(err);
>> + }
>
> I am wondering why we do not keep the void function here and handle the error directly in hci_create_le_conn.
>
> Any reason why you are doing it this way?
Yes, hci_create_le_conn() may return error if hci_req_run() returns
error (e.g. ENOMEM). For that case, we have to destroy the hci_conn
object created by hci_conn_add() otherwise this object will leak.
Besides, if the HCI command could not be sent to controller we should
notify the caller about this (e.g. connect() returns error to the user
or MGMT_OP_PAIR_DEVICE completes with error)
Regards,
Andre
^ permalink raw reply
* Re: [PATCH 1/2] Bluetooth: Make LE scan interval and window a controller option
From: Andre Guedes @ 2013-10-07 21:28 UTC (permalink / raw)
To: Marcel Holtmann; +Cc: linux-bluetooth
In-Reply-To: <B6CE6A9A-E989-4F48-B12D-D23C47FC36A2@holtmann.org>
Hi Marcel,
On 10/04/2013 11:39 PM, Marcel Holtmann wrote:
> Hi Andre,
>
>>> The scan interval and window for LE passive scanning and connection
>>> establishment should be configurable on a per controller basis. So
>>> introduce a setting that later on will allow modifying it.
>>
>> Each remote device has their particular set of parameters based on the profiles it support. So, these parameters should be per device, not per controller.
>>
>> IIRC, we discussed about this in New Orleans and the connection parameters will be informed to the kernel through the Mgmt command to load the connection list. This way, we'll have the parameters set per device.
>>
>> So I don't understand exactly what is the purpose of this command you are introducing. Am I missing something?
>
> I looked through the core specification and also the scan parameters profile. And actually the way I read it is that these two values are pretty much controller centric.
>
> So yes, depending on the profile you are running you can change them. Or if you are running on an active device or if your device is in sleep mode. However at the end of day, the kernel does not really care much what these two values are. It can not make any smart decision about it.
The way I see it, for connection (including background scan), the scan
window and interval are Peripheral centric. I'll explain.
Each profile specification recommends the set of parameters for
connection establishment (see the "Connection Establishment" section of
the profiles specification, for instance HoGP, PXP, FMP). At that
section we find the advertising parameters the profile recommends for
those who are implementing the Peripheral side and the connection
parameters (scan window, scan interval, connection maximum and minimum
interval) recommended for those who are implementing the Central side.
The profiles may have different connection parameters (e.g. HoGP and FMP).
So, based on the scanning parameters defined by the profiles the Central
supports, we should configure the background scan. For instance, let's
say we have three devices with the following scanning parameters:
- Device A (HoGP): interval 22.5ms window 11.25ms
- Device B (PXP): interval 60ms window 30ms
- Device C (FMP): interval 60ms window 30ms
For that list of devices, the background scan should be configured with
interval 22.5ms window 11.25ms. Now, let's say Device A connects. Then
the background scan should be configured with interval 60ms window 30ms.
> The way I read especially the scan parameters profile is that not the peripheral is telling us what would be good scan parameters. Instead the central is telling what scan parameters it is using and then the peripheral is suppose to adjust its advertising to it.
The Scan Parameters Profile seems to be useful in situation like the one
described above. The Central is not using the recommends scanning
parameters (since it has more than one set of parameters) so it informs
the Peripheral what parameters it is using. The Peripheral does its best
to configure its advertising interval according to the scanning
parameters the Central is using.
> All the information to pick good scan parameters are based on the remote profiles and whatever the system is currently doing. So my current take is that we let bluetoothd make that call and set the right parameters and the kernel just uses them. Of course buetoothd can adjust these at runtime any time it wants to.
The background scanning parameters can be configured by bluetoothd or
internaly by the kernel. At the moment, I'm not sure what option is the
best.
> Settings like the connection interval are different. They are learned from the advertising data and can be used by the connection process. The scan internal and window however make no difference. For background scanning and auto-connection handling these values should be used. In case of pairing and direct connections, we better set them to same value to get a continuous scan anyway. Same as we do for active scanning during discovery right now.
The maximum and minimum connection intervals are defined by the profiles
and/or in the advertising data.
The Central should use them to establish connection in order to optimize
the energy comsuption on the Peripheral side. If the Central doesn't use
the recommended parameters, the Peripheral may send a Connection
Parameter Update Request through the signaling channel to change the
connection parameters.
Regards,
Andre
^ permalink raw reply
* Re: [PATCH v3 1/2] Bluetooth: Use HCI request for LE connection
From: Marcel Holtmann @ 2013-10-07 21:16 UTC (permalink / raw)
To: Andre Guedes; +Cc: linux-bluetooth
In-Reply-To: <1381165148-14156-2-git-send-email-andre.guedes@openbossa.org>
Hi Andre,
> This patch introduces a new helper, which uses the HCI request
> framework, for creating LE connectons. All the handling is now
> done by this function so we can remove the hci_cs_le_create_conn()
> event handler.
>
> This patch also removes the old hci_le_create_connection() since
> it is not used anymore.
>
> Signed-off-by: Andre Guedes <andre.guedes@openbossa.org>
> ---
> include/net/bluetooth/hci_core.h | 2 ++
> net/bluetooth/hci_conn.c | 30 +++++-----------------
> net/bluetooth/hci_core.c | 55 ++++++++++++++++++++++++++++++++++++++++
> net/bluetooth/hci_event.c | 31 ----------------------
> 4 files changed, 63 insertions(+), 55 deletions(-)
>
> diff --git a/include/net/bluetooth/hci_core.h b/include/net/bluetooth/hci_core.h
> index c065527..6ac542c 100644
> --- a/include/net/bluetooth/hci_core.h
> +++ b/include/net/bluetooth/hci_core.h
> @@ -1188,6 +1188,8 @@ void hci_le_start_enc(struct hci_conn *conn, __le16 ediv, __u8 rand[8],
>
> u8 bdaddr_to_le(u8 bdaddr_type);
>
> +int hci_create_le_conn(struct hci_dev *hdev, bdaddr_t *addr, u8 type);
> +
> #define SCO_AIRMODE_MASK 0x0003
> #define SCO_AIRMODE_CVSD 0x0000
> #define SCO_AIRMODE_TRANSP 0x0003
> diff --git a/net/bluetooth/hci_conn.c b/net/bluetooth/hci_conn.c
> index 2a220a8..31f6712 100644
> --- a/net/bluetooth/hci_conn.c
> +++ b/net/bluetooth/hci_conn.c
> @@ -49,29 +49,6 @@ static const struct sco_param sco_param_wideband[] = {
> { EDR_ESCO_MASK | ESCO_EV3, 0x0008 }, /* T1 */
> };
>
> -static void hci_le_create_connection(struct hci_conn *conn)
> -{
> - struct hci_dev *hdev = conn->hdev;
> - struct hci_cp_le_create_conn cp;
> -
> - memset(&cp, 0, sizeof(cp));
> - cp.scan_interval = __constant_cpu_to_le16(0x0060);
> - cp.scan_window = __constant_cpu_to_le16(0x0030);
> - bacpy(&cp.peer_addr, &conn->dst);
> - cp.peer_addr_type = conn->dst_type;
> - if (bacmp(&hdev->bdaddr, BDADDR_ANY))
> - cp.own_address_type = ADDR_LE_DEV_PUBLIC;
> - else
> - cp.own_address_type = ADDR_LE_DEV_RANDOM;
> - cp.conn_interval_min = __constant_cpu_to_le16(0x0028);
> - cp.conn_interval_max = __constant_cpu_to_le16(0x0038);
> - cp.supervision_timeout = __constant_cpu_to_le16(0x002a);
> - cp.min_ce_len = __constant_cpu_to_le16(0x0000);
> - cp.max_ce_len = __constant_cpu_to_le16(0x0000);
> -
> - hci_send_cmd(hdev, HCI_OP_LE_CREATE_CONN, sizeof(cp), &cp);
> -}
> -
> static void hci_le_create_connection_cancel(struct hci_conn *conn)
> {
> hci_send_cmd(conn->hdev, HCI_OP_LE_CREATE_CONN_CANCEL, 0, NULL);
> @@ -549,6 +526,7 @@ static struct hci_conn *hci_connect_le(struct hci_dev *hdev, bdaddr_t *dst,
> u8 dst_type, u8 sec_level, u8 auth_type)
> {
> struct hci_conn *conn;
> + int err;
>
> if (test_bit(HCI_ADVERTISING, &hdev->flags))
> return ERR_PTR(-ENOTSUPP);
> @@ -569,7 +547,11 @@ static struct hci_conn *hci_connect_le(struct hci_dev *hdev, bdaddr_t *dst,
> conn->link_mode |= HCI_LM_MASTER;
> conn->sec_level = BT_SECURITY_LOW;
>
> - hci_le_create_connection(conn);
> + err = hci_create_le_conn(hdev, &conn->dst, conn->dst_type);
> + if (err) {
> + hci_conn_del(conn);
> + return ERR_PTR(err);
> + }
I am wondering why we do not keep the void function here and handle the error directly in hci_create_le_conn.
Any reason why you are doing it this way?
Regards
Marcel
^ permalink raw reply
* [PATCH BlueZ] autopair: Remove time(NULL) fallback when seeding rand()
From: Anderson Lizardo @ 2013-10-07 21:05 UTC (permalink / raw)
To: linux-bluetooth; +Cc: Anderson Lizardo
If /dev/urandom cannot be opened or read, just fail the plugin
initialization, as it is very unlikely that a fully working Linux system
does not have a working /dev/urandom. This also simplifies the code
logic.
---
plugins/autopair.c | 27 ++++++++++++++++++---------
1 file changed, 18 insertions(+), 9 deletions(-)
diff --git a/plugins/autopair.c b/plugins/autopair.c
index e6e5035..266b695 100644
--- a/plugins/autopair.c
+++ b/plugins/autopair.c
@@ -29,6 +29,7 @@
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
+#include <errno.h>
#include <bluetooth/bluetooth.h>
#include <glib.h>
@@ -149,19 +150,27 @@ static int autopair_init(void)
{
/* Initialize the random seed from /dev/urandom */
unsigned int seed;
- int fd;
+ int fd, err;
+ ssize_t n;
fd = open("/dev/urandom", O_RDONLY);
- if (fd >= 0) {
- ssize_t n;
-
- n = read(fd, &seed, sizeof(seed));
- if (n < (ssize_t) sizeof(seed))
- seed = time(NULL);
+ if (fd < 0) {
+ err = -errno;
+ error("Failed to open /dev/urandom: %s (%d)", strerror(-err),
+ -err);
+ return err;
+ }
+ n = read(fd, &seed, sizeof(seed));
+ if (n < (ssize_t) sizeof(seed)) {
+ err = (n == -1) ? -errno : -EIO;
+ error("Failed to read %d bytes from /dev/urandom",
+ sizeof(seed));
close(fd);
- } else
- seed = time(NULL);
+ return err;
+ }
+
+ close(fd);
srand(seed);
--
1.7.9.5
^ permalink raw reply related
* [PATCH v3 2/2] Bluetooth: Refactor hci_connect_le
From: Andre Guedes @ 2013-10-07 16:59 UTC (permalink / raw)
To: linux-bluetooth
In-Reply-To: <1381165148-14156-1-git-send-email-andre.guedes@openbossa.org>
This patch does some code refactoring in hci_connect_le() by moving
the exception code into if statements and letting the main flow in
first level of function scope. It also adds extra comments to improve
the code readability.
Signed-off-by: Andre Guedes <andre.guedes@openbossa.org>
---
net/bluetooth/hci_conn.c | 55 ++++++++++++++++++++++++++++++------------------
1 file changed, 35 insertions(+), 20 deletions(-)
diff --git a/net/bluetooth/hci_conn.c b/net/bluetooth/hci_conn.c
index 31f6712..de211ca 100644
--- a/net/bluetooth/hci_conn.c
+++ b/net/bluetooth/hci_conn.c
@@ -531,34 +531,49 @@ static struct hci_conn *hci_connect_le(struct hci_dev *hdev, bdaddr_t *dst,
if (test_bit(HCI_ADVERTISING, &hdev->flags))
return ERR_PTR(-ENOTSUPP);
+ /* Some devices send ATT messages as soon as the physical link is
+ * established. To be able to handle these ATT messages, the user-
+ * space first establishes the connection and then starts the pairing
+ * process.
+ *
+ * So if a hci_conn object already exists for the following connection
+ * attempt, we simply update pending_sec_level and auth_type fields
+ * and return the object found.
+ */
conn = hci_conn_hash_lookup_ba(hdev, LE_LINK, dst);
- if (!conn) {
- conn = hci_conn_hash_lookup_state(hdev, LE_LINK, BT_CONNECT);
- if (conn)
- return ERR_PTR(-EBUSY);
-
- conn = hci_conn_add(hdev, LE_LINK, dst);
- if (!conn)
- return ERR_PTR(-ENOMEM);
+ if (conn) {
+ conn->pending_sec_level = sec_level;
+ conn->auth_type = auth_type;
+ goto done;
+ }
- conn->dst_type = bdaddr_to_le(dst_type);
- conn->state = BT_CONNECT;
- conn->out = true;
- conn->link_mode |= HCI_LM_MASTER;
- conn->sec_level = BT_SECURITY_LOW;
+ /* Since the controller supports only one LE connection attempt at a
+ * time, we return -EBUSY if there is any connection attempt running.
+ */
+ conn = hci_conn_hash_lookup_state(hdev, LE_LINK, BT_CONNECT);
+ if (conn)
+ return ERR_PTR(-EBUSY);
- err = hci_create_le_conn(hdev, &conn->dst, conn->dst_type);
- if (err) {
- hci_conn_del(conn);
- return ERR_PTR(err);
- }
- }
+ conn = hci_conn_add(hdev, LE_LINK, dst);
+ if (!conn)
+ return ERR_PTR(-ENOMEM);
+ conn->dst_type = bdaddr_to_le(dst_type);
+ conn->state = BT_CONNECT;
+ conn->out = true;
+ conn->link_mode |= HCI_LM_MASTER;
+ conn->sec_level = BT_SECURITY_LOW;
conn->pending_sec_level = sec_level;
conn->auth_type = auth_type;
- hci_conn_hold(conn);
+ err = hci_create_le_conn(hdev, &conn->dst, conn->dst_type);
+ if (err) {
+ hci_conn_del(conn);
+ return ERR_PTR(err);
+ }
+done:
+ hci_conn_hold(conn);
return conn;
}
--
1.8.4
^ permalink raw reply related
* [PATCH v3 1/2] Bluetooth: Use HCI request for LE connection
From: Andre Guedes @ 2013-10-07 16:59 UTC (permalink / raw)
To: linux-bluetooth
In-Reply-To: <1381165148-14156-1-git-send-email-andre.guedes@openbossa.org>
This patch introduces a new helper, which uses the HCI request
framework, for creating LE connectons. All the handling is now
done by this function so we can remove the hci_cs_le_create_conn()
event handler.
This patch also removes the old hci_le_create_connection() since
it is not used anymore.
Signed-off-by: Andre Guedes <andre.guedes@openbossa.org>
---
include/net/bluetooth/hci_core.h | 2 ++
net/bluetooth/hci_conn.c | 30 +++++-----------------
net/bluetooth/hci_core.c | 55 ++++++++++++++++++++++++++++++++++++++++
net/bluetooth/hci_event.c | 31 ----------------------
4 files changed, 63 insertions(+), 55 deletions(-)
diff --git a/include/net/bluetooth/hci_core.h b/include/net/bluetooth/hci_core.h
index c065527..6ac542c 100644
--- a/include/net/bluetooth/hci_core.h
+++ b/include/net/bluetooth/hci_core.h
@@ -1188,6 +1188,8 @@ void hci_le_start_enc(struct hci_conn *conn, __le16 ediv, __u8 rand[8],
u8 bdaddr_to_le(u8 bdaddr_type);
+int hci_create_le_conn(struct hci_dev *hdev, bdaddr_t *addr, u8 type);
+
#define SCO_AIRMODE_MASK 0x0003
#define SCO_AIRMODE_CVSD 0x0000
#define SCO_AIRMODE_TRANSP 0x0003
diff --git a/net/bluetooth/hci_conn.c b/net/bluetooth/hci_conn.c
index 2a220a8..31f6712 100644
--- a/net/bluetooth/hci_conn.c
+++ b/net/bluetooth/hci_conn.c
@@ -49,29 +49,6 @@ static const struct sco_param sco_param_wideband[] = {
{ EDR_ESCO_MASK | ESCO_EV3, 0x0008 }, /* T1 */
};
-static void hci_le_create_connection(struct hci_conn *conn)
-{
- struct hci_dev *hdev = conn->hdev;
- struct hci_cp_le_create_conn cp;
-
- memset(&cp, 0, sizeof(cp));
- cp.scan_interval = __constant_cpu_to_le16(0x0060);
- cp.scan_window = __constant_cpu_to_le16(0x0030);
- bacpy(&cp.peer_addr, &conn->dst);
- cp.peer_addr_type = conn->dst_type;
- if (bacmp(&hdev->bdaddr, BDADDR_ANY))
- cp.own_address_type = ADDR_LE_DEV_PUBLIC;
- else
- cp.own_address_type = ADDR_LE_DEV_RANDOM;
- cp.conn_interval_min = __constant_cpu_to_le16(0x0028);
- cp.conn_interval_max = __constant_cpu_to_le16(0x0038);
- cp.supervision_timeout = __constant_cpu_to_le16(0x002a);
- cp.min_ce_len = __constant_cpu_to_le16(0x0000);
- cp.max_ce_len = __constant_cpu_to_le16(0x0000);
-
- hci_send_cmd(hdev, HCI_OP_LE_CREATE_CONN, sizeof(cp), &cp);
-}
-
static void hci_le_create_connection_cancel(struct hci_conn *conn)
{
hci_send_cmd(conn->hdev, HCI_OP_LE_CREATE_CONN_CANCEL, 0, NULL);
@@ -549,6 +526,7 @@ static struct hci_conn *hci_connect_le(struct hci_dev *hdev, bdaddr_t *dst,
u8 dst_type, u8 sec_level, u8 auth_type)
{
struct hci_conn *conn;
+ int err;
if (test_bit(HCI_ADVERTISING, &hdev->flags))
return ERR_PTR(-ENOTSUPP);
@@ -569,7 +547,11 @@ static struct hci_conn *hci_connect_le(struct hci_dev *hdev, bdaddr_t *dst,
conn->link_mode |= HCI_LM_MASTER;
conn->sec_level = BT_SECURITY_LOW;
- hci_le_create_connection(conn);
+ err = hci_create_le_conn(hdev, &conn->dst, conn->dst_type);
+ if (err) {
+ hci_conn_del(conn);
+ return ERR_PTR(err);
+ }
}
conn->pending_sec_level = sec_level;
diff --git a/net/bluetooth/hci_core.c b/net/bluetooth/hci_core.c
index 0c636ba..8cd8486 100644
--- a/net/bluetooth/hci_core.c
+++ b/net/bluetooth/hci_core.c
@@ -3702,3 +3702,58 @@ u8 bdaddr_to_le(u8 bdaddr_type)
return ADDR_LE_DEV_RANDOM;
}
}
+
+static void create_le_conn_complete(struct hci_dev *hdev, u8 status)
+{
+ struct hci_conn *conn;
+
+ if (status == 0)
+ return;
+
+ BT_ERR("HCI request failed to create LE connection: status 0x%2.2x",
+ status);
+
+ hci_dev_lock(hdev);
+
+ conn = hci_conn_hash_lookup_state(hdev, LE_LINK, BT_CONNECT);
+ if (!conn)
+ goto done;
+
+ conn->state = BT_CLOSED;
+
+ mgmt_connect_failed(hdev, &conn->dst, conn->type, conn->dst_type,
+ status);
+
+ hci_proto_connect_cfm(conn, status);
+
+ hci_conn_del(conn);
+
+done:
+ hci_dev_unlock(hdev);
+}
+
+int hci_create_le_conn(struct hci_dev *hdev, bdaddr_t *addr, u8 type)
+{
+ struct hci_cp_le_create_conn cp;
+ struct hci_request req;
+
+ hci_req_init(&req, hdev);
+
+ memset(&cp, 0, sizeof(cp));
+ cp.scan_interval = __constant_cpu_to_le16(0x0060);
+ cp.scan_window = __constant_cpu_to_le16(0x0030);
+ bacpy(&cp.peer_addr, addr);
+ cp.peer_addr_type = type;
+ if (bacmp(&hdev->bdaddr, BDADDR_ANY))
+ cp.own_address_type = ADDR_LE_DEV_PUBLIC;
+ else
+ cp.own_address_type = ADDR_LE_DEV_RANDOM;
+ cp.conn_interval_min = __constant_cpu_to_le16(0x0028);
+ cp.conn_interval_max = __constant_cpu_to_le16(0x0038);
+ cp.supervision_timeout = __constant_cpu_to_le16(0x002a);
+ cp.min_ce_len = __constant_cpu_to_le16(0x0000);
+ cp.max_ce_len = __constant_cpu_to_le16(0x0000);
+ hci_req_add(&req, HCI_OP_LE_CREATE_CONN, sizeof(cp), &cp);
+
+ return hci_req_run(&req, create_le_conn_complete);
+}
diff --git a/net/bluetooth/hci_event.c b/net/bluetooth/hci_event.c
index 224210c..655d5ca 100644
--- a/net/bluetooth/hci_event.c
+++ b/net/bluetooth/hci_event.c
@@ -1470,33 +1470,6 @@ static void hci_cs_disconnect(struct hci_dev *hdev, u8 status)
hci_dev_unlock(hdev);
}
-static void hci_cs_le_create_conn(struct hci_dev *hdev, __u8 status)
-{
- struct hci_conn *conn;
-
- BT_DBG("%s status 0x%2.2x", hdev->name, status);
-
- if (status) {
- hci_dev_lock(hdev);
-
- conn = hci_conn_hash_lookup_state(hdev, LE_LINK, BT_CONNECT);
- if (!conn) {
- hci_dev_unlock(hdev);
- return;
- }
-
- BT_DBG("%s bdaddr %pMR conn %p", hdev->name, &conn->dst, conn);
-
- conn->state = BT_CLOSED;
- mgmt_connect_failed(hdev, &conn->dst, conn->type,
- conn->dst_type, status);
- hci_proto_connect_cfm(conn, status);
- hci_conn_del(conn);
-
- hci_dev_unlock(hdev);
- }
-}
-
static void hci_cs_create_phylink(struct hci_dev *hdev, u8 status)
{
struct hci_cp_create_phy_link *cp;
@@ -2362,10 +2335,6 @@ static void hci_cmd_status_evt(struct hci_dev *hdev, struct sk_buff *skb)
hci_cs_disconnect(hdev, ev->status);
break;
- case HCI_OP_LE_CREATE_CONN:
- hci_cs_le_create_conn(hdev, ev->status);
- break;
-
case HCI_OP_CREATE_PHY_LINK:
hci_cs_create_phylink(hdev, ev->status);
break;
--
1.8.4
^ permalink raw reply related
* [PATCH v3 0/2] LE connection refactoring and fixes
From: Andre Guedes @ 2013-10-07 16:59 UTC (permalink / raw)
To: linux-bluetooth
Hi all,
This v3 implements Marcel's comments from the previous patchset. It is rebased
on top of current bluetooth-next tree.
Regards,
Andre
Andre Guedes (2):
Bluetooth: Use HCI request for LE connection
Bluetooth: Refactor hci_connect_le
include/net/bluetooth/hci_core.h | 2 ++
net/bluetooth/hci_conn.c | 75 +++++++++++++++++++---------------------
net/bluetooth/hci_core.c | 55 +++++++++++++++++++++++++++++
net/bluetooth/hci_event.c | 31 -----------------
4 files changed, 93 insertions(+), 70 deletions(-)
--
1.8.4
^ permalink raw reply
* Re: [PATCH v2] bluetooth: fix variable shadow warnings
From: Marcel Holtmann @ 2013-10-07 16:53 UTC (permalink / raw)
To: Johannes Berg; +Cc: linux-wireless, linux-bluetooth, Johannes Berg
In-Reply-To: <1381162756-18353-1-git-send-email-johannes@sipsolutions.net>
Hi Johannes,
> From: Johannes Berg <johannes.berg@intel.com>
>
> Sparse points out three places where variables are shadowed,
> rename two of the variables and remove the duplicate third.
>
> Signed-off-by: Johannes Berg <johannes.berg@intel.com>
> ---
> net/bluetooth/hci_event.c | 12 +++++++-----
> net/bluetooth/l2cap_sock.c | 2 +-
> 2 files changed, 8 insertions(+), 6 deletions(-)
patch has been applied to bluetooth-next tree.
Regards
Marcel
^ permalink raw reply
* [PATCH v2] bluetooth: fix variable shadow warnings
From: Johannes Berg @ 2013-10-07 16:19 UTC (permalink / raw)
To: linux-wireless, linux-bluetooth; +Cc: Johannes Berg
From: Johannes Berg <johannes.berg@intel.com>
Sparse points out three places where variables are shadowed,
rename two of the variables and remove the duplicate third.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
---
net/bluetooth/hci_event.c | 12 +++++++-----
net/bluetooth/l2cap_sock.c | 2 +-
2 files changed, 8 insertions(+), 6 deletions(-)
diff --git a/net/bluetooth/hci_event.c b/net/bluetooth/hci_event.c
index 94aab73..8b2991e 100644
--- a/net/bluetooth/hci_event.c
+++ b/net/bluetooth/hci_event.c
@@ -1291,9 +1291,11 @@ static void hci_cs_remote_name_req(struct hci_dev *hdev, __u8 status)
goto unlock;
if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->flags)) {
- struct hci_cp_auth_requested cp;
- cp.handle = __cpu_to_le16(conn->handle);
- hci_send_cmd(hdev, HCI_OP_AUTH_REQUESTED, sizeof(cp), &cp);
+ struct hci_cp_auth_requested auth_cp;
+
+ auth_cp.handle = __cpu_to_le16(conn->handle);
+ hci_send_cmd(hdev, HCI_OP_AUTH_REQUESTED,
+ sizeof(auth_cp), &auth_cp);
}
unlock:
@@ -3636,8 +3638,8 @@ void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb)
skb_pull(skb, HCI_EVENT_HDR_SIZE);
if (hdev->sent_cmd && bt_cb(hdev->sent_cmd)->req.event == event) {
- struct hci_command_hdr *hdr = (void *) hdev->sent_cmd->data;
- u16 opcode = __le16_to_cpu(hdr->opcode);
+ struct hci_command_hdr *cmd_hdr = (void *) hdev->sent_cmd->data;
+ u16 opcode = __le16_to_cpu(cmd_hdr->opcode);
hci_req_cmd_complete(hdev, opcode, 0);
}
diff --git a/net/bluetooth/l2cap_sock.c b/net/bluetooth/l2cap_sock.c
index 0098af8..f07e25d 100644
--- a/net/bluetooth/l2cap_sock.c
+++ b/net/bluetooth/l2cap_sock.c
@@ -683,7 +683,7 @@ static int l2cap_sock_setsockopt(struct socket *sock, int level, int optname,
}
if (opt == BT_FLUSHABLE_OFF) {
- struct l2cap_conn *conn = chan->conn;
+ conn = chan->conn;
/* proceed further only when we have l2cap_conn and
No Flush support in the LM */
if (!conn || !lmp_no_flush_capable(conn->hcon->hdev)) {
--
1.8.4.rc3
^ permalink raw reply related
* Re: [PATCH] bluetooth: fix variable shadow warnings
From: Marcel Holtmann @ 2013-10-07 16:17 UTC (permalink / raw)
To: Johannes Berg; +Cc: linux-wireless, linux-bluetooth, Johannes Berg
In-Reply-To: <1381157810-15310-1-git-send-email-johannes@sipsolutions.net>
Hi Johannes,
> Sparse points out three places where variables are shadowed,
> rename two of the variables and remove the duplicate third.
>
> Signed-off-by: Johannes Berg <johannes.berg@intel.com>
> ---
> net/bluetooth/hci_event.c | 12 +++++++-----
> net/bluetooth/l2cap_sock.c | 2 +-
> 2 files changed, 8 insertions(+), 6 deletions(-)
>
> diff --git a/net/bluetooth/hci_event.c b/net/bluetooth/hci_event.c
> index 94aab73..b5a3736 100644
> --- a/net/bluetooth/hci_event.c
> +++ b/net/bluetooth/hci_event.c
> @@ -1291,9 +1291,11 @@ static void hci_cs_remote_name_req(struct hci_dev *hdev, __u8 status)
> goto unlock;
>
> if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->flags)) {
> - struct hci_cp_auth_requested cp;
> - cp.handle = __cpu_to_le16(conn->handle);
> - hci_send_cmd(hdev, HCI_OP_AUTH_REQUESTED, sizeof(cp), &cp);
> + struct hci_cp_auth_requested auth_req;
can you rename this to auth_cp. The code base uses cp for command parameters.
> +
> + auth_req.handle = __cpu_to_le16(conn->handle);
> + hci_send_cmd(hdev, HCI_OP_AUTH_REQUESTED,
> + sizeof(auth_req), &auth_req);
> }
>
> unlock:
> @@ -3636,8 +3638,8 @@ void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb)
> skb_pull(skb, HCI_EVENT_HDR_SIZE);
>
> if (hdev->sent_cmd && bt_cb(hdev->sent_cmd)->req.event == event) {
> - struct hci_command_hdr *hdr = (void *) hdev->sent_cmd->data;
> - u16 opcode = __le16_to_cpu(hdr->opcode);
> + struct hci_command_hdr *cmd_hdr = (void *) hdev->sent_cmd->data;
> + u16 opcode = __le16_to_cpu(cmd_hdr->opcode);
>
> hci_req_cmd_complete(hdev, opcode, 0);
> }
> diff --git a/net/bluetooth/l2cap_sock.c b/net/bluetooth/l2cap_sock.c
> index 0098af8..f07e25d 100644
> --- a/net/bluetooth/l2cap_sock.c
> +++ b/net/bluetooth/l2cap_sock.c
> @@ -683,7 +683,7 @@ static int l2cap_sock_setsockopt(struct socket *sock, int level, int optname,
> }
>
> if (opt == BT_FLUSHABLE_OFF) {
> - struct l2cap_conn *conn = chan->conn;
> + conn = chan->conn;
> /* proceed further only when we have l2cap_conn and
> No Flush support in the LM */
> if (!conn || !lmp_no_flush_capable(conn->hcon->hdev)) {
I would have personally put this into part into a separate patch, but this way is fine as well.
Regards
Marcel
^ permalink raw reply
* [PATCH] bluetooth: fix variable shadow warnings
From: Johannes Berg @ 2013-10-07 14:56 UTC (permalink / raw)
To: linux-wireless, linux-bluetooth; +Cc: Johannes Berg
From: Johannes Berg <johannes.berg@intel.com>
Sparse points out three places where variables are shadowed,
rename two of the variables and remove the duplicate third.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
---
net/bluetooth/hci_event.c | 12 +++++++-----
net/bluetooth/l2cap_sock.c | 2 +-
2 files changed, 8 insertions(+), 6 deletions(-)
diff --git a/net/bluetooth/hci_event.c b/net/bluetooth/hci_event.c
index 94aab73..b5a3736 100644
--- a/net/bluetooth/hci_event.c
+++ b/net/bluetooth/hci_event.c
@@ -1291,9 +1291,11 @@ static void hci_cs_remote_name_req(struct hci_dev *hdev, __u8 status)
goto unlock;
if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->flags)) {
- struct hci_cp_auth_requested cp;
- cp.handle = __cpu_to_le16(conn->handle);
- hci_send_cmd(hdev, HCI_OP_AUTH_REQUESTED, sizeof(cp), &cp);
+ struct hci_cp_auth_requested auth_req;
+
+ auth_req.handle = __cpu_to_le16(conn->handle);
+ hci_send_cmd(hdev, HCI_OP_AUTH_REQUESTED,
+ sizeof(auth_req), &auth_req);
}
unlock:
@@ -3636,8 +3638,8 @@ void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb)
skb_pull(skb, HCI_EVENT_HDR_SIZE);
if (hdev->sent_cmd && bt_cb(hdev->sent_cmd)->req.event == event) {
- struct hci_command_hdr *hdr = (void *) hdev->sent_cmd->data;
- u16 opcode = __le16_to_cpu(hdr->opcode);
+ struct hci_command_hdr *cmd_hdr = (void *) hdev->sent_cmd->data;
+ u16 opcode = __le16_to_cpu(cmd_hdr->opcode);
hci_req_cmd_complete(hdev, opcode, 0);
}
diff --git a/net/bluetooth/l2cap_sock.c b/net/bluetooth/l2cap_sock.c
index 0098af8..f07e25d 100644
--- a/net/bluetooth/l2cap_sock.c
+++ b/net/bluetooth/l2cap_sock.c
@@ -683,7 +683,7 @@ static int l2cap_sock_setsockopt(struct socket *sock, int level, int optname,
}
if (opt == BT_FLUSHABLE_OFF) {
- struct l2cap_conn *conn = chan->conn;
+ conn = chan->conn;
/* proceed further only when we have l2cap_conn and
No Flush support in the LM */
if (!conn || !lmp_no_flush_capable(conn->hcon->hdev)) {
--
1.8.4.rc3
^ permalink raw reply related
* Re: [PATCH 1/2] Bluetooth: Read location data on AMP controller init
From: Johan Hedberg @ 2013-10-07 14:54 UTC (permalink / raw)
To: Marcel Holtmann; +Cc: linux-bluetooth
In-Reply-To: <1381143353-57149-1-git-send-email-marcel@holtmann.org>
Hi Marcel,
On Mon, Oct 07, 2013, Marcel Holtmann wrote:
> When initializing an AMP controller, read its current known location
> data so that it can be analyzed later on.
>
> Signed-off-by: Marcel Holtmann <marcel@holtmann.org>
> ---
> include/net/bluetooth/hci.h | 2 ++
> net/bluetooth/hci_core.c | 3 +++
> 2 files changed, 5 insertions(+)
Both patches in this set have been applied to bluetooth-next. Thanks.
Johan
^ permalink raw reply
* [RFC 2/2] android: Add PAN skeleton
From: Andrei Emeltchenko @ 2013-10-07 13:39 UTC (permalink / raw)
To: linux-bluetooth
In-Reply-To: <1381153158-13207-1-git-send-email-Andrei.Emeltchenko.news@gmail.com>
From: Frederic Danis <frederic.danis@linux.intel.com>
---
android/Android.mk | 1 +
android/hal.h | 1 +
android/hal_bluetooth.c | 4 ++
android/hal_pan.c | 130 +++++++++++++++++++++++++++++++++++++++++++++++
4 files changed, 136 insertions(+)
create mode 100644 android/hal_pan.c
diff --git a/android/Android.mk b/android/Android.mk
index d1cd2bc..453dcd3 100644
--- a/android/Android.mk
+++ b/android/Android.mk
@@ -65,6 +65,7 @@ LOCAL_SRC_FILES := \
hal_bt_sock.c \
hal_msg_client.c \
hal_hidhost.c \
+ hal_pan.c \
LOCAL_SHARED_LIBRARIES := \
libcutils \
diff --git a/android/hal.h b/android/hal.h
index be69339..38b90b2 100644
--- a/android/hal.h
+++ b/android/hal.h
@@ -17,3 +17,4 @@
btsock_interface_t *bt_get_sock_interface(void);
bthh_interface_t *bt_get_hidhost_interface(void);
+btpan_interface_t *bt_get_pan_interface(void);
diff --git a/android/hal_bluetooth.c b/android/hal_bluetooth.c
index 46cc794..636c1fe 100644
--- a/android/hal_bluetooth.c
+++ b/android/hal_bluetooth.c
@@ -23,6 +23,7 @@
#include <hardware/bluetooth.h>
#include <hardware/bt_sock.h>
#include <hardware/bt_hh.h>
+#include <hardware/bt_pan.h>
#include <cutils/sockets.h>
#include <cutils/properties.h>
@@ -313,6 +314,9 @@ static const void *get_profile_interface(const char *profile_id)
if (is_profile(profile_id, BT_PROFILE_HIDHOST_ID))
return bt_get_hidhost_interface();
+ if (is_profile(profile_id, BT_PROFILE_PAN_ID))
+ return bt_get_pan_interface();
+
return NULL;
}
diff --git a/android/hal_pan.c b/android/hal_pan.c
new file mode 100644
index 0000000..064b086
--- /dev/null
+++ b/android/hal_pan.c
@@ -0,0 +1,130 @@
+/*
+ * Copyright (C) 2013 Intel Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <stdbool.h>
+
+#include <hardware/bluetooth.h>
+#include <hardware/bt_pan.h>
+
+#define LOG_TAG "BlueZ"
+#include <cutils/log.h>
+
+const btpan_callbacks_t *bt_pan_cbacks = NULL;
+
+static bool interface_ready(void)
+{
+ return bt_pan_cbacks != NULL;
+}
+
+static bt_status_t bt_pan_enable(int local_role)
+{
+ ALOGI(__func__);
+
+ /* sanity check */
+ if (interface_ready() == false)
+ return BT_STATUS_NOT_READY;
+
+ return BT_STATUS_UNSUPPORTED;
+}
+
+static int bt_pan_get_local_role(void)
+{
+ ALOGI(__func__);
+
+ /* sanity check */
+ if (interface_ready() == false)
+ return BTPAN_ROLE_NONE;
+
+ return BTPAN_ROLE_NONE;
+}
+
+static bt_status_t bt_pan_connect(const bt_bdaddr_t *bd_addr, int local_role,
+ int remote_role)
+{
+ ALOGI(__func__);
+
+ /* sanity check */
+ if (interface_ready() == false)
+ return BT_STATUS_NOT_READY;
+
+ if (bd_addr == NULL) {
+ ALOGE("invalid parameters, bd_addr:%p", bd_addr);
+ return BT_STATUS_PARM_INVALID;
+ }
+
+ return BT_STATUS_UNSUPPORTED;
+}
+
+static bt_status_t bt_pan_disconnect(const bt_bdaddr_t *bd_addr)
+{
+ ALOGI(__func__);
+
+ /* sanity check */
+ if (interface_ready() == false)
+ return BT_STATUS_NOT_READY;
+
+ if (bd_addr == NULL) {
+ ALOGE("invalid parameters, bd_addr:%p", bd_addr);
+ return BT_STATUS_PARM_INVALID;
+ }
+
+ return BT_STATUS_UNSUPPORTED;
+}
+
+static bt_status_t bt_pan_init(const btpan_callbacks_t *callbacks)
+{
+ ALOGI(__func__);
+
+ /* store reference to user callbacks */
+ bt_pan_cbacks = callbacks;
+
+ /* TODO: start HID Host thread */
+
+ /* TODO: enable service */
+
+ return BT_STATUS_SUCCESS;
+}
+
+static void bt_pan_cleanup()
+{
+ ALOGI(__func__);
+
+ /* sanity check */
+ if (interface_ready() == false)
+ return;
+
+ /* TODO: disable service */
+
+ /* TODO: stop PAN thread */
+
+ bt_pan_cbacks = NULL;
+}
+
+static btpan_interface_t bt_pan_if = {
+ sizeof(bt_pan_if),
+ bt_pan_init,
+ bt_pan_enable,
+ bt_pan_get_local_role,
+ bt_pan_connect,
+ bt_pan_disconnect,
+ bt_pan_cleanup
+};
+
+btpan_interface_t *bt_get_pan_interface()
+{
+ return &bt_pan_if;
+}
--
1.7.10.4
^ permalink raw reply related
* [RFC 1/2] android: Add HID Host skeleton
From: Andrei Emeltchenko @ 2013-10-07 13:39 UTC (permalink / raw)
To: linux-bluetooth
In-Reply-To: <1381153158-13207-1-git-send-email-Andrei.Emeltchenko.news@gmail.com>
From: Frederic Danis <frederic.danis@linux.intel.com>
---
android/Android.mk | 1 +
android/hal.h | 1 +
android/hal_bluetooth.c | 4 +
android/hal_hidhost.c | 232 +++++++++++++++++++++++++++++++++++++++++++++++
4 files changed, 238 insertions(+)
create mode 100644 android/hal_hidhost.c
diff --git a/android/Android.mk b/android/Android.mk
index cb156d3..d1cd2bc 100644
--- a/android/Android.mk
+++ b/android/Android.mk
@@ -64,6 +64,7 @@ LOCAL_SRC_FILES := \
hal_cb_thread.c \
hal_bt_sock.c \
hal_msg_client.c \
+ hal_hidhost.c \
LOCAL_SHARED_LIBRARIES := \
libcutils \
diff --git a/android/hal.h b/android/hal.h
index 40fbf03..be69339 100644
--- a/android/hal.h
+++ b/android/hal.h
@@ -16,3 +16,4 @@
*/
btsock_interface_t *bt_get_sock_interface(void);
+bthh_interface_t *bt_get_hidhost_interface(void);
diff --git a/android/hal_bluetooth.c b/android/hal_bluetooth.c
index f8139a7..46cc794 100644
--- a/android/hal_bluetooth.c
+++ b/android/hal_bluetooth.c
@@ -22,6 +22,7 @@
#include <hardware/bluetooth.h>
#include <hardware/bt_sock.h>
+#include <hardware/bt_hh.h>
#include <cutils/sockets.h>
#include <cutils/properties.h>
@@ -309,6 +310,9 @@ static const void *get_profile_interface(const char *profile_id)
if (is_profile(profile_id, BT_PROFILE_SOCKETS_ID))
return bt_get_sock_interface();
+ if (is_profile(profile_id, BT_PROFILE_HIDHOST_ID))
+ return bt_get_hidhost_interface();
+
return NULL;
}
diff --git a/android/hal_hidhost.c b/android/hal_hidhost.c
new file mode 100644
index 0000000..7340b11
--- /dev/null
+++ b/android/hal_hidhost.c
@@ -0,0 +1,232 @@
+/*
+ * Copyright (C) 2013 Intel Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <stdbool.h>
+
+#include <hardware/bluetooth.h>
+#include <hardware/bt_hh.h>
+
+#define LOG_TAG "BlueZ"
+#include <cutils/log.h>
+
+bthh_callbacks_t *bt_hh_cbacks;
+
+static bool interface_ready(void)
+{
+ return bt_hh_cbacks != NULL;
+}
+
+static bt_status_t bt_hidhost_connect(bt_bdaddr_t *bd_addr)
+{
+ ALOGI(__func__);
+
+ /* sanity check */
+ if (interface_ready() == false)
+ return BT_STATUS_NOT_READY;
+
+ if (bd_addr == NULL) {
+ ALOGE("invalid parameters, bd_addr:%p", bd_addr);
+ return BT_STATUS_PARM_INVALID;
+ }
+
+ return BT_STATUS_UNSUPPORTED;
+}
+
+static bt_status_t bt_hidhost_disconnect(bt_bdaddr_t *bd_addr)
+{
+ ALOGI(__func__);
+
+ /* sanity check */
+ if (interface_ready() == false)
+ return BT_STATUS_NOT_READY;
+
+ if (bd_addr == NULL) {
+ ALOGE("invalid parameters, bd_addr:%p", bd_addr);
+ return BT_STATUS_PARM_INVALID;
+ }
+
+ return BT_STATUS_UNSUPPORTED;
+}
+
+static bt_status_t bt_hidhost_virtual_unplug(bt_bdaddr_t *bd_addr)
+{
+ ALOGI(__func__);
+
+ /* sanity check */
+ if (interface_ready() == false)
+ return BT_STATUS_NOT_READY;
+
+ if (bd_addr == NULL) {
+ ALOGE("invalid parameters, bd_addr:%p", bd_addr);
+ return BT_STATUS_PARM_INVALID;
+ }
+
+ return BT_STATUS_UNSUPPORTED;
+}
+
+static bt_status_t bt_hidhost_set_info(bt_bdaddr_t *bd_addr,
+ bthh_hid_info_t hid_info)
+{
+ ALOGI(__func__);
+
+ /* sanity check */
+ if (interface_ready() == false)
+ return BT_STATUS_NOT_READY;
+
+ if (bd_addr == NULL) {
+ ALOGE("invalid parameters, bd_addr:%p", bd_addr);
+ return BT_STATUS_PARM_INVALID;
+ }
+
+ return BT_STATUS_UNSUPPORTED;
+}
+
+static bt_status_t bt_hidhost_get_protocol(bt_bdaddr_t *bd_addr,
+ bthh_protocol_mode_t protocolMode)
+{
+ ALOGI(__func__);
+
+ /* sanity check */
+ if (interface_ready() == false)
+ return BT_STATUS_NOT_READY;
+
+ if (bd_addr == NULL) {
+ ALOGE("invalid parameters, bd_addr:%p", bd_addr);
+ return BT_STATUS_PARM_INVALID;
+ }
+
+ return BT_STATUS_UNSUPPORTED;
+}
+
+static bt_status_t bt_hidhost_set_protocol(bt_bdaddr_t *bd_addr,
+ bthh_protocol_mode_t protocolMode)
+{
+ ALOGI(__func__);
+
+ /* sanity check */
+ if (interface_ready() == false)
+ return BT_STATUS_NOT_READY;
+
+ if (bd_addr == NULL) {
+ ALOGE("invalid parameters, bd_addr:%p", bd_addr);
+ return BT_STATUS_PARM_INVALID;
+ }
+
+ return BT_STATUS_UNSUPPORTED;
+}
+
+static bt_status_t bt_hidhost_get_report(bt_bdaddr_t *bd_addr,
+ bthh_report_type_t reportType,
+ uint8_t reportId,
+ int bufferSize)
+{
+ ALOGI(__func__);
+
+ /* sanity check */
+ if (interface_ready() == false)
+ return BT_STATUS_NOT_READY;
+
+ if (bd_addr == NULL) {
+ ALOGE("invalid parameters, bd_addr:%p", bd_addr);
+ return BT_STATUS_PARM_INVALID;
+ }
+
+ return BT_STATUS_UNSUPPORTED;
+}
+
+static bt_status_t bt_hidhost_set_report(bt_bdaddr_t *bd_addr,
+ bthh_report_type_t reportType,
+ char *report)
+{
+ ALOGI(__func__);
+
+ /* sanity check */
+ if (interface_ready() == false)
+ return BT_STATUS_NOT_READY;
+
+ if (bd_addr == NULL || report == NULL) {
+ ALOGE("invalid parameters, bd_addr:%p", bd_addr);
+ return BT_STATUS_PARM_INVALID;
+ }
+
+ return BT_STATUS_UNSUPPORTED;
+}
+
+static bt_status_t bt_hidhost_send_data(bt_bdaddr_t *bd_addr, char *data)
+{
+ ALOGI(__func__);
+
+ /* sanity check */
+ if (interface_ready() == false)
+ return BT_STATUS_NOT_READY;
+
+ if (bd_addr == NULL || data == NULL) {
+ ALOGE("invalid parameters, bd_addr:%p", bd_addr);
+ return BT_STATUS_PARM_INVALID;
+ }
+
+ return BT_STATUS_UNSUPPORTED;
+}
+
+static bt_status_t bt_hidhost_init(bthh_callbacks_t *callbacks)
+{
+ ALOGI(__func__);
+
+ /* store reference to user callbacks */
+ bt_hh_cbacks = callbacks;
+
+ /* TODO: start HID Host thread */
+
+ /* TODO: enable service */
+
+ return BT_STATUS_SUCCESS;
+}
+
+static void bt_hidhost_cleanup(void)
+{
+ ALOGI(__func__);
+
+ /* sanity check */
+ if (interface_ready() == false)
+ return;
+
+ /* TODO: disable service */
+
+ /* TODO: stop HID Host thread */
+
+ bt_hh_cbacks = NULL;
+}
+
+static bthh_interface_t bt_hidhost_if = {
+ sizeof(bt_hidhost_if),
+ bt_hidhost_init,
+ bt_hidhost_connect,
+ bt_hidhost_disconnect,
+ bt_hidhost_virtual_unplug,
+ bt_hidhost_set_info,
+ bt_hidhost_get_protocol,
+ bt_hidhost_set_protocol,
+ bt_hidhost_get_report,
+ bt_hidhost_set_report,
+ bt_hidhost_send_data,
+ bt_hidhost_cleanup
+};
+
+bthh_interface_t *bt_get_hidhost_interface(void)
+{
+ return &bt_hidhost_if;
+}
--
1.7.10.4
^ permalink raw reply related
* [RFC 0/2] Initial code for PAN and HID HALs
From: Andrei Emeltchenko @ 2013-10-07 13:39 UTC (permalink / raw)
To: linux-bluetooth
From: Andrei Emeltchenko <andrei.emeltchenko@intel.com>
Slightly modified code from Frederic Danis.
Frederic Danis (2):
android: Add HID Host skeleton
android: Add PAN skeleton
android/Android.mk | 2 +
android/hal.h | 2 +
android/hal_bluetooth.c | 8 ++
android/hal_hidhost.c | 232 +++++++++++++++++++++++++++++++++++++++++++++++
android/hal_pan.c | 130 ++++++++++++++++++++++++++
5 files changed, 374 insertions(+)
create mode 100644 android/hal_hidhost.c
create mode 100644 android/hal_pan.c
--
1.7.10.4
^ permalink raw reply
* [RFC 2/2] android: Add HAL message helpers
From: Andrei Emeltchenko @ 2013-10-07 13:37 UTC (permalink / raw)
To: linux-bluetooth
In-Reply-To: <1381153036-12631-1-git-send-email-Andrei.Emeltchenko.news@gmail.com>
From: Andrei Emeltchenko <andrei.emeltchenko@intel.com>
Add helper to ease opening channel and sending commands.
---
android/Android.mk | 1 +
android/hal_msg_client.c | 123 ++++++++++++++++++++++++++++++++++++++++++++++
android/hal_msg_client.h | 25 ++++++++++
3 files changed, 149 insertions(+)
create mode 100644 android/hal_msg_client.c
create mode 100644 android/hal_msg_client.h
diff --git a/android/Android.mk b/android/Android.mk
index cc5c024..3000feb 100644
--- a/android/Android.mk
+++ b/android/Android.mk
@@ -62,6 +62,7 @@ include $(CLEAR_VARS)
LOCAL_SRC_FILES := \
hal_bluetooth.c \
hal_bt_sock.c \
+ hal_msg_client.c \
LOCAL_SHARED_LIBRARIES := \
libcutils \
diff --git a/android/hal_msg_client.c b/android/hal_msg_client.c
new file mode 100644
index 0000000..fa19599
--- /dev/null
+++ b/android/hal_msg_client.c
@@ -0,0 +1,123 @@
+/*
+ *
+ * BlueZ - Bluetooth protocol stack for Linux
+ *
+ * Copyright (C) 2013 Intel Corporation. All rights reserved.
+ *
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <stdbool.h>
+
+#include <hardware/bluetooth.h>
+#include <cutils/sockets.h>
+#include <cutils/properties.h>
+
+#define LOG_TAG "BlueZ"
+#include <cutils/log.h>
+
+#include "hal_msg.h"
+#include "hal_msg_client.h"
+
+#define BLUEZ_SOCKET "/tmp/bt_hal"
+
+int open_hal_chan(void)
+{
+ int tries = 10;
+ int sock;
+
+ while (tries-- > 0) {
+ sock = socket_local_client(BLUEZ_SOCKET,
+ ANDROID_SOCKET_NAMESPACE_FILESYSTEM,
+ SOCK_SEQPACKET);
+ if (sock < 0)
+ ALOGE("%s: Cannot open chan: %s", __func__,
+ strerror(errno));
+ else
+ return sock;
+
+ usleep(100000);
+ }
+
+ return sock;
+}
+
+static int hal_send(int sock, struct hal_msg_hdr *msg)
+{
+ int len, size;
+ uint8_t buf[MAX_HAL_BUF_SIZE];
+ struct hal_msg_rsp {
+ struct hal_msg_hdr hdr;
+ uint8_t status;
+ } *rsp;
+
+ if (sock < 0) {
+ ALOGE("%s: socket not ready", __func__);
+ return BT_STATUS_NOT_READY;
+ }
+
+ size = sizeof(*msg) + msg->len;
+ len = send(sock, msg, size, 0);
+ if (len != size) {
+ ALOGE("%s: send(): %s", __func__, strerror(errno));
+ close(sock);
+ return BT_STATUS_FAIL;
+ }
+
+ ALOGD("%s: Sent %d bytes", __func__, len);
+
+ len = recv(sock, &buf, sizeof(buf), 0);
+ if (len <= 0) {
+ ALOGE("%s: recv(): %s", __func__, strerror(errno));
+ return BT_STATUS_FAIL;
+ }
+
+ if (len == sizeof(struct hal_msg_hdr))
+ return BT_STATUS_SUCCESS;
+
+ rsp = (struct hal_msg_rsp *) buf;
+
+ ALOGE("%s: error returned: %u", __func__, rsp->status);
+
+ return rsp->status;
+}
+
+int hal_register_module(int sock, uint8_t service_id)
+{
+ struct hal_msg_hdr *hdr;
+ struct hal_msg_cp_register_module *msg;
+ int err;
+
+ hdr = malloc(sizeof(*hdr) + sizeof(*msg));
+ if (hdr == NULL)
+ return BT_STATUS_NOMEM;
+
+ hdr->service_id = 0;
+ hdr->opcode = HAL_MSG_OP_REGISTER_MODULE;
+ hdr->len = sizeof(*msg);
+
+ msg = (struct hal_msg_cp_register_module *) hdr->payload;
+ msg->service_id = service_id;
+
+ err = hal_send(sock, hdr);
+
+ free(hdr);
+ return err;
+}
diff --git a/android/hal_msg_client.h b/android/hal_msg_client.h
new file mode 100644
index 0000000..c620dea
--- /dev/null
+++ b/android/hal_msg_client.h
@@ -0,0 +1,25 @@
+/*
+ *
+ * BlueZ - Bluetooth protocol stack for Linux
+ *
+ * Copyright (C) 2013 Intel Corporation. All rights reserved.
+ *
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+int hal_register_module(int sock, uint8_t service_id);
+int open_hal_chan(void);
--
1.7.10.4
^ permalink raw reply related
* [RFC 1/2] android: Implement basic HAL server
From: Andrei Emeltchenko @ 2013-10-07 13:37 UTC (permalink / raw)
To: linux-bluetooth
In-Reply-To: <1381153036-12631-1-git-send-email-Andrei.Emeltchenko.news@gmail.com>
From: Andrei Emeltchenko <andrei.emeltchenko@intel.com>
Add basic HAL server on BlueZ daemon side. It will listen for messages
from Android HAL threads.
---
Makefile.android | 3 +-
android/Android.mk | 1 +
android/hal_msg.c | 267 ++++++++++++++++++++++++++++++++++++++++++++++++++++
android/hal_msg.h | 5 +
android/main.c | 10 ++
5 files changed, 285 insertions(+), 1 deletion(-)
create mode 100644 android/hal_msg.c
diff --git a/Makefile.android b/Makefile.android
index d576b52..4da136b 100644
--- a/Makefile.android
+++ b/Makefile.android
@@ -6,7 +6,8 @@ android_bluetoothd_SOURCES = android/main.c src/log.c \
src/sdpd-service.c src/sdpd-request.c \
src/shared/util.h src/shared/util.c \
src/shared/mgmt.h src/shared/mgmt.c \
- android/bt_adapter.h android/bt_adapter.c
+ android/bt_adapter.h android/bt_adapter.c \
+ android/hal_msg.h android/hal_msg.c
android_bluetoothd_LDADD = lib/libbluetooth-internal.la @GLIB_LIBS@
endif
diff --git a/android/Android.mk b/android/Android.mk
index 5798749..cc5c024 100644
--- a/android/Android.mk
+++ b/android/Android.mk
@@ -18,6 +18,7 @@ LOCAL_SRC_FILES := \
../src/shared/mgmt.c \
../src/shared/util.c \
bt_adapter.c \
+ hal_msg.c \
../src/sdpd-database.c \
../src/sdpd-service.c \
../src/sdpd-request.c \
diff --git a/android/hal_msg.c b/android/hal_msg.c
new file mode 100644
index 0000000..fb7b7a3
--- /dev/null
+++ b/android/hal_msg.c
@@ -0,0 +1,267 @@
+/*
+ *
+ * BlueZ - Bluetooth protocol stack for Linux
+ *
+ * Copyright (C) 2013 Intel Corporation. All rights reserved.
+ *
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <sys/stat.h>
+
+#include <glib.h>
+
+#include "log.h"
+#include "hal_msg.h"
+
+static guint watch_id = 0;
+
+static uint8_t hal_register_module(struct hal_msg_hdr *msg)
+{
+ DBG("");
+
+ return 0;
+}
+
+static uint8_t hal_unregister_module(struct hal_msg_hdr *msg)
+{
+ DBG("");
+
+ return 0;
+}
+
+static uint8_t process_hal_service_chan(struct hal_msg_hdr *msg)
+{
+ uint8_t status = -1;
+
+ DBG("");
+
+ switch (msg->opcode) {
+ case HAL_MSG_OP_REGISTER_MODULE:
+ status = hal_register_module(msg);
+ break;
+ case HAL_MSG_OP_UNREGISTER_MODULE:
+ status = hal_unregister_module(msg);
+ break;
+ default:
+ error("%s: unrecognized command on service channel", __func__);
+ break;
+ }
+
+ return status;
+}
+
+static uint8_t sanity_check(struct hal_msg_hdr *msg)
+{
+ /* TODO: Add sanity check here */
+
+ return 0;
+}
+
+static uint8_t process_hal_msg(uint8_t *buf, int len)
+{
+ struct hal_msg_hdr *msg = (struct hal_msg_hdr *) buf;
+ uint8_t status;
+
+ DBG("");
+
+ status = sanity_check(msg);
+ if (status != 0)
+ return status;
+
+ if (msg->service_id == 0)
+ status = process_hal_service_chan(msg);
+
+ return status;
+}
+
+static gboolean io_session_event(GIOChannel *chan, GIOCondition cond,
+ gpointer data)
+{
+ struct hal_msg_hdr *hdr;
+ uint8_t buf[MAX_HAL_BUF_SIZE];
+ int sock, len;
+ uint8_t status;
+
+ if (cond & G_IO_NVAL)
+ return FALSE;
+
+ sock = g_io_channel_unix_get_fd(chan);
+
+ if (cond & (G_IO_HUP | G_IO_ERR)) {
+ error("%s: error condition %d", __func__, cond);
+ /* TODO: handle */
+ return FALSE;
+ }
+
+ len = recv(sock, buf, sizeof(buf), 0);
+ if (len <= 0) {
+ error("%s: recv(): %s", __func__, strerror(errno));
+ /* TODO: handle */
+ return FALSE;
+ }
+
+ if (len < (int) sizeof(struct hal_msg_hdr))
+ return FALSE;
+
+ status = process_hal_msg(buf, len);
+
+ hdr = (struct hal_msg_hdr *) buf;
+
+ if (status == 0) {
+ /* Success reply */
+ len = send(sock, hdr, sizeof(*hdr), 0);
+ if (len != sizeof(hdr)) {
+ error("%s: send() rsp: %s", __func__, strerror(errno));
+ /* TODO: handle */
+ return FALSE;
+ }
+ } else {
+ struct hal_msg_rsp {
+ struct hal_msg_hdr hdr;
+ uint8_t status;
+ } rsp;
+
+ rsp.hdr.service_id = hdr->service_id;
+ rsp.hdr.opcode = HAL_MSG_OP_ERROR;
+ rsp.hdr.len = sizeof(rsp.status);
+ rsp.status = status;
+
+ len = send(sock, &rsp, sizeof(rsp), 0);
+ if (len != sizeof(rsp)) {
+ error("%s: send() rsp: %s", __func__, strerror(errno));
+ /* TODO: handle */
+ return FALSE;
+ }
+ }
+
+ return TRUE;
+}
+
+static gboolean io_accept_event(GIOChannel *chan, GIOCondition cond,
+ gpointer data)
+{
+ GIOChannel *io;
+ int sock, nsk;
+ struct sockaddr_un addr;
+ socklen_t len = sizeof(addr);
+
+ DBG("");
+
+ if (cond & (G_IO_HUP | G_IO_ERR | G_IO_NVAL))
+ return FALSE;
+
+ sock = g_io_channel_unix_get_fd(chan);
+
+ nsk = accept(sock, (struct sockaddr *) &addr, &len);
+ if (nsk < 0) {
+ error("%s: accept(): %s", __func__, strerror(errno));
+ return TRUE;
+ }
+
+ io = g_io_channel_unix_new(nsk);
+ g_io_channel_set_close_on_unref(io, TRUE);
+
+ g_io_add_watch(io, G_IO_IN | G_IO_ERR | G_IO_HUP | G_IO_NVAL,
+ io_session_event, data);
+
+ g_io_channel_unref(io);
+
+ return TRUE;
+}
+
+static int init_hal_socket(const char *sock_path)
+{
+ struct sockaddr_un addr;
+ int sock;
+ size_t len;
+
+ DBG("");
+
+ sock = socket(AF_UNIX, SOCK_SEQPACKET, 0);
+ if (sock < 0) {
+ error("%s: socket(): %s", __func__, strerror(errno));
+ return sock;
+ }
+
+ len = strlen(sock_path);
+ if (len > sizeof(addr.sun_path) - 1) {
+ error("%s: too big socket name", __func__);
+ return -1;
+ }
+
+ memset(&addr, 0, sizeof(addr));
+ addr.sun_family = AF_UNIX;
+ strcpy(addr.sun_path, sock_path);
+
+ /* let fail for android */
+ if (unlink(addr.sun_path) < 0)
+ warn("%s: unlink() %s failed: %s", __func__, sock_path,
+ strerror(errno));
+
+ if (bind(sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
+ error("%s: bind(): %s", __func__, strerror(errno));
+ return -1;
+ }
+
+ if (listen(sock, 5) < 0) {
+ error("%s: listen(): %s", __func__, strerror(errno));
+ return -1;
+ }
+
+ chmod(sock_path, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
+
+ return sock;
+}
+
+void start_hal_srv(const char *sock_path)
+{
+ GIOChannel *io;
+ int sock;
+
+ DBG("");
+
+ sock = init_hal_socket(sock_path);
+ if (sock < 0)
+ return;
+
+ io = g_io_channel_unix_new(sock);
+ g_io_channel_set_close_on_unref(io, TRUE);
+
+ watch_id = g_io_add_watch(io, G_IO_IN | G_IO_ERR | G_IO_HUP | G_IO_NVAL,
+ io_accept_event, &sock);
+}
+
+void stop_hal_srv(void)
+{
+ DBG("");
+
+ if (watch_id > 0)
+ g_source_remove(watch_id);
+
+ watch_id = 0;
+}
diff --git a/android/hal_msg.h b/android/hal_msg.h
index c6bc883..63551c3 100644
--- a/android/hal_msg.h
+++ b/android/hal_msg.h
@@ -29,6 +29,9 @@ typedef struct {
uint8_t b[6];
} __packed __bdaddr_t;
+void start_hal_srv(const char *sock_path);
+void stop_hal_srv(void);
+
struct hal_msg_hdr {
uint8_t service_id;
uint8_t opcode;
@@ -47,6 +50,8 @@ struct hal_msg_hdr {
#define HAL_SERVICE_ID_AVRCP 8
#define HAL_SERVICE_ID_GATT 9
+#define MAX_HAL_BUF_SIZE 1024
+
/* Core Service */
#define HAL_MSG_OP_ERROR 0x00
diff --git a/android/main.c b/android/main.c
index bfd30d5..8a58371 100644
--- a/android/main.c
+++ b/android/main.c
@@ -60,6 +60,14 @@
#include "lib/mgmt.h"
#include "src/shared/mgmt.h"
+#include "hal_msg.h"
+
+#if defined(__ANDROID_API__)
+#define BT_HAL_SOCKET "/tmp/bt_hal"
+#else
+#define BT_HAL_SOCKET "/var/run/bt_hal"
+#endif
+
#define SHUTDOWN_GRACE_SECONDS 10
struct main_opts main_opts;
@@ -617,11 +625,13 @@ int main(int argc, char *argv[])
init_mgmt_interface();
sdp_start();
+ start_hal_srv(BT_HAL_SOCKET);
DBG("Entering main loop");
g_main_loop_run(event_loop);
+ stop_hal_srv();
sdp_stop();
cleanup_mgmt_interface();
g_main_loop_unref(event_loop);
--
1.7.10.4
^ permalink raw reply related
* [RFC 0/2] Basic code for HAL API
From: Andrei Emeltchenko @ 2013-10-07 13:37 UTC (permalink / raw)
To: linux-bluetooth
From: Andrei Emeltchenko <andrei.emeltchenko@intel.com>
Please comment what is the way to split code between common shared part
and HAL and daemon related.
Currently hal_msg.c is used by "server" - BlueZ daemon and hal_msg_client.c is used
by "client" - Android HAL.
Andrei Emeltchenko (2):
android: Implement basic HAL server
android: Add HAL message helpers
Makefile.android | 3 +-
android/Android.mk | 2 +
android/hal_msg.c | 267 ++++++++++++++++++++++++++++++++++++++++++++++
android/hal_msg.h | 5 +
android/hal_msg_client.c | 123 +++++++++++++++++++++
android/hal_msg_client.h | 25 +++++
android/main.c | 10 ++
7 files changed, 434 insertions(+), 1 deletion(-)
create mode 100644 android/hal_msg.c
create mode 100644 android/hal_msg_client.c
create mode 100644 android/hal_msg_client.h
--
1.7.10.4
^ permalink raw reply
* Re: [PATCH] Bluetooth: Read supported features and commands on AMP controllers
From: Johan Hedberg @ 2013-10-07 12:53 UTC (permalink / raw)
To: Marcel Holtmann; +Cc: linux-bluetooth
In-Reply-To: <1381138299-49639-1-git-send-email-marcel@holtmann.org>
Hi Marcel,
On Mon, Oct 07, 2013, Marcel Holtmann wrote:
> The commands for reading supported features and commands are both
> supported by AMP controllers. Issue them during controller init
> phase so their values are known.
>
> Signed-off-by: Marcel Holtmann <marcel@holtmann.org>
> ---
> net/bluetooth/hci_core.c | 6 ++++++
> 1 file changed, 6 insertions(+)
Applied to bluetooth-next. Thanks.
Johan
^ permalink raw reply
* Re: [PATCHv1 12/15] android: Implement read_info_complete callback
From: Andrei Emeltchenko @ 2013-10-07 12:26 UTC (permalink / raw)
To: linux-bluetooth
In-Reply-To: <1381131496-9417-13-git-send-email-Andrei.Emeltchenko.news@gmail.com>
On Mon, Oct 07, 2013 at 10:38:13AM +0300, Andrei Emeltchenko wrote:
> From: Andrei Emeltchenko <andrei.emeltchenko@intel.com>
>
> Handle read info complete callback from mgmt interface.
> ---
> android/main.c | 102 +++++++++++++++++++++++++++++++++++++++++++++++++-------
> 1 file changed, 90 insertions(+), 12 deletions(-)
>
> diff --git a/android/main.c b/android/main.c
> index dab54ce..3a63eb9 100644
> --- a/android/main.c
> +++ b/android/main.c
> @@ -54,6 +54,7 @@
> #include "log.h"
> #include "hcid.h"
> #include "sdpd.h"
> +#include "bt_adapter.h"
>
> #include "lib/bluetooth.h"
> #include "lib/mgmt.h"
> @@ -69,6 +70,8 @@ static struct mgmt *mgmt_if = NULL;
> static uint8_t mgmt_version = 0;
> static uint8_t mgmt_revision = 0;
>
> +struct bt_adapter *default_adapter = NULL;
> +
> static int sdp_start(void)
> {
> DBG("");
> @@ -118,34 +121,109 @@ static GOptionEntry options[] = {
> { NULL }
> };
>
> -static void read_info_complete(uint8_t status, uint16_t length,
> +static void load_link_keys_complete(uint8_t status, uint16_t length,
> const void *param, void *user_data)
> {
> - /* TODO: Store Controller information */
> -
> - /**
> - * Register all event notification handlers for controller.
> - *
> - * The handlers are registered after a succcesful read of the
> - * controller info. From now on they can track updates and
> - * notifications.
> - */
> + DBG("status %u", status);
> }
>
> +static void load_link_keys(struct bt_adapter *adapter, GSList *keys)
> +{
> + struct mgmt_cp_load_link_keys *cp;
> + uint16_t key_len = g_slist_length(keys);
> + struct mgmt_link_key_info *key;
> + uint16_t len;
> +
> + DBG("");
> +
> + len = sizeof(*cp) + key_len * sizeof(*key);
> + cp = malloc(len);
> + if (cp == NULL) {
> + error("%s: Not enough memory for link keys loading", __func__);
> + return;
> + }
> +
> + cp->debug_keys = 0;
> + cp->key_count = htobs(key_len);
> +
> + mgmt_send(adapter->mgmt, MGMT_OP_LOAD_LINK_KEYS, adapter->dev_id, len,
> + cp, load_link_keys_complete, adapter, NULL);
> +
> + free(cp);
> +}
> +
> +static void read_info_complete(uint8_t status, uint16_t length,
> + const void *param, void *user_data)
> +{
> + const struct mgmt_rp_read_info *rp = param;
> +
> + DBG("");
> +
> + if (status != MGMT_STATUS_SUCCESS) {
> + error("Failed to read info for index %u: %s (0x%02x)",
> + default_adapter->dev_id, mgmt_errstr(status), status);
> + goto failed;
> + }
> +
> + if (length < sizeof(*rp)) {
> + error("Too small read info complete response");
> + goto failed;
> + }
> +
> + if (bacmp(&rp->bdaddr, BDADDR_ANY) == 0) {
> + error("No Bluetooth address for index %u",
> + default_adapter->dev_id);
> + goto failed;
> + }
> +
> + /* Store adapter information */
> + bacpy(&default_adapter->bdaddr, &rp->bdaddr);
> + default_adapter->dev_class = rp->dev_class[0] |
> + (rp->dev_class[1] << 8) |
> + (rp->dev_class[2] << 16);
> + default_adapter->name = g_strdup((const char *) rp->name);
> + default_adapter->short_name = g_strdup((const char *) rp->short_name);
> +
> + default_adapter->supported_settings = btohs(rp->supported_settings);
> + default_adapter->current_settings = btohs(rp->current_settings);
> +
> + /* TODO: Register all event notification handlers */
> +
> + if (default_adapter->current_settings & MGMT_SETTING_POWERED)
> + adapter_start(default_adapter);
> +
> + /* dummy link keys loading */
> + load_link_keys(default_adapter, NULL);
> +
> + return;
> +
> +failed:
> + default_adapter = NULL;
> +}
>
> static void mgmt_index_added_event(uint16_t index, uint16_t length,
> const void *param, void *user_data)
> {
> info("%s: index %u", __func__, index);
>
> + if (default_adapter == NULL) {
sorry, this should be != NULL
I will send updated version soon.
Best regards
Andrei Emeltchenko
^ permalink raw reply
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox