/*

 * 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.

 *

 */

#define _GNU_SOURCE

#include <stdio.h>

#include <stdlib.h>

#include <stdbool.h>

#include <string.h>

#include <errno.h>

#include <cutils/properties.h>

#include "hal-log.h"

#include "hal.h"

#include "hal-msg.h"

#include "ipc-common.h"

#include "hal-ipc.h"

#include "hal-utils.h"

static const bt_callbacks_t *bt_hal_cbacks = NULL;

#define enum_prop_to_hal(prop, hal_prop, type) do { \

	static type e; \

	prop.val = &e; \

	prop.len = sizeof(e); \

	e = *((uint8_t *) (hal_prop->val)); \

} while (0)

#define enum_prop_from_hal(prop, hal_len, hal_val, enum_type) do { \

	enum_type e; \

	if (prop->len != sizeof(e)) { \

		error("invalid HAL property %u (%u vs %zu), aborting ", \

					prop->type, prop->len, sizeof(e)); \

		exit(EXIT_FAILURE); \

	} \

	memcpy(&e, prop->val, sizeof(e)); \

	*((uint8_t *) hal_val) = e; /* enums are mapped to 1 byte */ \

	*hal_len = 1; \

} while (0)

static void handle_adapter_state_changed(void *buf, uint16_t len, int fd)

{

	struct hal_ev_adapter_state_changed *ev = buf;

	DBG("state: %s", bt_state_t2str(ev->state));

	if (bt_hal_cbacks->adapter_state_changed_cb)

		bt_hal_cbacks->adapter_state_changed_cb(ev->state);

}

static void adapter_props_to_hal(bt_property_t *send_props,

					struct hal_property *prop,

					uint8_t num_props, uint16_t len)

{

	void *buf = prop;

	uint8_t i;

	for (i = 0; i < num_props; i++) {

		if (sizeof(*prop) + prop->len > len) {

			error("invalid adapter properties(%zu > %u), aborting",

					sizeof(*prop) + prop->len, len);

			exit(EXIT_FAILURE);

		}

		send_props[i].type = prop->type;

		switch (prop->type) {

		case HAL_PROP_ADAPTER_TYPE:

			enum_prop_to_hal(send_props[i], prop,

							bt_device_type_t);

			break;

		case HAL_PROP_ADAPTER_SCAN_MODE:

			enum_prop_to_hal(send_props[i], prop,

							bt_scan_mode_t);

			break;

		case HAL_PROP_ADAPTER_SERVICE_REC:

		default:

			send_props[i].len = prop->len;

			send_props[i].val = prop->val;

			break;

		}

		DBG("prop[%d]: %s", i, btproperty2str(&send_props[i]));

		len -= sizeof(*prop) + prop->len;

		buf += sizeof(*prop) + prop->len;

		prop = buf;

	}

	if (!len)

		return;

	error("invalid adapter properties (%u bytes left), aborting", len);

	exit(EXIT_FAILURE);

}

static void adapter_prop_from_hal(const bt_property_t *property, uint8_t *type,

						uint16_t *len, void *val)

{

	/* type match IPC type */

	*type = property->type;

	switch (property->type) {

	case HAL_PROP_ADAPTER_SCAN_MODE:

		enum_prop_from_hal(property, len, val, bt_scan_mode_t);

		break;

	case BT_PROPERTY_BDNAME:

	case BT_PROPERTY_BDADDR:

	case BT_PROPERTY_UUIDS:

	case BT_PROPERTY_CLASS_OF_DEVICE:

	case BT_PROPERTY_TYPE_OF_DEVICE:

	case BT_PROPERTY_SERVICE_RECORD:

	case BT_PROPERTY_ADAPTER_BONDED_DEVICES:

	case BT_PROPERTY_ADAPTER_DISCOVERY_TIMEOUT:

	case BT_PROPERTY_REMOTE_FRIENDLY_NAME:

	case BT_PROPERTY_REMOTE_RSSI:

	case BT_PROPERTY_REMOTE_VERSION_INFO:

	case BT_PROPERTY_REMOTE_DEVICE_TIMESTAMP:

#if ANDROID_VERSION >= PLATFORM_VER(5, 0, 0)

	case BT_PROPERTY_LOCAL_LE_FEATURES:

#endif

	default:

		*len = property->len;

		memcpy(val, property->val, property->len);

		break;

	}

}

