* [PATCH 2/4] android: Fix typo
From: Andrzej Kaczmarek @ 2014-01-15 21:01 UTC (permalink / raw)
To: linux-bluetooth; +Cc: Andrzej Kaczmarek
In-Reply-To: <1389819699-12055-1-git-send-email-andrzej.kaczmarek@tieto.com>
---
android/bluetoothd-snoop.c | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/android/bluetoothd-snoop.c b/android/bluetoothd-snoop.c
index 23e0bfd..9312c11 100644
--- a/android/bluetoothd-snoop.c
+++ b/android/bluetoothd-snoop.c
@@ -37,7 +37,7 @@
#include "monitor/mainloop.h"
#include "src/shared/btsnoop.h"
-#define DEAULT_SNOOP_FILE "/sdcard/btsnoop_hci.log"
+#define DEFAULT_SNOOP_FILE "/sdcard/btsnoop_hci.log"
#define MAX_PACKET_SIZE (1486 + 4)
@@ -196,7 +196,7 @@ int main(int argc, char *argv[])
if (argc > 1)
path = argv[1];
else
- path = DEAULT_SNOOP_FILE;
+ path = DEFAULT_SNOOP_FILE;
mainloop_init();
--
1.8.5.2
^ permalink raw reply related
* [PATCH 1/4] android: Add simple rotation of snoop file
From: Andrzej Kaczmarek @ 2014-01-15 21:01 UTC (permalink / raw)
To: linux-bluetooth; +Cc: Andrzej Kaczmarek
Already existing snoop file is renamed by adding ".old" suffix before
new one is created. This is useful in case phone is restarted so logs
are not overwritten and for this reason it's only applied in case
default snoop file name is used.
---
android/bluetoothd-snoop.c | 3 +++
1 file changed, 3 insertions(+)
diff --git a/android/bluetoothd-snoop.c b/android/bluetoothd-snoop.c
index 02f44e9..23e0bfd 100644
--- a/android/bluetoothd-snoop.c
+++ b/android/bluetoothd-snoop.c
@@ -206,6 +206,9 @@ int main(int argc, char *argv[])
mainloop_set_signal(&mask, signal_callback, NULL, NULL);
+ if (!strcmp(DEFAULT_SNOOP_FILE, path))
+ rename(DEFAULT_SNOOP_FILE, DEFAULT_SNOOP_FILE ".old");
+
if (open_monitor(path) < 0) {
printf("Failed to start bluetoothd_snoop\n");
return EXIT_FAILURE;
--
1.8.5.2
^ permalink raw reply related
* [PATCH 5/5] android/ipc-tester: Add next command test case
From: Marcin Kraglak @ 2014-01-15 19:12 UTC (permalink / raw)
To: linux-bluetooth
In-Reply-To: <1389813150-16914-1-git-send-email-marcin.kraglak@tieto.com>
This case will register service, next unregister it and send
command. Expected status is raise SIGTERM.
---
android/test-android-ipc.c | 36 ++++++++++++++++++++++++++++++++++++
1 file changed, 36 insertions(+)
diff --git a/android/test-android-ipc.c b/android/test-android-ipc.c
index 930f9f4..1fde61b 100644
--- a/android/test-android-ipc.c
+++ b/android/test-android-ipc.c
@@ -306,6 +306,16 @@ static gboolean register_service(gpointer user_data)
return FALSE;
}
+static gboolean unregister_service(gpointer user_data)
+{
+ struct context *context = user_data;
+ const struct test_data *test_data = context->data;
+
+ ipc_unregister(test_data->service);
+
+ return FALSE;
+}
+
static void test_cmd(gconstpointer data)
{
struct context *context = create_context(data);
@@ -336,6 +346,21 @@ static void test_cmd_reg(gconstpointer data)
ipc_cleanup();
}
+static void test_cmd_reg_1(gconstpointer data)
+{
+ struct context *context = create_context(data);
+
+ ipc_init();
+
+ g_idle_add(register_service, context);
+ g_idle_add(unregister_service, context);
+ g_idle_add(send_cmd, context);
+
+ execute_context(context);
+
+ ipc_cleanup();
+}
+
static void test_cmd_handler(const void *buf, uint16_t len)
{
ipc_send_rsp(0, 1, 0);
@@ -367,6 +392,15 @@ static const struct test_data test_cmd_2 = {
.handlers_size = 1
};
+static const struct test_data test_cmd_3 = {
+ .cmd = &test_cmd_1_hdr,
+ .cmd_size = sizeof(test_cmd_1_hdr),
+ .service = 0,
+ .handlers = cmd_handlers,
+ .handlers_size = 1,
+ .expected_signal = SIGTERM
+};
+
int main(int argc, char *argv[])
{
g_test_init(&argc, &argv, NULL);
@@ -378,6 +412,8 @@ int main(int argc, char *argv[])
g_test_add_data_func("/android_ipc/send_cmd_1", &test_cmd_1, test_cmd);
g_test_add_data_func("/android_ipc/send_cmd_2", &test_cmd_2,
test_cmd_reg);
+ g_test_add_data_func("/android_ipc/send_cmd_3", &test_cmd_3,
+ test_cmd_reg_1);
return g_test_run();
}
--
1.8.3.1
^ permalink raw reply related
* [PATCH 4/5] android/ipc-tester: Add test case to send cmd to registered service
From: Marcin Kraglak @ 2014-01-15 19:12 UTC (permalink / raw)
To: linux-bluetooth
In-Reply-To: <1389813150-16914-1-git-send-email-marcin.kraglak@tieto.com>
This will test sending command to previously registered service.
---
android/test-android-ipc.c | 62 ++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 62 insertions(+)
diff --git a/android/test-android-ipc.c b/android/test-android-ipc.c
index 99f8559..930f9f4 100644
--- a/android/test-android-ipc.c
+++ b/android/test-android-ipc.c
@@ -46,6 +46,9 @@ struct test_data {
uint32_t expected_signal;
const struct hal_hdr *cmd;
uint16_t cmd_size;
+ uint8_t service;
+ const struct ipc_handler *handlers;
+ uint8_t handlers_size;
};
struct context {
@@ -74,11 +77,23 @@ static void context_quit(struct context *context)
static gboolean cmd_watch(GIOChannel *io, GIOCondition cond,
gpointer user_data)
{
+ struct context *context = user_data;
+ const struct test_data *test_data = context->data;
+ uint8_t buf[128];
+ int sk;
+
if (cond & (G_IO_HUP | G_IO_ERR | G_IO_NVAL)) {
g_assert(FALSE);
return FALSE;
}
+ sk = g_io_channel_unix_get_fd(io);
+
+ g_assert(read(sk, buf, sizeof(buf)) == test_data->cmd_size);
+ g_assert(!memcmp(test_data->cmd, buf, test_data->cmd_size));
+
+ context_quit(context);
+
return TRUE;
}
@@ -280,6 +295,17 @@ static gboolean send_cmd(gpointer user_data)
return FALSE;
}
+static gboolean register_service(gpointer user_data)
+{
+ struct context *context = user_data;
+ const struct test_data *test_data = context->data;
+
+ ipc_register(test_data->service, test_data->handlers,
+ test_data->handlers_size);
+
+ return FALSE;
+}
+
static void test_cmd(gconstpointer data)
{
struct context *context = create_context(data);
@@ -293,6 +319,28 @@ static void test_cmd(gconstpointer data)
ipc_cleanup();
}
+static void test_cmd_reg(gconstpointer data)
+{
+ struct context *context = create_context(data);
+ const struct test_data *test_data = context->data;
+
+ ipc_init();
+
+ g_idle_add(register_service, context);
+ g_idle_add(send_cmd, context);
+
+ execute_context(context);
+
+ ipc_unregister(test_data->service);
+
+ ipc_cleanup();
+}
+
+static void test_cmd_handler(const void *buf, uint16_t len)
+{
+ ipc_send_rsp(0, 1, 0);
+}
+
static const struct test_data test_init_1 = {};
static const struct hal_hdr test_cmd_1_hdr = {
@@ -307,6 +355,18 @@ static const struct test_data test_cmd_1 = {
.expected_signal = SIGTERM
};
+static const struct ipc_handler cmd_handlers[] = {
+ { test_cmd_handler, false, 0 }
+};
+
+static const struct test_data test_cmd_2 = {
+ .cmd = &test_cmd_1_hdr,
+ .cmd_size = sizeof(test_cmd_1_hdr),
+ .service = 0,
+ .handlers = cmd_handlers,
+ .handlers_size = 1
+};
+
int main(int argc, char *argv[])
{
g_test_init(&argc, &argv, NULL);
@@ -316,6 +376,8 @@ int main(int argc, char *argv[])
g_test_add_data_func("/android_ipc/init", &test_init_1, test_init);
g_test_add_data_func("/android_ipc/send_cmd_1", &test_cmd_1, test_cmd);
+ g_test_add_data_func("/android_ipc/send_cmd_2", &test_cmd_2,
+ test_cmd_reg);
return g_test_run();
}
--
1.8.3.1
^ permalink raw reply related
* [PATCH 3/5] android/ipc-tester: Add test case to send cmd
From: Marcin Kraglak @ 2014-01-15 19:12 UTC (permalink / raw)
To: linux-bluetooth
In-Reply-To: <1389813150-16914-1-git-send-email-marcin.kraglak@tieto.com>
This test case will check if ipc lib will raise SIGTERM
after sending cmd to not registered service.
---
android/test-android-ipc.c | 46 +++++++++++++++++++++++++++++++++++++++++++++-
1 file changed, 45 insertions(+), 1 deletion(-)
diff --git a/android/test-android-ipc.c b/android/test-android-ipc.c
index 6ac1175..99f8559 100644
--- a/android/test-android-ipc.c
+++ b/android/test-android-ipc.c
@@ -44,6 +44,8 @@
struct test_data {
uint32_t expected_signal;
+ const struct hal_hdr *cmd;
+ uint16_t cmd_size;
};
struct context {
@@ -95,6 +97,7 @@ static gboolean connect_handler(GIOChannel *io, GIOCondition cond,
gpointer user_data)
{
struct context *context = user_data;
+ const struct test_data *test_data = context->data;
GIOChannel *new_io;
GIOCondition watch_cond;
int sk;
@@ -126,7 +129,7 @@ static gboolean connect_handler(GIOChannel *io, GIOCondition cond,
context->cmd_io = new_io;
}
- if (context->cmd_source && context->notif_source)
+ if (context->cmd_source && context->notif_source && !test_data->cmd)
context_quit(context);
return TRUE;
@@ -262,8 +265,48 @@ static void test_init(gconstpointer data)
ipc_cleanup();
}
+static gboolean send_cmd(gpointer user_data)
+{
+ struct context *context = user_data;
+ const struct test_data *test_data = context->data;
+ int sk;
+
+ sk = g_io_channel_unix_get_fd(context->cmd_io);
+ g_assert(sk >= 0);
+
+ g_assert(write(sk, test_data->cmd, test_data->cmd_size) ==
+ test_data->cmd_size);
+
+ return FALSE;
+}
+
+static void test_cmd(gconstpointer data)
+{
+ struct context *context = create_context(data);
+
+ ipc_init();
+
+ g_idle_add(send_cmd, context);
+
+ execute_context(context);
+
+ ipc_cleanup();
+}
+
static const struct test_data test_init_1 = {};
+static const struct hal_hdr test_cmd_1_hdr = {
+ .service_id = 0,
+ .opcode = 1,
+ .len = 0
+};
+
+static const struct test_data test_cmd_1 = {
+ .cmd = &test_cmd_1_hdr,
+ .cmd_size = sizeof(test_cmd_1_hdr),
+ .expected_signal = SIGTERM
+};
+
int main(int argc, char *argv[])
{
g_test_init(&argc, &argv, NULL);
@@ -272,6 +315,7 @@ int main(int argc, char *argv[])
__btd_log_init("*", 0);
g_test_add_data_func("/android_ipc/init", &test_init_1, test_init);
+ g_test_add_data_func("/android_ipc/send_cmd_1", &test_cmd_1, test_cmd);
return g_test_run();
}
--
1.8.3.1
^ permalink raw reply related
* [PATCH 2/5] android: Fix ipc cleanup
From: Marcin Kraglak @ 2014-01-15 19:12 UTC (permalink / raw)
To: linux-bluetooth
In-Reply-To: <1389813150-16914-1-git-send-email-marcin.kraglak@tieto.com>
Remove sources while cleanup. It will avoid receiving
events after cleanup.
---
android/ipc.c | 17 +++++++++++++++--
1 file changed, 15 insertions(+), 2 deletions(-)
diff --git a/android/ipc.c b/android/ipc.c
index ed3ef3c..4277bfe 100644
--- a/android/ipc.c
+++ b/android/ipc.c
@@ -45,6 +45,9 @@ static struct service_handler services[HAL_SERVICE_ID_MAX + 1];
static GIOChannel *cmd_io = NULL;
static GIOChannel *notif_io = NULL;
+static guint cmd_id;
+static guint notif_id;
+
int ipc_handle_msg(struct service_handler *handlers, size_t max_index,
const void *buf, ssize_t len)
{
@@ -192,11 +195,11 @@ static gboolean notif_connect_cb(GIOChannel *io, GIOCondition cond,
cond = G_IO_ERR | G_IO_HUP | G_IO_NVAL;
- g_io_add_watch(io, cond, notif_watch_cb, NULL);
+ notif_id = g_io_add_watch(io, cond, notif_watch_cb, NULL);
cond = G_IO_IN | G_IO_ERR | G_IO_HUP | G_IO_NVAL;
- g_io_add_watch(cmd_io, cond, cmd_watch_cb, NULL);
+ cmd_id = g_io_add_watch(cmd_io, cond, cmd_watch_cb, NULL);
info("IPC: successfully connected");
@@ -232,12 +235,22 @@ void ipc_init(void)
void ipc_cleanup(void)
{
+ if (cmd_id) {
+ g_source_remove(cmd_id);
+ cmd_id = 0;
+ }
+
if (cmd_io) {
g_io_channel_shutdown(cmd_io, TRUE, NULL);
g_io_channel_unref(cmd_io);
cmd_io = NULL;
}
+ if (notif_id) {
+ g_source_remove(notif_id);
+ notif_id = 0;
+ }
+
if (notif_io) {
g_io_channel_shutdown(notif_io, TRUE, NULL);
g_io_channel_unref(notif_io);
--
1.8.3.1
^ permalink raw reply related
* [PATCH 1/5] android: Add android ipc tester
From: Marcin Kraglak @ 2014-01-15 19:12 UTC (permalink / raw)
To: linux-bluetooth
This tool will test ipc library. First test case will check
ipc_init() call.
---
.gitignore | 1 +
android/Makefile.am | 8 ++
android/test-android-ipc.c | 277 +++++++++++++++++++++++++++++++++++++++++++++
3 files changed, 286 insertions(+)
create mode 100644 android/test-android-ipc.c
diff --git a/.gitignore b/.gitignore
index ac76fe2..0d0834b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -114,3 +114,4 @@ android/bluetoothd
android/haltest
android/android-tester
android/bluetoothd-snoop
+android/test-android-ipc
diff --git a/android/Makefile.am b/android/Makefile.am
index 7806f79..271a3e8 100644
--- a/android/Makefile.am
+++ b/android/Makefile.am
@@ -117,6 +117,14 @@ android_android_tester_LDADD = lib/libbluetooth-internal.la @GLIB_LIBS@
android_android_tester_LDFLAGS = -pthread -ldl
+noinst_PROGRAMS += android/test-android-ipc
+
+android_test_android_ipc_SOURCES = android/test-android-ipc.c \
+ src/shared/util.h src/shared/util.c \
+ src/log.h src/log.c \
+ android/ipc.c android/ipc.h
+android_test_android_ipc_LDADD = @GLIB_LIBS@
+
plugin_LTLIBRARIES += android/audio.a2dp.default.la
android_audio_a2dp_default_la_SOURCES = android/audio-msg.h \
diff --git a/android/test-android-ipc.c b/android/test-android-ipc.c
new file mode 100644
index 0000000..6ac1175
--- /dev/null
+++ b/android/test-android-ipc.c
@@ -0,0 +1,277 @@
+/*
+ *
+ * BlueZ - Bluetooth protocol stack for Linux
+ *
+ * Copyright (C) 2014 Intel Corporation. All rights reserved.
+ *
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; 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 <stdio.h>
+#include <errno.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <inttypes.h>
+#include <string.h>
+#include <fcntl.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <sys/signalfd.h>
+
+#include <glib.h>
+#include "src/shared/util.h"
+#include "src/log.h"
+#include "android/hal-msg.h"
+#include "android/ipc.h"
+
+struct test_data {
+ uint32_t expected_signal;
+};
+
+struct context {
+ GMainLoop *main_loop;
+
+ int sk;
+
+ guint source;
+ guint cmd_source;
+ guint notif_source;
+
+ GIOChannel *cmd_io;
+ GIOChannel *notif_io;
+ GIOChannel *signal_io;
+
+ guint signal_source;
+
+ const struct test_data *data;
+};
+
+static void context_quit(struct context *context)
+{
+ g_main_loop_quit(context->main_loop);
+}
+
+static gboolean cmd_watch(GIOChannel *io, GIOCondition cond,
+ gpointer user_data)
+{
+ if (cond & (G_IO_HUP | G_IO_ERR | G_IO_NVAL)) {
+ g_assert(FALSE);
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+static gboolean notif_watch(GIOChannel *io, GIOCondition cond,
+ gpointer user_data)
+{
+ if (cond & (G_IO_HUP | G_IO_ERR | G_IO_NVAL)) {
+ g_assert(FALSE);
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+static gboolean connect_handler(GIOChannel *io, GIOCondition cond,
+ gpointer user_data)
+{
+ struct context *context = user_data;
+ GIOChannel *new_io;
+ GIOCondition watch_cond;
+ int sk;
+
+ if (cond & (G_IO_HUP | G_IO_ERR | G_IO_NVAL)) {
+ g_assert(FALSE);
+ return FALSE;
+ }
+
+ g_assert(!context->cmd_source || !context->notif_source);
+
+ sk = accept(context->sk, NULL, NULL);
+ g_assert(sk >= 0);
+
+ new_io = g_io_channel_unix_new(sk);
+
+ watch_cond = G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL;
+
+ if (context->cmd_source && !context->notif_source) {
+ context->notif_source = g_io_add_watch(new_io, watch_cond,
+ notif_watch, context);
+ g_assert(context->notif_source > 0);
+ context->notif_io = new_io;
+ }
+
+ if (!context->cmd_source) {
+ context->cmd_source = g_io_add_watch(new_io, watch_cond,
+ cmd_watch, context);
+ context->cmd_io = new_io;
+ }
+
+ if (context->cmd_source && context->notif_source)
+ context_quit(context);
+
+ return TRUE;
+}
+
+static gboolean signal_handler(GIOChannel *channel, GIOCondition cond,
+ gpointer user_data)
+{
+ struct context *context = user_data;
+ const struct test_data *test_data = context->data;
+ struct signalfd_siginfo si;
+ ssize_t result;
+ int fd;
+
+ if (cond & (G_IO_NVAL | G_IO_ERR | G_IO_HUP))
+ return FALSE;
+
+ fd = g_io_channel_unix_get_fd(channel);
+
+ result = read(fd, &si, sizeof(si));
+ if (result != sizeof(si))
+ return FALSE;
+
+ g_assert(test_data->expected_signal == si.ssi_signo);
+ context_quit(context);
+ return TRUE;
+}
+
+static guint setup_signalfd(gpointer user_data)
+{
+ GIOChannel *channel;
+ guint source;
+ sigset_t mask;
+ int ret;
+ int fd;
+
+ sigemptyset(&mask);
+ sigaddset(&mask, SIGINT);
+ sigaddset(&mask, SIGTERM);
+
+ ret = sigprocmask(SIG_BLOCK, &mask, NULL);
+ g_assert(ret == 0);
+
+ fd = signalfd(-1, &mask, 0);
+ g_assert(fd >= 0);
+
+ channel = g_io_channel_unix_new(fd);
+
+ g_io_channel_set_close_on_unref(channel, TRUE);
+ g_io_channel_set_encoding(channel, NULL, NULL);
+ g_io_channel_set_buffered(channel, FALSE);
+
+ source = g_io_add_watch(channel,
+ G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
+ signal_handler, user_data);
+
+ g_io_channel_unref(channel);
+
+ return source;
+}
+
+static struct context *create_context(gconstpointer data)
+{
+ struct context *context = g_new0(struct context, 1);
+ struct sockaddr_un addr;
+ GIOChannel *io;
+ int ret, sk;
+
+ context->main_loop = g_main_loop_new(NULL, FALSE);
+ g_assert(context->main_loop);
+
+ context->signal_source = setup_signalfd(context);
+ g_assert(context->signal_source);
+
+ sk = socket(AF_LOCAL, SOCK_SEQPACKET, 0);
+ g_assert(sk >= 0);
+
+ memset(&addr, 0, sizeof(addr));
+ addr.sun_family = AF_UNIX;
+
+ memcpy(addr.sun_path, BLUEZ_HAL_SK_PATH, sizeof(BLUEZ_HAL_SK_PATH));
+
+ ret = bind(sk, (struct sockaddr *) &addr, sizeof(addr));
+ g_assert(ret == 0);
+
+ ret = listen(sk, 5);
+ g_assert(ret == 0);
+
+ io = g_io_channel_unix_new(sk);
+
+ g_io_channel_set_close_on_unref(io, TRUE);
+
+ context->source = g_io_add_watch(io,
+ G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
+ connect_handler, context);
+ g_assert(context->source > 0);
+
+ g_io_channel_unref(io);
+
+ context->sk = sk;
+ context->data = data;
+
+ return context;
+}
+
+static void execute_context(struct context *context)
+{
+ g_main_loop_run(context->main_loop);
+
+ g_io_channel_shutdown(context->notif_io, true, NULL);
+ g_io_channel_shutdown(context->cmd_io, true, NULL);
+ g_io_channel_unref(context->cmd_io);
+ g_io_channel_unref(context->notif_io);
+
+ g_source_remove(context->notif_source);
+ g_source_remove(context->signal_source);
+ g_source_remove(context->cmd_source);
+ g_source_remove(context->source);
+
+ g_main_loop_unref(context->main_loop);
+
+ g_free(context);
+}
+
+static void test_init(gconstpointer data)
+{
+ struct context *context = create_context(data);
+
+ ipc_init();
+
+ execute_context(context);
+
+ ipc_cleanup();
+}
+
+static const struct test_data test_init_1 = {};
+
+int main(int argc, char *argv[])
+{
+ g_test_init(&argc, &argv, NULL);
+
+ if (g_test_verbose())
+ __btd_log_init("*", 0);
+
+ g_test_add_data_func("/android_ipc/init", &test_init_1, test_init);
+
+ return g_test_run();
+}
--
1.8.3.1
^ permalink raw reply related
* [PATCH v2 11/11] android/hal-audio: Implement set_parameters for device
From: Andrzej Kaczmarek @ 2014-01-15 18:03 UTC (permalink / raw)
To: linux-bluetooth; +Cc: Andrzej Kaczmarek
In-Reply-To: <1389809037-11575-1-git-send-email-andrzej.kaczmarek@tieto.com>
---
android/hal-audio.c | 10 +++++++++-
1 file changed, 9 insertions(+), 1 deletion(-)
diff --git a/android/hal-audio.c b/android/hal-audio.c
index 58f48bb..a435aec 100644
--- a/android/hal-audio.c
+++ b/android/hal-audio.c
@@ -943,8 +943,16 @@ static void audio_close_output_stream(struct audio_hw_device *dev,
static int audio_set_parameters(struct audio_hw_device *dev,
const char *kvpairs)
{
+ struct a2dp_audio_dev *a2dp_dev = (struct a2dp_audio_dev *) dev;
+ struct a2dp_stream_out *out = a2dp_dev->out;
+
DBG("");
- return -ENOSYS;
+
+ if (!out)
+ return 0;
+
+ return out->stream.common.set_parameters((struct audio_stream *) out,
+ kvpairs);
}
static char *audio_get_parameters(const struct audio_hw_device *dev,
--
1.8.5.2
^ permalink raw reply related
* [PATCH v2 10/11] android/hal-audio: Fix AudioFlinger crash
From: Andrzej Kaczmarek @ 2014-01-15 18:03 UTC (permalink / raw)
To: linux-bluetooth; +Cc: Andrzej Kaczmarek
In-Reply-To: <1389809037-11575-1-git-send-email-andrzej.kaczmarek@tieto.com>
We need to return some valid values for buffer size and latency so
AudioFlinger does not crash. For now just use some dummy values until
codec implementation is in place.
---
android/hal-audio.c | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/android/hal-audio.c b/android/hal-audio.c
index 3c2dcb2..58f48bb 100644
--- a/android/hal-audio.c
+++ b/android/hal-audio.c
@@ -622,7 +622,7 @@ static int out_set_sample_rate(struct audio_stream *stream, uint32_t rate)
static size_t out_get_buffer_size(const struct audio_stream *stream)
{
DBG("");
- return -ENOSYS;
+ return 20 * 512;
}
static uint32_t out_get_channels(const struct audio_stream *stream)
@@ -729,7 +729,7 @@ static char *out_get_parameters(const struct audio_stream *stream,
static uint32_t out_get_latency(const struct audio_stream_out *stream)
{
DBG("");
- return -ENOSYS;
+ return 0;
}
static int out_set_volume(struct audio_stream_out *stream, float left,
--
1.8.5.2
^ permalink raw reply related
* [PATCH v2 09/11] android/hal-audio: Fix module loading
From: Andrzej Kaczmarek @ 2014-01-15 18:03 UTC (permalink / raw)
To: linux-bluetooth; +Cc: Andrzej Kaczmarek
In-Reply-To: <1389809037-11575-1-git-send-email-andrzej.kaczmarek@tieto.com>
---
android/hal-audio.c | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/android/hal-audio.c b/android/hal-audio.c
index 946531f..3c2dcb2 100644
--- a/android/hal-audio.c
+++ b/android/hal-audio.c
@@ -957,7 +957,7 @@ static char *audio_get_parameters(const struct audio_hw_device *dev,
static int audio_init_check(const struct audio_hw_device *dev)
{
DBG("");
- return -ENOSYS;
+ return 0;
}
static int audio_set_voice_volume(struct audio_hw_device *dev, float volume)
@@ -1194,6 +1194,7 @@ static int audio_open(const hw_module_t *module, const char *name,
if (!a2dp_dev)
return -ENOMEM;
+ a2dp_dev->dev.common.tag = HARDWARE_DEVICE_TAG;
a2dp_dev->dev.common.version = AUDIO_DEVICE_API_VERSION_CURRENT;
a2dp_dev->dev.common.module = (struct hw_module_t *) module;
a2dp_dev->dev.common.close = audio_close;
--
1.8.5.2
^ permalink raw reply related
* [PATCH v2 08/11] android/hal-audio: Handle audio preset from stream
From: Andrzej Kaczmarek @ 2014-01-15 18:03 UTC (permalink / raw)
To: linux-bluetooth; +Cc: Andrzej Kaczmarek
In-Reply-To: <1389809037-11575-1-git-send-email-andrzej.kaczmarek@tieto.com>
This patch adds handling of audio preset received after stream is
opened. Preset is used to initialize codec and then to set input
configuration so audio subsystem can write data in a format that
codec can handle later.
---
android/hal-audio.c | 108 +++++++++++++++++++++++++++++++++++++++++++++++++---
1 file changed, 102 insertions(+), 6 deletions(-)
diff --git a/android/hal-audio.c b/android/hal-audio.c
index 93db6eb..946531f 100644
--- a/android/hal-audio.c
+++ b/android/hal-audio.c
@@ -51,7 +51,15 @@ struct audio_input_config {
audio_format_t format;
};
+struct sbc_data {
+ a2dp_sbc_t sbc;
+};
+
static int sbc_get_presets(struct audio_preset *preset, size_t *len);
+static int sbc_init(struct audio_preset *preset, void **codec_data);
+static int sbc_cleanup(void *codec_data);
+static int sbc_get_config(void *codec_data,
+ struct audio_input_config *config);
struct audio_codec {
uint8_t type;
@@ -71,6 +79,10 @@ static const struct audio_codec audio_codecs[] = {
.type = A2DP_CODEC_SBC,
.get_presets = sbc_get_presets,
+
+ .init = sbc_init,
+ .cleanup = sbc_cleanup,
+ .get_config = sbc_get_config,
}
};
@@ -99,6 +111,7 @@ struct a2dp_stream_out {
struct audio_endpoint *ep;
enum a2dp_state_t audio_state;
+ struct audio_input_config cfg;
};
struct a2dp_audio_dev {
@@ -191,6 +204,64 @@ static int sbc_get_presets(struct audio_preset *preset, size_t *len)
return i;
}
+static int sbc_init(struct audio_preset *preset, void **codec_data)
+{
+ struct sbc_data *sbc_data;
+
+ DBG("");
+
+ if (preset->len != sizeof(a2dp_sbc_t)) {
+ DBG("preset size mismatch");
+ return AUDIO_STATUS_FAILED;
+ }
+
+ sbc_data = calloc(sizeof(struct sbc_data), 1);
+
+ memcpy(&sbc_data->sbc, preset->data, preset->len);
+
+ *codec_data = sbc_data;
+
+ return AUDIO_STATUS_SUCCESS;
+}
+
+static int sbc_cleanup(void *codec_data)
+{
+ DBG("");
+
+ free(codec_data);
+
+ return AUDIO_STATUS_SUCCESS;
+}
+
+static int sbc_get_config(void *codec_data,
+ struct audio_input_config *config)
+{
+ struct sbc_data *sbc_data = (struct sbc_data *) codec_data;
+
+ switch (sbc_data->sbc.frequency) {
+ case SBC_SAMPLING_FREQ_16000:
+ config->rate = 16000;
+ break;
+ case SBC_SAMPLING_FREQ_32000:
+ config->rate = 32000;
+ break;
+ case SBC_SAMPLING_FREQ_44100:
+ config->rate = 44100;
+ break;
+ case SBC_SAMPLING_FREQ_48000:
+ config->rate = 48000;
+ break;
+ default:
+ return AUDIO_STATUS_FAILED;
+ }
+ config->channels = sbc_data->sbc.channel_mode == SBC_CHANNEL_MODE_MONO ?
+ AUDIO_CHANNEL_OUT_MONO :
+ AUDIO_CHANNEL_OUT_STEREO;
+ config->format = AUDIO_FORMAT_PCM_16_BIT;
+
+ return AUDIO_STATUS_SUCCESS;
+}
+
static void audio_ipc_cleanup(void)
{
if (audio_sk >= 0) {
@@ -527,14 +598,25 @@ static ssize_t out_write(struct audio_stream_out *stream, const void *buffer,
static uint32_t out_get_sample_rate(const struct audio_stream *stream)
{
+ struct a2dp_stream_out *out = (struct a2dp_stream_out *) stream;
+
DBG("");
- return -ENOSYS;
+
+ return out->cfg.rate;
}
static int out_set_sample_rate(struct audio_stream *stream, uint32_t rate)
{
+ struct a2dp_stream_out *out = (struct a2dp_stream_out *) stream;
+
DBG("");
- return -ENOSYS;
+
+ if (rate != out->cfg.rate) {
+ DBG("cannot set sample rate to %d", rate);
+ return -1;
+ }
+
+ return 0;
}
static size_t out_get_buffer_size(const struct audio_stream *stream)
@@ -545,14 +627,20 @@ static size_t out_get_buffer_size(const struct audio_stream *stream)
static uint32_t out_get_channels(const struct audio_stream *stream)
{
+ struct a2dp_stream_out *out = (struct a2dp_stream_out *) stream;
+
DBG("");
- return -ENOSYS;
+
+ return out->cfg.channels;
}
static audio_format_t out_get_format(const struct audio_stream *stream)
{
+ struct a2dp_stream_out *out = (struct a2dp_stream_out *) stream;
+
DBG("");
- return -ENOSYS;
+
+ return out->cfg.format;
}
static int out_set_format(struct audio_stream *stream, audio_format_t format)
@@ -778,6 +866,7 @@ static int audio_open_output_stream(struct audio_hw_device *dev,
struct a2dp_audio_dev *a2dp_dev = (struct a2dp_audio_dev *) dev;
struct a2dp_stream_out *out;
struct audio_preset *preset;
+ const struct audio_codec *codec;
out = calloc(1, sizeof(struct a2dp_stream_out));
if (!out)
@@ -811,7 +900,13 @@ static int audio_open_output_stream(struct audio_hw_device *dev,
if (!preset)
goto fail;
- /* TODO: initialize codec using received audio_preset */
+ codec = out->ep->codec;
+
+ codec->init(preset, &out->ep->codec_data);
+ codec->get_config(out->ep->codec_data, &out->cfg);
+
+ DBG("rate=%d channels=%d format=%d", out->cfg.rate,
+ out->cfg.channels, out->cfg.format);
free(preset);
@@ -838,7 +933,8 @@ static void audio_close_output_stream(struct audio_hw_device *dev,
ipc_close_stream_cmd(ep->id);
- /* TODO: cleanup codec */
+ ep->codec->cleanup(ep->codec_data);
+ ep->codec_data = NULL;
free(stream);
a2dp_dev->out = NULL;
--
1.8.5.2
^ permalink raw reply related
* [PATCH v2 07/11] android/hal-audio: Add support to suspend output stream
From: Andrzej Kaczmarek @ 2014-01-15 18:03 UTC (permalink / raw)
To: linux-bluetooth; +Cc: Andrzej Kaczmarek
In-Reply-To: <1389809037-11575-1-git-send-email-andrzej.kaczmarek@tieto.com>
This patch adds support to suspend output stream via Audio IPC.
>From HAL perspective stream can be either in standby or suspended -
the former is default one and can be auto-resumed on write while the
latter cannot be resumed only after explicitly going into standby
on audio code request.
---
android/hal-audio.c | 73 ++++++++++++++++++++++++++++++++++++++++++++++++++---
1 file changed, 70 insertions(+), 3 deletions(-)
diff --git a/android/hal-audio.c b/android/hal-audio.c
index 1de8830..93db6eb 100644
--- a/android/hal-audio.c
+++ b/android/hal-audio.c
@@ -450,6 +450,21 @@ static int ipc_resume_stream_cmd(uint8_t endpoint_id)
return result;
}
+static int ipc_suspend_stream_cmd(uint8_t endpoint_id)
+{
+ struct audio_cmd_suspend_stream cmd;
+ int result;
+
+ DBG("");
+
+ cmd.id = endpoint_id;
+
+ result = audio_ipc_cmd(AUDIO_SERVICE_ID, AUDIO_OP_SUSPEND_STREAM,
+ sizeof(cmd), &cmd, NULL, NULL, NULL);
+
+ return result;
+}
+
static int register_endpoints(void)
{
struct audio_endpoint *ep = &audio_endpoints[0];
@@ -548,8 +563,17 @@ static int out_set_format(struct audio_stream *stream, audio_format_t format)
static int out_standby(struct audio_stream *stream)
{
+ struct a2dp_stream_out *out = (struct a2dp_stream_out *) stream;
+
DBG("");
- return -ENOSYS;
+
+ if (out->audio_state == AUDIO_A2DP_STATE_STARTED) {
+ if (ipc_suspend_stream_cmd(out->ep->id) != AUDIO_STATUS_SUCCESS)
+ return -1;
+ out->audio_state = AUDIO_A2DP_STATE_STANDBY;
+ }
+
+ return 0;
}
static int out_dump(const struct audio_stream *stream, int fd)
@@ -560,8 +584,51 @@ static int out_dump(const struct audio_stream *stream, int fd)
static int out_set_parameters(struct audio_stream *stream, const char *kvpairs)
{
- DBG("");
- return -ENOSYS;
+ struct a2dp_stream_out *out = (struct a2dp_stream_out *) stream;
+ char *kvpair;
+ char *str;
+ char *saveptr;
+ bool enter_suspend = false;
+ bool exit_suspend = false;
+
+ DBG("%s", kvpairs);
+
+ str = strdup(kvpairs);
+ kvpair = strtok_r(str, ";", &saveptr);
+
+ for (; kvpair && *kvpair; kvpair = strtok_r(NULL, ";", &saveptr)) {
+ char *keyval;
+
+ keyval = strchr(kvpair, '=');
+ if (!keyval)
+ continue;
+
+ *keyval = '\0';
+ keyval++;
+
+ if (!strcmp(kvpair, "closing")) {
+ if (!strcmp(keyval, "true"))
+ out->audio_state = AUDIO_A2DP_STATE_NONE;
+ } else if (!strcmp(kvpair, "A2dpSuspended")) {
+ if (!strcmp(keyval, "true"))
+ enter_suspend = true;
+ else
+ exit_suspend = true;
+ }
+ }
+
+ free(str);
+
+ if (enter_suspend && out->audio_state == AUDIO_A2DP_STATE_STARTED) {
+ if (ipc_suspend_stream_cmd(out->ep->id) != AUDIO_STATUS_SUCCESS)
+ return -1;
+ out->audio_state = AUDIO_A2DP_STATE_SUSPENDED;
+ }
+
+ if (exit_suspend && out->audio_state == AUDIO_A2DP_STATE_SUSPENDED)
+ out->audio_state = AUDIO_A2DP_STATE_STANDBY;
+
+ return 0;
}
static char *out_get_parameters(const struct audio_stream *stream,
--
1.8.5.2
^ permalink raw reply related
* [PATCH v2 06/11] android/hal-audio: Add support to resume output stream
From: Andrzej Kaczmarek @ 2014-01-15 18:03 UTC (permalink / raw)
To: linux-bluetooth; +Cc: Andrzej Kaczmarek
In-Reply-To: <1389809037-11575-1-git-send-email-andrzej.kaczmarek@tieto.com>
This patch adds support to resume output stream via Audio IPC.
Stream is automatically resumed on first write when stream is in
standby state.
---
android/hal-audio.c | 37 +++++++++++++++++++++++++++++++++++--
1 file changed, 35 insertions(+), 2 deletions(-)
diff --git a/android/hal-audio.c b/android/hal-audio.c
index 2a6b6c4..1de8830 100644
--- a/android/hal-audio.c
+++ b/android/hal-audio.c
@@ -435,6 +435,21 @@ static int ipc_close_stream_cmd(uint8_t endpoint_id)
return result;
}
+static int ipc_resume_stream_cmd(uint8_t endpoint_id)
+{
+ struct audio_cmd_resume_stream cmd;
+ int result;
+
+ DBG("");
+
+ cmd.id = endpoint_id;
+
+ result = audio_ipc_cmd(AUDIO_SERVICE_ID, AUDIO_OP_RESUME_STREAM,
+ sizeof(cmd), &cmd, NULL, NULL, NULL);
+
+ return result;
+}
+
static int register_endpoints(void)
{
struct audio_endpoint *ep = &audio_endpoints[0];
@@ -473,8 +488,26 @@ static void unregister_endpoints(void)
static ssize_t out_write(struct audio_stream_out *stream, const void *buffer,
size_t bytes)
{
- DBG("");
- return -ENOSYS;
+ struct a2dp_stream_out *out = (struct a2dp_stream_out *) stream;
+
+ /* We can auto-start only from standby */
+ if (out->audio_state == AUDIO_A2DP_STATE_STANDBY) {
+ DBG("stream in standby, auto-start");
+
+ if (ipc_resume_stream_cmd(out->ep->id) != AUDIO_STATUS_SUCCESS)
+ return -1;
+
+ out->audio_state = AUDIO_A2DP_STATE_STARTED;
+ }
+
+ if (out->audio_state != AUDIO_A2DP_STATE_STARTED) {
+ DBG("stream not started");
+ return -1;
+ }
+
+ /* TODO: encode data using codec */
+
+ return bytes;
}
static uint32_t out_get_sample_rate(const struct audio_stream *stream)
--
1.8.5.2
^ permalink raw reply related
* [PATCH v2 05/11] android/hal-audio: Add support to close output stream
From: Andrzej Kaczmarek @ 2014-01-15 18:03 UTC (permalink / raw)
To: linux-bluetooth; +Cc: Andrzej Kaczmarek
In-Reply-To: <1389809037-11575-1-git-send-email-andrzej.kaczmarek@tieto.com>
---
android/hal-audio.c | 20 ++++++++++++++++++++
1 file changed, 20 insertions(+)
diff --git a/android/hal-audio.c b/android/hal-audio.c
index 2abd92a..2a6b6c4 100644
--- a/android/hal-audio.c
+++ b/android/hal-audio.c
@@ -420,6 +420,21 @@ static int ipc_open_stream_cmd(uint8_t endpoint_id,
return result;
}
+static int ipc_close_stream_cmd(uint8_t endpoint_id)
+{
+ struct audio_cmd_close_stream cmd;
+ int result;
+
+ DBG("");
+
+ cmd.id = endpoint_id;
+
+ result = audio_ipc_cmd(AUDIO_SERVICE_ID, AUDIO_OP_CLOSE_STREAM,
+ sizeof(cmd), &cmd, NULL, NULL, NULL);
+
+ return result;
+}
+
static int register_endpoints(void)
{
struct audio_endpoint *ep = &audio_endpoints[0];
@@ -717,9 +732,14 @@ static void audio_close_output_stream(struct audio_hw_device *dev,
struct audio_stream_out *stream)
{
struct a2dp_audio_dev *a2dp_dev = (struct a2dp_audio_dev *) dev;
+ struct audio_endpoint *ep = a2dp_dev->out->ep;
DBG("");
+ ipc_close_stream_cmd(ep->id);
+
+ /* TODO: cleanup codec */
+
free(stream);
a2dp_dev->out = NULL;
}
--
1.8.5.2
^ permalink raw reply related
* [PATCH v2 04/11] android/hal-audio: Add support to open output stream
From: Andrzej Kaczmarek @ 2014-01-15 18:03 UTC (permalink / raw)
To: linux-bluetooth; +Cc: Andrzej Kaczmarek
In-Reply-To: <1389809037-11575-1-git-send-email-andrzej.kaczmarek@tieto.com>
This patch adds support to open output stream via Audio IPC.
Since only SBC is supported, we always try to open stream for first
endpoint only which is enough.
---
android/hal-audio.c | 109 ++++++++++++++++++++++++++++++++++++++++++----------
1 file changed, 88 insertions(+), 21 deletions(-)
diff --git a/android/hal-audio.c b/android/hal-audio.c
index 13ae056..2abd92a 100644
--- a/android/hal-audio.c
+++ b/android/hal-audio.c
@@ -87,9 +87,23 @@ struct audio_endpoint {
static struct audio_endpoint audio_endpoints[MAX_AUDIO_ENDPOINTS];
+enum a2dp_state_t {
+ AUDIO_A2DP_STATE_NONE,
+ AUDIO_A2DP_STATE_STANDBY,
+ AUDIO_A2DP_STATE_SUSPENDED,
+ AUDIO_A2DP_STATE_STARTED
+};
+
+struct a2dp_stream_out {
+ struct audio_stream_out stream;
+
+ struct audio_endpoint *ep;
+ enum a2dp_state_t audio_state;
+};
+
struct a2dp_audio_dev {
struct audio_hw_device dev;
- struct audio_stream_out *out;
+ struct a2dp_stream_out *out;
};
static const a2dp_sbc_t sbc_presets[] = {
@@ -374,6 +388,38 @@ static int ipc_close_cmd(uint8_t endpoint_id)
return result;
}
+static int ipc_open_stream_cmd(uint8_t endpoint_id,
+ struct audio_preset **caps)
+{
+ char buf[BLUEZ_AUDIO_MTU];
+ struct audio_cmd_open_stream cmd;
+ struct audio_rsp_open_stream *rsp =
+ (struct audio_rsp_open_stream *) &buf;
+ size_t rsp_len = sizeof(buf);
+ int result;
+
+ DBG("");
+
+ if (!caps)
+ return AUDIO_STATUS_FAILED;
+
+ cmd.id = endpoint_id;
+
+ result = audio_ipc_cmd(AUDIO_SERVICE_ID, AUDIO_OP_OPEN_STREAM,
+ sizeof(cmd), &cmd, &rsp_len, rsp, NULL);
+
+ if (result == AUDIO_STATUS_SUCCESS) {
+ size_t buf_len = sizeof(struct audio_preset) +
+ rsp->preset[0].len;
+ *caps = malloc(buf_len);
+ memcpy(*caps, &rsp->preset, buf_len);
+ } else {
+ *caps = NULL;
+ }
+
+ return result;
+}
+
static int register_endpoints(void)
{
struct audio_endpoint *ep = &audio_endpoints[0];
@@ -615,35 +661,56 @@ static int audio_open_output_stream(struct audio_hw_device *dev,
{
struct a2dp_audio_dev *a2dp_dev = (struct a2dp_audio_dev *) dev;
- struct audio_stream_out *out;
+ struct a2dp_stream_out *out;
+ struct audio_preset *preset;
- out = calloc(1, sizeof(struct audio_stream_out));
+ out = calloc(1, sizeof(struct a2dp_stream_out));
if (!out)
return -ENOMEM;
DBG("");
- out->common.get_sample_rate = out_get_sample_rate;
- out->common.set_sample_rate = out_set_sample_rate;
- out->common.get_buffer_size = out_get_buffer_size;
- out->common.get_channels = out_get_channels;
- out->common.get_format = out_get_format;
- out->common.set_format = out_set_format;
- out->common.standby = out_standby;
- out->common.dump = out_dump;
- out->common.set_parameters = out_set_parameters;
- out->common.get_parameters = out_get_parameters;
- out->common.add_audio_effect = out_add_audio_effect;
- out->common.remove_audio_effect = out_remove_audio_effect;
- out->get_latency = out_get_latency;
- out->set_volume = out_set_volume;
- out->write = out_write;
- out->get_render_position = out_get_render_position;
-
- *stream_out = out;
+ out->stream.common.get_sample_rate = out_get_sample_rate;
+ out->stream.common.set_sample_rate = out_set_sample_rate;
+ out->stream.common.get_buffer_size = out_get_buffer_size;
+ out->stream.common.get_channels = out_get_channels;
+ out->stream.common.get_format = out_get_format;
+ out->stream.common.set_format = out_set_format;
+ out->stream.common.standby = out_standby;
+ out->stream.common.dump = out_dump;
+ out->stream.common.set_parameters = out_set_parameters;
+ out->stream.common.get_parameters = out_get_parameters;
+ out->stream.common.add_audio_effect = out_add_audio_effect;
+ out->stream.common.remove_audio_effect = out_remove_audio_effect;
+ out->stream.get_latency = out_get_latency;
+ out->stream.set_volume = out_set_volume;
+ out->stream.write = out_write;
+ out->stream.get_render_position = out_get_render_position;
+
+ /* TODO: for now we always use endpoint 0 */
+ out->ep = &audio_endpoints[0];
+
+ if (ipc_open_stream_cmd(out->ep->id, &preset) != AUDIO_STATUS_SUCCESS)
+ goto fail;
+
+ if (!preset)
+ goto fail;
+
+ /* TODO: initialize codec using received audio_preset */
+
+ free(preset);
+
+ *stream_out = &out->stream;
a2dp_dev->out = out;
+ out->audio_state = AUDIO_A2DP_STATE_STANDBY;
+
return 0;
+
+fail:
+ free(out);
+ *stream_out = NULL;
+ return -EIO;
}
static void audio_close_output_stream(struct audio_hw_device *dev,
--
1.8.5.2
^ permalink raw reply related
* [PATCH v2 03/11] android/hal-audio: Add support to unregister audio endpoints
From: Andrzej Kaczmarek @ 2014-01-15 18:03 UTC (permalink / raw)
To: linux-bluetooth; +Cc: Andrzej Kaczmarek
In-Reply-To: <1389809037-11575-1-git-send-email-andrzej.kaczmarek@tieto.com>
---
android/hal-audio.c | 33 +++++++++++++++++++++++++++++++++
1 file changed, 33 insertions(+)
diff --git a/android/hal-audio.c b/android/hal-audio.c
index 6aad002..13ae056 100644
--- a/android/hal-audio.c
+++ b/android/hal-audio.c
@@ -359,6 +359,21 @@ static int ipc_open_cmd(const struct audio_codec *codec)
return rsp.id;
}
+static int ipc_close_cmd(uint8_t endpoint_id)
+{
+ struct audio_cmd_close cmd;
+ int result;
+
+ DBG("");
+
+ cmd.id = endpoint_id;
+
+ result = audio_ipc_cmd(AUDIO_SERVICE_ID, AUDIO_OP_CLOSE,
+ sizeof(cmd), &cmd, NULL, NULL, NULL);
+
+ return result;
+}
+
static int register_endpoints(void)
{
struct audio_endpoint *ep = &audio_endpoints[0];
@@ -380,6 +395,20 @@ static int register_endpoints(void)
return AUDIO_STATUS_SUCCESS;
}
+static void unregister_endpoints(void)
+{
+ size_t i;
+
+ for (i = 0; i < MAX_AUDIO_ENDPOINTS; i++) {
+ struct audio_endpoint *ep = &audio_endpoints[i];
+
+ if (ep->id) {
+ ipc_close_cmd(ep->id);
+ memset(ep, 0, sizeof(*ep));
+ }
+ }
+}
+
static ssize_t out_write(struct audio_stream_out *stream, const void *buffer,
size_t bytes)
{
@@ -775,6 +804,8 @@ static void *ipc_handler(void *data)
if (register_endpoints() != AUDIO_STATUS_SUCCESS) {
error("audio: Failed to register endpoints");
+ unregister_endpoints();
+
shutdown(audio_sk, SHUT_RDWR);
continue;
}
@@ -798,6 +829,8 @@ static void *ipc_handler(void *data)
pthread_mutex_unlock(&close_mutex);
}
+ unregister_endpoints();
+
info("Closing Audio IPC thread");
return NULL;
}
--
1.8.5.2
^ permalink raw reply related
* [PATCH v2 02/11] android/hal-audio: Add support to register audio endpoints
From: Andrzej Kaczmarek @ 2014-01-15 18:03 UTC (permalink / raw)
To: linux-bluetooth; +Cc: Andrzej Kaczmarek
In-Reply-To: <1389809037-11575-1-git-send-email-andrzej.kaczmarek@tieto.com>
This patch adds support to register audio enpoints via Audio IPC.
Endpoints are registered based on predefined codecs table and for
each defined codec one endpoint is registered. By default, only
SBC will be supported.
---
android/hal-audio.c | 187 ++++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 187 insertions(+)
diff --git a/android/hal-audio.c b/android/hal-audio.c
index 354c3cf..6aad002 100644
--- a/android/hal-audio.c
+++ b/android/hal-audio.c
@@ -31,6 +31,11 @@
#include "audio-msg.h"
#include "hal-log.h"
#include "hal-msg.h"
+#include "../profiles/audio/a2dp-codecs.h"
+
+static const uint8_t a2dp_src_uuid[] = {
+ 0x00, 0x00, 0x11, 0x0a, 0x00, 0x00, 0x10, 0x00,
+ 0x80, 0x00, 0x00, 0x80, 0x5f, 0x9b, 0x34, 0xfb };
static int listen_sk = -1;
static int audio_sk = -1;
@@ -40,11 +45,138 @@ static pthread_t ipc_th = 0;
static pthread_mutex_t close_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t sk_mutex = PTHREAD_MUTEX_INITIALIZER;
+struct audio_input_config {
+ uint32_t rate;
+ uint32_t channels;
+ audio_format_t format;
+};
+
+static int sbc_get_presets(struct audio_preset *preset, size_t *len);
+
+struct audio_codec {
+ uint8_t type;
+
+ int (*get_presets) (struct audio_preset *preset, size_t *len);
+
+ int (*init) (struct audio_preset *preset, void **codec_data);
+ int (*cleanup) (void *codec_data);
+ int (*get_config) (void *codec_data,
+ struct audio_input_config *config);
+ ssize_t (*write_data) (void *codec_data, const void *buffer,
+ size_t bytes);
+};
+
+static const struct audio_codec audio_codecs[] = {
+ {
+ .type = A2DP_CODEC_SBC,
+
+ .get_presets = sbc_get_presets,
+ }
+};
+
+#define NUM_CODECS (sizeof(audio_codecs) / sizeof(audio_codecs[0]))
+
+#define MAX_AUDIO_ENDPOINTS NUM_CODECS
+
+struct audio_endpoint {
+ uint8_t id;
+ const struct audio_codec *codec;
+ void *codec_data;
+ int fd;
+};
+
+static struct audio_endpoint audio_endpoints[MAX_AUDIO_ENDPOINTS];
+
struct a2dp_audio_dev {
struct audio_hw_device dev;
struct audio_stream_out *out;
};
+static const a2dp_sbc_t sbc_presets[] = {
+ {
+ .frequency = SBC_SAMPLING_FREQ_44100 | SBC_SAMPLING_FREQ_48000,
+ .channel_mode = SBC_CHANNEL_MODE_MONO |
+ SBC_CHANNEL_MODE_DUAL_CHANNEL |
+ SBC_CHANNEL_MODE_STEREO |
+ SBC_CHANNEL_MODE_JOINT_STEREO,
+ .subbands = SBC_SUBBANDS_4 | SBC_SUBBANDS_8,
+ .allocation_method = SBC_ALLOCATION_SNR |
+ SBC_ALLOCATION_LOUDNESS,
+ .block_length = SBC_BLOCK_LENGTH_4 | SBC_BLOCK_LENGTH_8 |
+ SBC_BLOCK_LENGTH_12 | SBC_BLOCK_LENGTH_16,
+ .min_bitpool = MIN_BITPOOL,
+ .max_bitpool = MAX_BITPOOL
+ },
+ /* middle quality */
+ {
+ .frequency = SBC_SAMPLING_FREQ_44100,
+ .channel_mode = SBC_CHANNEL_MODE_JOINT_STEREO,
+ .subbands = SBC_SUBBANDS_8,
+ .allocation_method = SBC_ALLOCATION_LOUDNESS,
+ .block_length = SBC_BLOCK_LENGTH_16,
+ .min_bitpool = MIN_BITPOOL,
+ .max_bitpool = 35
+ },
+ {
+ .frequency = SBC_SAMPLING_FREQ_48000,
+ .channel_mode = SBC_CHANNEL_MODE_JOINT_STEREO,
+ .subbands = SBC_SUBBANDS_8,
+ .allocation_method = SBC_ALLOCATION_LOUDNESS,
+ .block_length = SBC_BLOCK_LENGTH_16,
+ .min_bitpool = MIN_BITPOOL,
+ .max_bitpool = 33
+ },
+ /* high quality */
+ {
+ .frequency = SBC_SAMPLING_FREQ_44100,
+ .channel_mode = SBC_CHANNEL_MODE_JOINT_STEREO,
+ .subbands = SBC_SUBBANDS_8,
+ .allocation_method = SBC_ALLOCATION_LOUDNESS,
+ .block_length = SBC_BLOCK_LENGTH_16,
+ .min_bitpool = MIN_BITPOOL,
+ .max_bitpool = 53
+ },
+ {
+ .frequency = SBC_SAMPLING_FREQ_48000,
+ .channel_mode = SBC_CHANNEL_MODE_JOINT_STEREO,
+ .subbands = SBC_SUBBANDS_8,
+ .allocation_method = SBC_ALLOCATION_LOUDNESS,
+ .block_length = SBC_BLOCK_LENGTH_16,
+ .min_bitpool = MIN_BITPOOL,
+ .max_bitpool = 51
+ },
+};
+
+static int sbc_get_presets(struct audio_preset *preset, size_t *len)
+{
+ int i;
+ int count;
+ size_t new_len = 0;
+ uint8_t *ptr = (uint8_t *) preset;
+ size_t preset_size = sizeof(*preset) + sizeof(a2dp_sbc_t);
+
+ DBG("");
+
+ count = sizeof(sbc_presets) / sizeof(sbc_presets[0]);
+
+ for (i = 0; i < count; i++) {
+ preset = (struct audio_preset *) ptr;
+
+ if (new_len + preset_size > *len)
+ break;
+
+ preset->len = sizeof(a2dp_sbc_t);
+ memcpy(preset->data, &sbc_presets[i], preset->len);
+
+ new_len += preset_size;
+ ptr += preset_size;
+ }
+
+ *len = new_len;
+
+ return i;
+}
+
static void audio_ipc_cleanup(void)
{
if (audio_sk >= 0) {
@@ -200,6 +332,54 @@ failed:
return AUDIO_STATUS_FAILED;
}
+static int ipc_open_cmd(const struct audio_codec *codec)
+{
+ uint8_t buf[BLUEZ_AUDIO_MTU];
+ struct audio_cmd_open *cmd = (struct audio_cmd_open *) buf;
+ struct audio_rsp_open rsp;
+ size_t cmd_len = sizeof(buf) - sizeof(*cmd);
+ size_t rsp_len = sizeof(rsp);
+ int result;
+
+ DBG("");
+
+ memcpy(cmd->uuid, a2dp_src_uuid, sizeof(a2dp_src_uuid));
+
+ cmd->codec = codec->type;
+ cmd->presets = codec->get_presets(cmd->preset, &cmd_len);
+
+ cmd_len += sizeof(*cmd);
+
+ result = audio_ipc_cmd(AUDIO_SERVICE_ID, AUDIO_OP_OPEN, cmd_len, cmd,
+ &rsp_len, &rsp, NULL);
+
+ if (result != AUDIO_STATUS_SUCCESS)
+ return 0;
+
+ return rsp.id;
+}
+
+static int register_endpoints(void)
+{
+ struct audio_endpoint *ep = &audio_endpoints[0];
+ size_t i;
+
+ for (i = 0; i < NUM_CODECS; i++, ep++) {
+ const struct audio_codec *codec = &audio_codecs[i];
+
+ ep->id = ipc_open_cmd(codec);
+
+ if (!ep->id)
+ return AUDIO_STATUS_FAILED;
+
+ ep->codec = codec;
+ ep->codec_data = NULL;
+ ep->fd = -1;
+ }
+
+ return AUDIO_STATUS_SUCCESS;
+}
+
static ssize_t out_write(struct audio_stream_out *stream, const void *buffer,
size_t bytes)
{
@@ -592,6 +772,13 @@ static void *ipc_handler(void *data)
DBG("Audio IPC: Connected");
+ if (register_endpoints() != AUDIO_STATUS_SUCCESS) {
+ error("audio: Failed to register endpoints");
+
+ shutdown(audio_sk, SHUT_RDWR);
+ continue;
+ }
+
memset(&pfd, 0, sizeof(pfd));
pfd.fd = audio_sk;
pfd.events = POLLHUP | POLLERR | POLLNVAL;
--
1.8.5.2
^ permalink raw reply related
* [PATCH v2 01/11] android/hal-audio: Add audio_ipc_cmd
From: Andrzej Kaczmarek @ 2014-01-15 18:03 UTC (permalink / raw)
To: linux-bluetooth; +Cc: Lukasz Rymanowski
In-Reply-To: <1389809037-11575-1-git-send-email-andrzej.kaczmarek@tieto.com>
From: Lukasz Rymanowski <lukasz.rymanowski@tieto.com>
Add function to handle send/receive on audio_sk.
---
android/Makefile.am | 1 +
android/hal-audio.c | 149 ++++++++++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 150 insertions(+)
diff --git a/android/Makefile.am b/android/Makefile.am
index 7806f79..e09f967 100644
--- a/android/Makefile.am
+++ b/android/Makefile.am
@@ -120,6 +120,7 @@ android_android_tester_LDFLAGS = -pthread -ldl
plugin_LTLIBRARIES += android/audio.a2dp.default.la
android_audio_a2dp_default_la_SOURCES = android/audio-msg.h \
+ android/hal-msg.h \
android/hal-audio.c \
android/hardware/audio.h \
android/hardware/audio_effect.h \
diff --git a/android/hal-audio.c b/android/hal-audio.c
index c51b065..354c3cf 100644
--- a/android/hal-audio.c
+++ b/android/hal-audio.c
@@ -30,6 +30,7 @@
#include "audio-msg.h"
#include "hal-log.h"
+#include "hal-msg.h"
static int listen_sk = -1;
static int audio_sk = -1;
@@ -37,6 +38,7 @@ static bool close_thread = false;
static pthread_t ipc_th = 0;
static pthread_mutex_t close_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t sk_mutex = PTHREAD_MUTEX_INITIALIZER;
struct a2dp_audio_dev {
struct audio_hw_device dev;
@@ -51,6 +53,153 @@ static void audio_ipc_cleanup(void)
}
}
+static int audio_ipc_cmd(uint8_t service_id, uint8_t opcode, uint16_t len,
+ void *param, size_t *rsp_len, void *rsp, int *fd)
+{
+ ssize_t ret;
+ struct msghdr msg;
+ struct iovec iv[2];
+ struct hal_hdr cmd;
+ char cmsgbuf[CMSG_SPACE(sizeof(int))];
+ struct hal_status s;
+ size_t s_len = sizeof(s);
+
+ if (audio_sk < 0) {
+ error("audio: Invalid cmd socket passed to audio_ipc_cmd");
+ goto failed;
+ }
+
+ if (!rsp || !rsp_len) {
+ memset(&s, 0, s_len);
+ rsp_len = &s_len;
+ rsp = &s;
+ }
+
+ memset(&msg, 0, sizeof(msg));
+ memset(&cmd, 0, sizeof(cmd));
+
+ cmd.service_id = service_id;
+ cmd.opcode = opcode;
+ cmd.len = len;
+
+ iv[0].iov_base = &cmd;
+ iv[0].iov_len = sizeof(cmd);
+
+ iv[1].iov_base = param;
+ iv[1].iov_len = len;
+
+ msg.msg_iov = iv;
+ msg.msg_iovlen = 2;
+
+ pthread_mutex_lock(&sk_mutex);
+
+ ret = sendmsg(audio_sk, &msg, 0);
+ if (ret < 0) {
+ error("audio: Sending command failed:%s", strerror(errno));
+ pthread_mutex_unlock(&sk_mutex);
+ goto failed;
+ }
+
+ /* socket was shutdown */
+ if (ret == 0) {
+ error("audio: Command socket closed");
+ goto failed;
+ }
+
+ memset(&msg, 0, sizeof(msg));
+ memset(&cmd, 0, sizeof(cmd));
+
+ iv[0].iov_base = &cmd;
+ iv[0].iov_len = sizeof(cmd);
+
+ iv[1].iov_base = rsp;
+ iv[1].iov_len = *rsp_len;
+
+ msg.msg_iov = iv;
+ msg.msg_iovlen = 2;
+
+ if (fd) {
+ memset(cmsgbuf, 0, sizeof(cmsgbuf));
+ msg.msg_control = cmsgbuf;
+ msg.msg_controllen = sizeof(cmsgbuf);
+ }
+
+ ret = recvmsg(audio_sk, &msg, 0);
+ if (ret < 0) {
+ error("audio: Receiving command response failed:%s",
+ strerror(errno));
+ pthread_mutex_unlock(&sk_mutex);
+ goto failed;
+ }
+
+ pthread_mutex_unlock(&sk_mutex);
+
+ if (ret < (ssize_t) sizeof(cmd)) {
+ error("audio: Too small response received(%zd bytes)", ret);
+ goto failed;
+ }
+
+ if (cmd.service_id != service_id) {
+ error("audio: Invalid service id (%u vs %u)", cmd.service_id,
+ service_id);
+ goto failed;
+ }
+
+ if (ret != (ssize_t) (sizeof(cmd) + cmd.len)) {
+ error("audio: Malformed response received(%zd bytes)", ret);
+ goto failed;
+ }
+
+ if (cmd.opcode != opcode && cmd.opcode != AUDIO_OP_STATUS) {
+ error("audio: Invalid opcode received (%u vs %u)",
+ cmd.opcode, opcode);
+ goto failed;
+ }
+
+ if (cmd.opcode == AUDIO_OP_STATUS) {
+ struct hal_status *s = rsp;
+
+ if (sizeof(*s) != cmd.len) {
+ error("audio: Invalid status length");
+ goto failed;
+ }
+
+ if (s->code == AUDIO_STATUS_SUCCESS) {
+ error("audio: Invalid success status response");
+ goto failed;
+ }
+
+ return s->code;
+ }
+
+ /* Receive auxiliary data in msg */
+ if (fd) {
+ struct cmsghdr *cmsg;
+
+ *fd = -1;
+
+ for (cmsg = CMSG_FIRSTHDR(&msg); cmsg;
+ cmsg = CMSG_NXTHDR(&msg, cmsg)) {
+ if (cmsg->cmsg_level == SOL_SOCKET
+ && cmsg->cmsg_type == SCM_RIGHTS) {
+ memcpy(fd, CMSG_DATA(cmsg), sizeof(int));
+ break;
+ }
+ }
+ }
+
+ if (rsp_len)
+ *rsp_len = cmd.len;
+
+ return AUDIO_STATUS_SUCCESS;
+
+failed:
+ /* Some serious issue happen on IPC - recover */
+ shutdown(audio_sk, SHUT_RDWR);
+ audio_sk = -1;
+ return AUDIO_STATUS_FAILED;
+}
+
static ssize_t out_write(struct audio_stream_out *stream, const void *buffer,
size_t bytes)
{
--
1.8.5.2
^ permalink raw reply related
* [PATCH v2 00/11] Audio HAL implementation
From: Andrzej Kaczmarek @ 2014-01-15 18:03 UTC (permalink / raw)
To: linux-bluetooth; +Cc: Andrzej Kaczmarek
Hi,
changes v1 -> v2
- fixed comments from Luiz
- removed "codec_" prefix from function related to SBC codec
- additional patch to implement set_parameters for audio device
(A2dpSuspend is initialized this way)
- changes dummy buffer size to 20*512 which is inline with Bluedroid
(AudioFlinger does crash when closing output stream when set to 512)
Andrzej Kaczmarek (10):
android/hal-audio: Add support to register audio endpoints
android/hal-audio: Add support to unregister audio endpoints
android/hal-audio: Add support to open output stream
android/hal-audio: Add support to close output stream
android/hal-audio: Add support to resume output stream
android/hal-audio: Add support to suspend output stream
android/hal-audio: Handle audio preset from stream
android/hal-audio: Fix module loading
android/hal-audio: Fix AudioFlinger crash
android/hal-audio: Implement set_parameters for device
Lukasz Rymanowski (1):
android/hal-audio: Add audio_ipc_cmd
android/Makefile.am | 1 +
android/hal-audio.c | 729 +++++++++++++++++++++++++++++++++++++++++++++++++---
2 files changed, 696 insertions(+), 34 deletions(-)
--
1.8.5.2
^ permalink raw reply
* Re: [PATCHv3 0/8] IPC negative tester
From: Szymon Janc @ 2014-01-15 16:04 UTC (permalink / raw)
To: Jakub Tyszkowski; +Cc: linux-bluetooth
In-Reply-To: <1389789757-16847-1-git-send-email-jakub.tyszkowski@tieto.com>
Hi Jakub,
On Wednesday 15 of January 2014 13:42:29 Jakub Tyszkowski wrote:
> Following patchset adds IPC negative tester framework with few test cases
> checking IPC's behaviour on daemon side. Expected daemon's behaviour is to
> shut down gracefully in case of receiving invalid IPC data.
>
> v2 changes:
> * fixed few indentation issues
> * fixed missing __attribute__((packed))
> * fixed amount of data written for 'malformed data' test case
> * fixed opcode for 'invalid service' test case
> * added patch(8) with more 'malformed data' cases
>
> v3 changes:
> * changed license to GPL
> * changed 'ipc-negative-tester' name to 'ipc-tester'
>
> Jakub Tyszkowski (8):
> android/ipc-tester: Skeleton for ipc negative tester
> android/ipc-tester: Run daemon in separate process
> android/ipc-tester: Add IPC initialization
> android/ipc-tester: Add daemon shutdown handler
> android/ipc-tester: Add sending test data with ipc
> android/ipc-tester: Register services
> android/ipc-tester: Add basic test cases for IPC's daemon site
> androi/ipc-tester: Add more cases for malformed data
>
> .gitignore | 1 +
> android/Makefile.am | 17 ++
> android/ipc-tester.c | 727 +++++++++++++++++++++++++++++++++++++++++++++++++++
> 3 files changed, 745 insertions(+)
> create mode 100644 android/ipc-tester.c
>
> --
> 1.8.5.2
>
> --
> To unsubscribe from this list: send the line "unsubscribe linux-bluetooth" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at http://vger.kernel.org/majordomo-info.html
Please send V4 with changes we discussed off-line.
--
Best regards,
Szymon Janc
^ permalink raw reply
* Re: [PATCH 01/12] android/tester: Add set device FRIENDLY_NAME prop success test case
From: Szymon Janc @ 2014-01-15 13:24 UTC (permalink / raw)
To: Grzegorz Kolodziejczyk; +Cc: linux-bluetooth
In-Reply-To: <1389788228-32195-1-git-send-email-grzegorz.kolodziejczyk@tieto.com>
Hi Grzegorz,
On Wednesday 15 of January 2014 13:16:57 Grzegorz Kolodziejczyk wrote:
> This adds set device FRIENDLY NAME property success test case.
> ---
> android/android-tester.c | 99 ++++++++++++++++++++++++++++++++++++++++++++++++
> 1 file changed, 99 insertions(+)
>
> diff --git a/android/android-tester.c b/android/android-tester.c
> index 030111b..27f436f 100644
> --- a/android/android-tester.c
> +++ b/android/android-tester.c
> @@ -653,6 +653,20 @@ static void remote_discovery_state_changed_cb(bt_discovery_state_t state)
> }
> }
>
> +static void remote_setprop_disc_state_changed_cb(bt_discovery_state_t state)
> +{
> + struct test_data *data = tester_get_data();
> +
> + if (state == BT_DISCOVERY_STARTED && data->cb_count == 4) {
> + data->cb_count--;
> + return;
> + }
> + if (state == BT_DISCOVERY_STOPPED) {
> + data->cb_count--;
> + check_cb_count();
> + }
> +}
> +
> static void discovery_state_changed_cb(bt_discovery_state_t state)
> {
> struct test_data *data = tester_get_data();
> @@ -758,6 +772,27 @@ static void remote_get_property_device_found_cb(int num_properties,
> check_expected_status(status);
> }
>
> +static void remote_setprop_device_found_cb(int num_properties,
> + bt_property_t *properties)
> +{
> + struct test_data *data = tester_get_data();
> + const struct generic_data *test = data->test_data;
> + bt_status_t status;
> + uint8_t *bdaddr = (uint8_t *)hciemu_get_client_bdaddr(data->hciemu);
> + bt_bdaddr_t remote_addr;
> +
> + const bt_property_t prop = test->expected_properties[0].prop;
> +
> + bdaddr2android((const bdaddr_t *)bdaddr, &remote_addr.address);
> +
> + if (data->cb_count == 3)
> + data->cb_count--;
> +
> + status = data->if_bluetooth->set_remote_device_property(&remote_addr,
> + &prop);
> + check_expected_status(status);
> +}
> +
> static void device_found_cb(int num_properties, bt_property_t *properties)
> {
> struct test_data *data = tester_get_data();
> @@ -803,6 +838,29 @@ static void remote_test_device_properties_cb(bt_status_t status,
> check_expected_property(properties[i]);
> }
>
> +static void remote_setprop_device_properties_cb(bt_status_t status,
> + bt_bdaddr_t *bd_addr, int num_properties,
> + bt_property_t *properties)
> +{
> + int i;
> + struct test_data *data = tester_get_data();
> + const struct generic_data *test = data->test_data;
> + uint8_t *bdaddr = (uint8_t *)hciemu_get_client_bdaddr(data->hciemu);
> + bt_bdaddr_t remote_addr;
> + const bt_property_t prop = test->expected_properties[1].prop;
> +
> + for (i = 0; i < num_properties; i++)
> + check_expected_property(properties[i]);
> +
> + if (g_slist_length(data->expected_properties_list) == 1) {
> + bdaddr2android((const bdaddr_t *)bdaddr, &remote_addr.address);
> + data->cb_count--;
> + check_cb_count();
> + data->if_bluetooth->get_remote_device_property(&remote_addr,
> + prop.type);
> + }
> +}
> +
> static void remote_device_properties_cb(bt_status_t status,
> bt_bdaddr_t *bd_addr, int num_properties,
> bt_property_t *properties)
> @@ -1596,6 +1654,33 @@ static const struct generic_data bt_dev_getprop_fname_fail_test = {
> .expected_adapter_status = BT_STATUS_FAIL,
> };
>
> +static const char remote_setprop_fname_val[] = "set_fname_test";
> +
> +static struct priority_property remote_setprop_fname_props[] = {
> + {
> + .prop.type = BT_PROPERTY_REMOTE_FRIENDLY_NAME,
> + .prop.val = &remote_setprop_fname_val,
> + .prop.len = sizeof(remote_setprop_fname_val) - 1,
> + },
> + {
> + .prop.type = BT_PROPERTY_REMOTE_FRIENDLY_NAME,
> + .prop.val = &remote_setprop_fname_val,
> + .prop.len = sizeof(remote_setprop_fname_val) - 1,
> + },
> +};
> +
> +static const struct generic_data bt_dev_setprop_fname_success_test = {
> + .expected_hal_cb.discovery_state_changed_cb =
> + remote_setprop_disc_state_changed_cb,
> + .expected_hal_cb.device_found_cb = remote_setprop_device_found_cb,
> + .expected_hal_cb.remote_device_properties_cb =
> + remote_setprop_device_properties_cb,
> + .expected_cb_count = 4,
> + .expected_properties_num = 2,
> + .expected_properties = remote_setprop_fname_props,
> + .expected_adapter_status = BT_STATUS_SUCCESS,
> +};
> +
> static bt_callbacks_t bt_callbacks = {
> .size = sizeof(bt_callbacks),
> .adapter_state_changed_cb = adapter_state_changed_cb,
> @@ -2235,6 +2320,15 @@ static void test_dev_getprop_fname_fail(const void *test_data)
> data->if_bluetooth->start_discovery();
> }
>
> +static void test_dev_setprop_fname_success(const void *test_data)
> +{
> + struct test_data *data = tester_get_data();
> +
> + init_test_conditions(data);
> +
> + data->if_bluetooth->start_discovery();
> +}
> +
> /* Test Socket HAL */
>
> static void adapter_socket_state_changed_cb(bt_state_t state)
> @@ -2907,6 +3001,11 @@ int main(int argc, char *argv[])
> setup_enabled_adapter,
> test_dev_getprop_fname_fail, teardown);
>
> + test_bredrle("Bluetooth Device Set FRIENDLY_NAME - Success",
> + &bt_dev_setprop_fname_success_test,
> + setup_enabled_adapter,
> + test_dev_setprop_fname_success, teardown);
> +
> test_bredrle("Socket Init", NULL, setup_socket_interface,
> test_dummy, teardown);
>
>
All patches applied, thanks.
--
Best regards,
Szymon Janc
^ permalink raw reply
* [PATCH BlueZ] android/A2DP: Change to connected state when a transport open
From: Luiz Augusto von Dentz @ 2014-01-15 13:06 UTC (permalink / raw)
To: linux-bluetooth
From: Luiz Augusto von Dentz <luiz.von.dentz@intel.com>
This changes the connected state to be only sent once a transport is
open, before this was done right after the signalling was connected but
this reflect in the audio HAL side attempting to open a stream while
with possible no transport available.
---
android/a2dp.c | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/android/a2dp.c b/android/a2dp.c
index 35ffe46..a5fc652 100644
--- a/android/a2dp.c
+++ b/android/a2dp.c
@@ -401,8 +401,6 @@ static void signaling_connect_cb(GIOChannel *chan, GError *err,
}
}
- bt_a2dp_notify_state(dev, HAL_A2DP_STATE_CONNECTED);
-
return;
failed:
@@ -544,6 +542,8 @@ static void transport_connect_cb(GIOChannel *chan, GError *err,
g_io_channel_unref(dev->io);
dev->io = NULL;
}
+
+ bt_a2dp_notify_state(dev, HAL_A2DP_STATE_CONNECTED);
}
static void connect_cb(GIOChannel *chan, GError *err, gpointer user_data)
--
1.8.4.2
^ permalink raw reply related
* Re: [PATCH BlueZ 1/2] android/A2DP: Add handling of incoming transport connection
From: Luiz Augusto von Dentz @ 2014-01-15 12:55 UTC (permalink / raw)
To: linux-bluetooth@vger.kernel.org
In-Reply-To: <1389700090-3642-1-git-send-email-luiz.dentz@gmail.com>
Hi,
On Tue, Jan 14, 2014 at 1:48 PM, Luiz Augusto von Dentz
<luiz.dentz@gmail.com> wrote:
> From: Luiz Augusto von Dentz <luiz.von.dentz@intel.com>
>
> This adds handling of incoming transport connection attempt.
> ---
> android/a2dp.c | 64 ++++++++++++++++++++++++++++++++++++++++++++++++++++++----
> 1 file changed, 60 insertions(+), 4 deletions(-)
>
> diff --git a/android/a2dp.c b/android/a2dp.c
> index 9f3164a..aab0940 100644
> --- a/android/a2dp.c
> +++ b/android/a2dp.c
> @@ -477,6 +477,60 @@ static const struct ipc_handler cmd_handlers[] = {
> { bt_a2dp_disconnect, false, sizeof(struct hal_cmd_a2dp_disconnect) },
> };
>
> +static struct a2dp_setup *find_setup_by_device(struct a2dp_device *dev)
> +{
> + GSList *l;
> +
> + for (l = setups; l; l = g_slist_next(l)) {
> + struct a2dp_setup *setup = l->data;
> +
> + if (setup->dev == dev)
> + return setup;
> + }
> +
> + return NULL;
> +}
> +
> +static void transport_connect_cb(GIOChannel *chan, GError *err,
> + gpointer user_data)
> +{
> + struct a2dp_device *dev = user_data;
> + struct a2dp_setup *setup;
> + uint16_t imtu, omtu;
> + GError *gerr = NULL;
> + int fd;
> +
> + if (err) {
> + error("%s", err->message);
> + return;
> + }
> +
> + setup = find_setup_by_device(dev);
> + if (!setup) {
> + error("Unable to find stream setup");
> + return;
> + }
> +
> + bt_io_get(chan, &gerr,
> + BT_IO_OPT_IMTU, &imtu,
> + BT_IO_OPT_OMTU, &omtu,
> + BT_IO_OPT_INVALID);
> + if (gerr) {
> + error("%s", gerr->message);
> + g_error_free(gerr);
> + return;
> + }
> +
> + fd = g_io_channel_unix_get_fd(chan);
> +
> + if (!avdtp_stream_set_transport(setup->stream, fd, imtu, omtu)) {
> + error("avdtp_stream_set_transport: failed");
> + return;
> + }
> +
> + g_io_channel_set_close_on_unref(chan, FALSE);
> +}
> +
> static void connect_cb(GIOChannel *chan, GError *err, gpointer user_data)
> {
> struct a2dp_device *dev;
> @@ -501,13 +555,15 @@ static void connect_cb(GIOChannel *chan, GError *err, gpointer user_data)
> return;
> }
>
> - l = g_slist_find_custom(devices, &dst, device_cmp);
> - if (l)
> - return;
> -
> ba2str(&dst, address);
> DBG("Incoming connection from %s", address);
>
> + l = g_slist_find_custom(devices, &dst, device_cmp);
> + if (l) {
> + transport_connect_cb(chan, err, l->data);
> + return;
> + }
> +
> dev = a2dp_device_new(&dst);
> signaling_connect_cb(chan, err, dev);
> }
> --
> 1.8.4.2
Pushed.
--
Luiz Augusto von Dentz
^ permalink raw reply
* [PATCHv3 8/8] androi/ipc-tester: Add more cases for malformed data
From: Jakub Tyszkowski @ 2014-01-15 12:42 UTC (permalink / raw)
To: linux-bluetooth
In-Reply-To: <1389789757-16847-1-git-send-email-jakub.tyszkowski@tieto.com>
This patch adds tests for more types of possible data malformations.
---
android/ipc-tester.c | 46 ++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 46 insertions(+)
diff --git a/android/ipc-tester.c b/android/ipc-tester.c
index 72200d8..046b794 100644
--- a/android/ipc-tester.c
+++ b/android/ipc-tester.c
@@ -591,6 +591,48 @@ static const struct generic_data malformed_data = {
.num_services = 1,
};
+static const struct generic_data malformed_data2 = {
+ .ipc_data = {
+ /* use proper msg */
+ .buffer = ®ister_bt_msg,
+ /* but write incomplete */
+ .len = sizeof(register_bt_msg) - 1,
+ },
+ .init_services = {HAL_SERVICE_ID_BLUETOOTH},
+ .num_services = 1,
+};
+
+struct malformed_data3_struct {
+ struct regmod_msg valid_msg;
+ int redundant_data;
+} __attribute__((packed));
+
+static struct malformed_data3_struct malformed_data3_msg = {
+ /* valid register service message */
+ .valid_msg = {
+ .header = {
+ .service_id = HAL_SERVICE_ID_CORE,
+ .opcode = HAL_OP_REGISTER_MODULE,
+ .len = sizeof(struct hal_cmd_register_module),
+ },
+ .cmd = {
+ .service_id = HAL_SERVICE_ID_CORE,
+ },
+ },
+ /* plus redundant data */
+ . redundant_data = 666,
+};
+
+static const struct generic_data malformed_data3 = {
+ .ipc_data = {
+ /* use malformed msg */
+ .buffer = &malformed_data3_msg,
+ .len = sizeof(malformed_data3_msg),
+ },
+ .init_services = {HAL_SERVICE_ID_BLUETOOTH},
+ .num_services = 1,
+};
+
struct hal_hdr enable_unknown_service_hdr = {
.service_id = HAL_SERVICE_ID_MAX + 1,
.opcode = HAL_OP_REGISTER_MODULE,
@@ -667,6 +709,10 @@ int main(int argc, char *argv[])
setup, ipc_send_tc, teardown);
test_bredrle("Malformed data (wrong payload declared)", &malformed_data,
setup, ipc_send_tc, teardown);
+ test_bredrle("Malformed data2 (undersized msg)", &malformed_data2,
+ setup, ipc_send_tc, teardown);
+ test_bredrle("Malformed data3 (oversized msg)", &malformed_data3,
+ setup, ipc_send_tc, teardown);
test_bredrle("Invalid service", &enable_unknown_service_data,
setup, ipc_send_tc, teardown);
test_bredrle("Enable unregistered service",
--
1.8.5.2
^ permalink raw reply related
* [PATCHv3 7/8] android/ipc-tester: Add basic test cases for IPC's daemon site
From: Jakub Tyszkowski @ 2014-01-15 12:42 UTC (permalink / raw)
To: linux-bluetooth
In-Reply-To: <1389789757-16847-1-git-send-email-jakub.tyszkowski@tieto.com>
This patch add first few test cases checking for proper daemon
termination in case of receiving invalid IPC data.
---
android/ipc-tester.c | 120 +++++++++++++++++++++++++++++++++++++++++++++++++--
1 file changed, 117 insertions(+), 3 deletions(-)
diff --git a/android/ipc-tester.c b/android/ipc-tester.c
index 5901c78..72200d8 100644
--- a/android/ipc-tester.c
+++ b/android/ipc-tester.c
@@ -546,11 +546,113 @@ static void ipc_send_tc(const void *data)
3, user, g_free); \
} while (0)
-static const struct generic_data dummy_data = {
+struct regmod_msg register_bt_msg = {
+ .header = {
+ .service_id = HAL_SERVICE_ID_CORE,
+ .opcode = HAL_OP_REGISTER_MODULE,
+ .len = sizeof(struct hal_cmd_register_module),
+ },
+ .cmd = {
+ .service_id = HAL_SERVICE_ID_CORE,
+ },
+};
+
+static const struct generic_data to_small_data = {
.ipc_data = {
- .buffer = "",
+ /* valid header and payload */
+ .buffer = ®ister_bt_msg,
+ /* but write only incomplete header */
.len = 1,
},
+ .init_services = {},
+ .num_services = 0,
+};
+
+struct regmod_msg register_bt_malformed_size_msg = {
+ .header = {
+ .service_id = HAL_SERVICE_ID_CORE,
+ .opcode = HAL_OP_REGISTER_MODULE,
+ /* wrong payload size declared */
+ .len = sizeof(struct hal_cmd_register_module) - 1,
+ },
+ .cmd = {
+ .service_id = HAL_SERVICE_ID_CORE,
+ },
+};
+
+static const struct generic_data malformed_data = {
+ .ipc_data = {
+ /* use malformed msg - wrong size declared */
+ .buffer = ®ister_bt_malformed_size_msg,
+ /* but write proper size */
+ .len = sizeof(register_bt_malformed_size_msg),
+ },
+ .init_services = {HAL_SERVICE_ID_BLUETOOTH},
+ .num_services = 1,
+};
+
+struct hal_hdr enable_unknown_service_hdr = {
+ .service_id = HAL_SERVICE_ID_MAX + 1,
+ .opcode = HAL_OP_REGISTER_MODULE,
+ .len = 0,
+};
+
+static const struct generic_data enable_unknown_service_data = {
+ .ipc_data = {
+ /* enable invalid service */
+ .buffer = &enable_unknown_service_hdr,
+ .len = sizeof(enable_unknown_service_hdr),
+ },
+ .init_services = {HAL_SERVICE_ID_BLUETOOTH},
+ .num_services = 1,
+};
+
+struct hal_hdr enable_bt_service_hdr = {
+ .service_id = HAL_SERVICE_ID_BLUETOOTH,
+ .opcode = HAL_OP_ENABLE,
+ .len = 0,
+};
+
+static const struct generic_data enable_unregistered_service_data = {
+ .ipc_data = {
+ /* valid msg */
+ .buffer = &enable_bt_service_hdr,
+ /* send the whole thing */
+ .len = sizeof(enable_bt_service_hdr),
+ },
+ /* but don't register it before enabling */
+ .init_services = {},
+ .num_services = 0,
+};
+
+struct hal_hdr invalid_opcode_hdr = {
+ .service_id = HAL_SERVICE_ID_BLUETOOTH,
+ .opcode = 0x16,
+ .len = 0,
+};
+
+static const struct generic_data invalid_opcode_data = {
+ .ipc_data = {
+ /* valid msg */
+ .buffer = &invalid_opcode_hdr,
+ /* send the whole thing */
+ .len = sizeof(invalid_opcode_hdr),
+ },
+ .init_services = {HAL_SERVICE_ID_BLUETOOTH},
+ .num_services = 1,
+};
+
+struct hal_hdr invalid_msg_size_hdr = {
+ .service_id = HAL_SERVICE_ID_BLUETOOTH,
+ .opcode = HAL_OP_CREATE_BOND,
+ .len = 0,
+};
+
+static const struct generic_data invalid_msg_size_data = {
+ .ipc_data = {
+ .buffer = &invalid_msg_size_hdr,
+ .len = sizeof(invalid_msg_size_hdr),
+ },
.init_services = {HAL_SERVICE_ID_BLUETOOTH},
.num_services = 1,
};
@@ -561,7 +663,19 @@ int main(int argc, char *argv[])
tester_init(&argc, &argv);
- test_bredrle("Test Dummy", &dummy_data, setup, ipc_send_tc, teardown);
+ test_bredrle("To small data", &to_small_data,
+ setup, ipc_send_tc, teardown);
+ test_bredrle("Malformed data (wrong payload declared)", &malformed_data,
+ setup, ipc_send_tc, teardown);
+ test_bredrle("Invalid service", &enable_unknown_service_data,
+ setup, ipc_send_tc, teardown);
+ test_bredrle("Enable unregistered service",
+ &enable_unregistered_service_data,
+ setup, ipc_send_tc, teardown);
+ test_bredrle("Invalid opcode", &invalid_opcode_data,
+ setup, ipc_send_tc, teardown);
+ test_bredrle("Invalid msg size for opcode", &invalid_msg_size_data,
+ setup, ipc_send_tc, teardown);
return tester_run();
}
--
1.8.5.2
^ permalink raw reply related
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