static void device_props_to_hal(bt_property_t *send_props,

				struct hal_property *prop, uint8_t num_props,

				uint16_t len)

{

	void *buf = prop;

	uint8_t i;

	for (i = 0; i < num_props; i++) {

		if (sizeof(*prop) + prop->len > len) {

			error("invalid device properties (%zu > %u), aborting",

					sizeof(*prop) + prop->len, len);

			exit(EXIT_FAILURE);

		}

		send_props[i].type = prop->type;

		switch (prop->type) {

		case HAL_PROP_DEVICE_TYPE:

			enum_prop_to_hal(send_props[i], prop,

							bt_device_type_t);

			break;

		case HAL_PROP_DEVICE_VERSION_INFO:

		{

			static bt_remote_version_t e;

			const struct hal_prop_device_info *p;

			send_props[i].val = &e;

			send_props[i].len = sizeof(e);

			p = (struct hal_prop_device_info *) prop->val;

			e.manufacturer = p->manufacturer;

			e.sub_ver = p->sub_version;

			e.version = p->version;

		}

			break;

		case HAL_PROP_DEVICE_SERVICE_REC:

		{

			static bt_service_record_t e;

			const struct hal_prop_device_service_rec *p;

			send_props[i].val = &e;

			send_props[i].len = sizeof(e);

			p = (struct hal_prop_device_service_rec *) prop->val;

			memset(&e, 0, sizeof(e));

			memcpy(&e.channel, &p->channel, sizeof(e.channel));

			memcpy(e.uuid.uu, p->uuid, sizeof(e.uuid.uu));

			memcpy(e.name, p->name, p->name_len);

		}

			break;

		default:

			send_props[i].len = prop->len;

			send_props[i].val = prop->val;

			break;

		}

		len -= sizeof(*prop) + prop->len;

		buf += sizeof(*prop) + prop->len;

		prop = buf;

		DBG("prop[%d]: %s", i, btproperty2str(&send_props[i]));

	}

	if (!len)

		return;

	error("invalid device properties (%u bytes left), aborting", len);

	exit(EXIT_FAILURE);

}

static void handle_adapter_props_changed(void *buf, uint16_t len, int fd)

{

	struct hal_ev_adapter_props_changed *ev = buf;

	bt_property_t props[ev->num_props];

	DBG("");

	if (!bt_hal_cbacks->adapter_properties_cb)

		return;

	len -= sizeof(*ev);

	adapter_props_to_hal(props, ev->props, ev->num_props, len);

	bt_hal_cbacks->adapter_properties_cb(ev->status, ev->num_props, props);

}

static void handle_bond_state_change(void *buf, uint16_t len, int fd)

{

	struct hal_ev_bond_state_changed *ev = buf;

	bt_bdaddr_t *addr = (bt_bdaddr_t *) ev->bdaddr;

	DBG("state %u", ev->state);

	if (bt_hal_cbacks->bond_state_changed_cb)

		bt_hal_cbacks->bond_state_changed_cb(ev->status, addr,

								ev->state);

}

static void handle_pin_request(void *buf, uint16_t len, int fd)

{

	struct hal_ev_pin_request *ev = buf;

	/* Those are declared as packed, so it's safe to assign pointers */

	bt_bdaddr_t *addr = (bt_bdaddr_t *) ev->bdaddr;

	bt_bdname_t *name = (bt_bdname_t *) ev->name;

	DBG("");

	if (bt_hal_cbacks->pin_request_cb)

		bt_hal_cbacks->pin_request_cb(addr, name, ev->class_of_dev);

}

static void handle_ssp_request(void *buf, uint16_t len, int fd)

{

	struct hal_ev_ssp_request *ev = buf;

	/* Those are declared as packed, so it's safe to assign pointers */

	bt_bdaddr_t *addr = (bt_bdaddr_t *) ev->bdaddr;

	bt_bdname_t *name = (bt_bdname_t *) ev->name;

	DBG("");

	if (bt_hal_cbacks->ssp_request_cb)

		bt_hal_cbacks->ssp_request_cb(addr, name, ev->class_of_dev,

							ev->pairing_variant,

							ev->passkey);

}

void bt_thread_associate(void)

{

	if (bt_hal_cbacks->thread_evt_cb)

		bt_hal_cbacks->thread_evt_cb(ASSOCIATE_JVM);

}

void bt_thread_disassociate(void)

{

	if (bt_hal_cbacks->thread_evt_cb)

		bt_hal_cbacks->thread_evt_cb(DISASSOCIATE_JVM);

}

static bool interface_ready(void)

{

	return bt_hal_cbacks != NULL;

}

static void handle_discovery_state_changed(void *buf, uint16_t len, int fd)

{

	struct hal_ev_discovery_state_changed *ev = buf;

	DBG("");

	if (bt_hal_cbacks->discovery_state_changed_cb)

		bt_hal_cbacks->discovery_state_changed_cb(ev->state);

}

static void handle_device_found(void *buf, uint16_t len, int fd)

{

	struct hal_ev_device_found *ev = buf;

	bt_property_t props[ev->num_props];

	DBG("");

	if (!bt_hal_cbacks->device_found_cb)

		return;

	len -= sizeof(*ev);

	device_props_to_hal(props, ev->props, ev->num_props, len);

	bt_hal_cbacks->device_found_cb(ev->num_props, props);

}

static void handle_device_state_changed(void *buf, uint16_t len, int fd)

{

	struct hal_ev_remote_device_props *ev = buf;

	bt_property_t props[ev->num_props];

	DBG("");

	if (!bt_hal_cbacks->remote_device_properties_cb)

		return;

	len -= sizeof(*ev);

	device_props_to_hal(props, ev->props, ev->num_props, len);

	bt_hal_cbacks->remote_device_properties_cb(ev->status,

						(bt_bdaddr_t *)ev->bdaddr,

						ev->num_props, props);

}

static void handle_acl_state_changed(void *buf, uint16_t len, int fd)

{

	struct hal_ev_acl_state_changed *ev = buf;

	bt_bdaddr_t *addr = (bt_bdaddr_t *) ev->bdaddr;

	DBG("state %u", ev->state);

	if (bt_hal_cbacks->acl_state_changed_cb)

		bt_hal_cbacks->acl_state_changed_cb(ev->status, addr,

								ev->state);

}

static void handle_dut_mode_receive(void *buf, uint16_t len, int fd)

{

	struct hal_ev_dut_mode_receive *ev = buf;

	DBG("");

	if (len != sizeof(*ev) + ev->len) {

		error("invalid dut mode receive event (%u), aborting", len);

		exit(EXIT_FAILURE);

	}

	if (bt_hal_cbacks->dut_mode_recv_cb)

		bt_hal_cbacks->dut_mode_recv_cb(ev->opcode, ev->data, ev->len);

}

static void handle_le_test_mode(void *buf, uint16_t len, int fd)

{

	struct hal_ev_le_test_mode *ev = buf;

	DBG("");

	if (bt_hal_cbacks->le_test_mode_cb)

		bt_hal_cbacks->le_test_mode_cb(ev->status, ev->num_packets);

}

static void handle_energy_info(void *buf, uint16_t len, int fd)

{

#if ANDROID_VERSION >= PLATFORM_VER(5, 0, 0)

	struct hal_ev_energy_info *ev = buf;

	bt_activity_energy_info info;

	DBG("");

	info.ctrl_state = ev->ctrl_state;

	info.energy_used = ev->energy_used;

	info.idle_time = ev->idle_time;

	info.rx_time = ev->rx_time;

	info.status = ev->status;

	info.tx_time = ev->status;

	if (bt_hal_cbacks->energy_info_cb)

		bt_hal_cbacks->energy_info_cb(&info;;

#endif

}

/*

 * handlers will be called from notification thread context,

 * index in table equals to 'opcode - HAL_MINIMUM_EVENT'

 */

static const struct hal_ipc_handler ev_handlers[] = {

	/* HAL_EV_ADAPTER_STATE_CHANGED */

	{ handle_adapter_state_changed, false,

				sizeof(struct hal_ev_adapter_state_changed) },

	/* HAL_EV_ADAPTER_PROPS_CHANGED */

	{ handle_adapter_props_changed, true,

				sizeof(struct hal_ev_adapter_props_changed) +

				sizeof(struct hal_property) },

	/* HAL_EV_REMOTE_DEVICE_PROPS */

	{ handle_device_state_changed, true,

				sizeof(struct hal_ev_remote_device_props) +

				sizeof(struct hal_property) },

	/* HAL_EV_DEVICE_FOUND */

	{ handle_device_found, true, sizeof(struct hal_ev_device_found) +

				sizeof(struct hal_property) },

	/* HAL_EV_DISCOVERY_STATE_CHANGED */

	{ handle_discovery_state_changed, false,

				sizeof(struct hal_ev_discovery_state_changed) },

	/* HAL_EV_PIN_REQUEST */

	{ handle_pin_request, false, sizeof(struct hal_ev_pin_request) },

	/* HAL_EV_SSP_REQUEST */

	{ handle_ssp_request, false, sizeof(struct hal_ev_ssp_request) },

	/* HAL_EV_BOND_STATE_CHANGED */

	{ handle_bond_state_change, false,

				sizeof(struct hal_ev_bond_state_changed) },

	/* HAL_EV_ACL_STATE_CHANGED */

	{ handle_acl_state_changed, false,

				sizeof(struct hal_ev_acl_state_changed) },

	/* HAL_EV_DUT_MODE_RECEIVE */

	{ handle_dut_mode_receive, true,

				sizeof(struct hal_ev_dut_mode_receive) },

	/* HAL_EV_LE_TEST_MODE */

	{ handle_le_test_mode, false, sizeof(struct hal_ev_le_test_mode) },

	/* HAL_EV_ENERGY_INFO */

	{ handle_energy_info, false, sizeof(struct hal_ev_energy_info) },

};

static uint8_t get_mode(void)

{

	char value[PROPERTY_VALUE_MAX];

	if (get_config("mode", value, NULL) > 0) {

		if (!strcasecmp(value, "bredr"))

			return HAL_MODE_BREDR;

		if (!strcasecmp(value, "le"))

			return HAL_MODE_LE;

	}

	return HAL_MODE_DEFAULT;

}

static uint16_t add_prop(const char *prop, uint8_t type, void *buf)

{

	struct hal_config_prop *hal_prop = buf;

	hal_prop->type = type;

	hal_prop->len = strlen(prop) + 1;

	memcpy(hal_prop->val, prop, hal_prop->len);

	return sizeof(*hal_prop) + hal_prop->len;

}

static int send_configuration(void)

{

	char buf[IPC_MTU];

	struct hal_cmd_configuration *cmd = (void *) buf;

	char prop[PROPERTY_VALUE_MAX];

	uint16_t len = sizeof(*cmd);

	cmd->num = 0;

	if (get_config("vendor", prop, "ro.product.manufacturer") > 0) {

		len += add_prop(prop, HAL_CONFIG_VENDOR, buf + len);

		cmd->num++;

	}

	if (get_config("name", prop, "ro.product.name") > 0) {

		len += add_prop(prop, HAL_CONFIG_NAME, buf + len);

		cmd->num++;

	}

	if (get_config("model", prop, "ro.product.model") > 0) {

		len += add_prop(prop, HAL_CONFIG_MODEL, buf + len);

		cmd->num++;

	}

	if (get_config("serialno", prop, "ro.serialno") > 0) {

		len += add_prop(prop, HAL_CONFIG_SERIAL_NUMBER, buf + len);

		cmd->num++;

	}

	if (get_config("systemid", prop, NULL) > 0) {

		len += add_prop(prop, HAL_CONFIG_SYSTEM_ID, buf + len);

		cmd->num++;

	}

	if (get_config("pnpid", prop, NULL) > 0) {

		len += add_prop(prop, HAL_CONFIG_PNP_ID, buf + len);

		cmd->num++;

	}

	if (get_config("fwrev", prop, "ro.build.version.release") > 0) {

		len += add_prop(prop, HAL_CONFIG_FW_REV, buf + len);

		cmd->num++;

	}

	if (get_config("hwrev", prop, "ro.board.platform") > 0) {

		len += add_prop(prop, HAL_CONFIG_HW_REV, buf + len);

		cmd->num++;

	}

	return hal_ipc_cmd(HAL_SERVICE_ID_CORE, HAL_OP_CONFIGURATION, len, cmd,

							NULL, NULL, NULL);

}

static int init(bt_callbacks_t *callbacks)

{

	struct hal_cmd_register_module cmd;

	int status;

	DBG("");

	if (interface_ready())

		return BT_STATUS_DONE;

	hal_ipc_register(HAL_SERVICE_ID_BLUETOOTH, ev_handlers,

				sizeof(ev_handlers)/sizeof(ev_handlers[0]));

	if (!hal_ipc_init(BLUEZ_HAL_SK_PATH, sizeof(BLUEZ_HAL_SK_PATH)))

		return BT_STATUS_FAIL;

	bt_hal_cbacks = callbacks;

	/* Start Android Bluetooth daemon service */

	if (property_set("bluetooth.start", "daemon") < 0) {

		error("Failed to set bluetooth.start=daemon");

		hal_ipc_cleanup();

		bt_hal_cbacks = NULL;

		return BT_STATUS_FAIL;

	}

	if (!hal_ipc_accept()) {

		hal_ipc_cleanup();

		bt_hal_cbacks = NULL;

		return BT_STATUS_FAIL;

	}

	status = send_configuration();

	if (status != BT_STATUS_SUCCESS) {

		error("Failed to send configuration");

		goto fail;

	}

	cmd.service_id = HAL_SERVICE_ID_BLUETOOTH;

	cmd.mode = get_mode();

	cmd.max_clients = 1;

	status = hal_ipc_cmd(HAL_SERVICE_ID_CORE, HAL_OP_REGISTER_MODULE,

					sizeof(cmd), &cmd, NULL, NULL, NULL);

	if (status != BT_STATUS_SUCCESS) {

		error("Failed to register 'bluetooth' service");

		goto fail;

	}

	cmd.service_id = HAL_SERVICE_ID_SOCKET;

	cmd.max_clients = 1;

#if ANDROID_VERSION >= PLATFORM_VER(5, 0, 0)

	cmd.mode = HAL_MODE_SOCKET_DYNAMIC_MAP;

#else

	cmd.mode = HAL_MODE_DEFAULT;

#endif

	status = hal_ipc_cmd(HAL_SERVICE_ID_CORE, HAL_OP_REGISTER_MODULE,

					sizeof(cmd), &cmd, NULL, NULL, NULL);

	if (status != BT_STATUS_SUCCESS) {

		error("Failed to register 'socket' service");

		goto fail;

	}

	return status;

fail:

	hal_ipc_cleanup();

	bt_hal_cbacks = NULL;

	hal_ipc_unregister(HAL_SERVICE_ID_BLUETOOTH);

	return status;

}

static int enable(void)

{

	DBG("");

	if (!interface_ready())

		return BT_STATUS_NOT_READY;

	return hal_ipc_cmd(HAL_SERVICE_ID_BLUETOOTH, HAL_OP_ENABLE, 0, NULL,

							NULL, NULL, NULL);

}

static int disable(void)

{

	DBG("");

	if (!interface_ready())

		return BT_STATUS_NOT_READY;

	return hal_ipc_cmd(HAL_SERVICE_ID_BLUETOOTH, HAL_OP_DISABLE, 0, NULL,

							NULL, NULL, NULL);

}

static void cleanup(void)

{

	DBG("");

	if (!interface_ready())

		return;

	hal_ipc_cleanup();

	hal_ipc_unregister(HAL_SERVICE_ID_BLUETOOTH);

	bt_hal_cbacks = NULL;

}

static int get_adapter_properties(void)

{

	DBG("");

	if (!interface_ready())

		return BT_STATUS_NOT_READY;

	return hal_ipc_cmd(HAL_SERVICE_ID_BLUETOOTH, HAL_OP_GET_ADAPTER_PROPS,

						0, NULL, NULL, NULL, NULL);

}

static int get_adapter_property(bt_property_type_t type)

{

	struct hal_cmd_get_adapter_prop cmd;

	DBG("prop: %s (%d)", bt_property_type_t2str(type), type);

	if (!interface_ready())

		return BT_STATUS_NOT_READY;

	/* type match IPC type */

	cmd.type = type;

	return hal_ipc_cmd(HAL_SERVICE_ID_BLUETOOTH, HAL_OP_GET_ADAPTER_PROP,

					sizeof(cmd), &cmd, NULL, NULL, NULL);

}

static int set_adapter_property(const bt_property_t *property)

{

	char buf[IPC_MTU];

	struct hal_cmd_set_adapter_prop *cmd = (void *) buf;

	uint16_t len_ret;

	size_t len;

	DBG("prop: %s", btproperty2str(property));

	if (!interface_ready())

		return BT_STATUS_NOT_READY;

	adapter_prop_from_hal(property, &cmd->type, &len_ret, cmd->val);

	cmd->len = len_ret;

	len = sizeof(*cmd) + cmd->len;

	return hal_ipc_cmd(HAL_SERVICE_ID_BLUETOOTH, HAL_OP_SET_ADAPTER_PROP,

						len, cmd, NULL, NULL, NULL);

}

static int get_remote_device_properties(bt_bdaddr_t *remote_addr)

{

	struct hal_cmd_get_remote_device_props cmd;

	DBG("bdaddr: %s", bdaddr2str(remote_addr));

	if (!interface_ready())

		return BT_STATUS_NOT_READY;

	memcpy(cmd.bdaddr, remote_addr, sizeof(cmd.bdaddr));

	return hal_ipc_cmd(HAL_SERVICE_ID_BLUETOOTH,

					HAL_OP_GET_REMOTE_DEVICE_PROPS,

					sizeof(cmd), &cmd, NULL, NULL, NULL);

}

static int get_remote_device_property(bt_bdaddr_t *remote_addr,

						bt_property_type_t type)

{

	struct hal_cmd_get_remote_device_prop cmd;

	DBG("bdaddr: %s prop: %s", bdaddr2str(remote_addr),

						bt_property_type_t2str(type));

	if (!interface_ready())

		return BT_STATUS_NOT_READY;

	memcpy(cmd.bdaddr, remote_addr, sizeof(cmd.bdaddr));

	/* type match IPC type */

	cmd.type = type;

	return hal_ipc_cmd(HAL_SERVICE_ID_BLUETOOTH,

					HAL_OP_GET_REMOTE_DEVICE_PROP,

					sizeof(cmd), &cmd, NULL, NULL, NULL);

}

static int set_remote_device_property(bt_bdaddr_t *remote_addr,

						const bt_property_t *property)

{

	char buf[IPC_MTU];

	struct hal_cmd_set_remote_device_prop *cmd = (void *) buf;

	size_t len;

	DBG("bdaddr: %s prop: %s", bdaddr2str(remote_addr),

				bt_property_type_t2str(property->type));

	if (!interface_ready())

		return BT_STATUS_NOT_READY;

	memcpy(cmd->bdaddr, remote_addr, sizeof(cmd->bdaddr));

	/* type match IPC type */

	cmd->type = property->type;

	cmd->len = property->len;

	memcpy(cmd->val, property->val, property->len);

	len = sizeof(*cmd) + cmd->len;

	return hal_ipc_cmd(HAL_SERVICE_ID_BLUETOOTH,

					HAL_OP_SET_REMOTE_DEVICE_PROP,

					len, cmd, NULL, NULL, NULL);

}

static int get_remote_service_record(bt_bdaddr_t *remote_addr, bt_uuid_t *uuid)

{

	struct hal_cmd_get_remote_service_rec cmd;

	DBG("bdaddr: %s", bdaddr2str(remote_addr));

	if (!interface_ready())

		return BT_STATUS_NOT_READY;

	memcpy(cmd.bdaddr, remote_addr, sizeof(cmd.bdaddr));

	memcpy(cmd.uuid, uuid, sizeof(cmd.uuid));

	return hal_ipc_cmd(HAL_SERVICE_ID_BLUETOOTH,

					HAL_OP_GET_REMOTE_SERVICE_REC,

					sizeof(cmd), &cmd, NULL, NULL, NULL);

}

static int get_remote_services(bt_bdaddr_t *remote_addr)

{

	struct hal_cmd_get_remote_services cmd;

	DBG("bdaddr: %s", bdaddr2str(remote_addr));

	if (!interface_ready())

		return BT_STATUS_NOT_READY;

	memcpy(cmd.bdaddr, remote_addr, sizeof(cmd.bdaddr));

	return hal_ipc_cmd(HAL_SERVICE_ID_BLUETOOTH, HAL_OP_GET_REMOTE_SERVICES,

					sizeof(cmd), &cmd, NULL, NULL, NULL);

}

static int start_discovery(void)

{

	DBG("");

	if (!interface_ready())

		return BT_STATUS_NOT_READY;

	return hal_ipc_cmd(HAL_SERVICE_ID_BLUETOOTH, HAL_OP_START_DISCOVERY, 0,

						NULL, NULL, NULL, NULL);

}

static int cancel_discovery(void)

{

	DBG("");

	if (!interface_ready())

		return BT_STATUS_NOT_READY;

	return hal_ipc_cmd(HAL_SERVICE_ID_BLUETOOTH, HAL_OP_CANCEL_DISCOVERY, 0,

						NULL, NULL, NULL, NULL);

}

static int create_bond_real(const bt_bdaddr_t *bd_addr, int transport)

{

	struct hal_cmd_create_bond cmd;

	DBG("bdaddr: %s", bdaddr2str(bd_addr));

	if (!interface_ready())

		return BT_STATUS_NOT_READY;

	cmd.transport = transport;

	memcpy(cmd.bdaddr, bd_addr, sizeof(cmd.bdaddr));

	return hal_ipc_cmd(HAL_SERVICE_ID_BLUETOOTH, HAL_OP_CREATE_BOND,

					sizeof(cmd), &cmd, NULL, NULL, NULL);

}

#if ANDROID_VERSION >= PLATFORM_VER(5, 0, 0)

static int create_bond(const bt_bdaddr_t *bd_addr, int transport)

{

	return create_bond_real(bd_addr, transport);

}

#else

static int create_bond(const bt_bdaddr_t *bd_addr)

{

	return create_bond_real(bd_addr, BT_TRANSPORT_UNKNOWN);

}

#endif

static int cancel_bond(const bt_bdaddr_t *bd_addr)

{

	struct hal_cmd_cancel_bond cmd;

	DBG("bdaddr: %s", bdaddr2str(bd_addr));

	if (!interface_ready())

		return BT_STATUS_NOT_READY;

	memcpy(cmd.bdaddr, bd_addr, sizeof(cmd.bdaddr));

	return hal_ipc_cmd(HAL_SERVICE_ID_BLUETOOTH, HAL_OP_CANCEL_BOND,

					sizeof(cmd), &cmd, NULL, NULL, NULL);

}

static int remove_bond(const bt_bdaddr_t *bd_addr)

{

	struct hal_cmd_remove_bond cmd;

	DBG("bdaddr: %s", bdaddr2str(bd_addr));

	if (!interface_ready())

		return BT_STATUS_NOT_READY;

	memcpy(cmd.bdaddr, bd_addr, sizeof(cmd.bdaddr));

	return hal_ipc_cmd(HAL_SERVICE_ID_BLUETOOTH, HAL_OP_REMOVE_BOND,

					sizeof(cmd), &cmd, NULL, NULL, NULL);

}

static int pin_reply(const bt_bdaddr_t *bd_addr, uint8_t accept,

				uint8_t pin_len, bt_pin_code_t *pin_code)

{

	struct hal_cmd_pin_reply cmd;

	DBG("bdaddr: %s", bdaddr2str(bd_addr));

	if (!interface_ready())

		return BT_STATUS_NOT_READY;

	memcpy(cmd.bdaddr, bd_addr, sizeof(cmd.bdaddr));

	cmd.accept = accept;

	cmd.pin_len = pin_len;

	memcpy(cmd.pin_code, pin_code, sizeof(cmd.pin_code));

	return hal_ipc_cmd(HAL_SERVICE_ID_BLUETOOTH, HAL_OP_PIN_REPLY,

					sizeof(cmd), &cmd, NULL, NULL, NULL);

}

static int ssp_reply(const bt_bdaddr_t *bd_addr, bt_ssp_variant_t variant,

					uint8_t accept, uint32_t passkey)

{

	struct hal_cmd_ssp_reply cmd;

	DBG("bdaddr: %s", bdaddr2str(bd_addr));

	if (!interface_ready())

		return BT_STATUS_NOT_READY;

	memcpy(cmd.bdaddr, bd_addr, sizeof(cmd.bdaddr));

	/* type match IPC type */

	cmd.ssp_variant = variant;

	cmd.accept = accept;

	cmd.passkey = passkey;