bt-oal/bluez_hal/src/bt-hal-bluetooth.c

   1 /*
   2  * BLUETOOTH HAL
   3  *
   4  * Copyright (c) 2015 -2016 Samsung Electronics Co., Ltd All Rights Reserved.
   5  *
   6  * Contact: Anupam Roy <anupam.r@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *              http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <stdbool.h>
  25 #include <string.h>
  26 #include <dlog.h>
  27
  28 #include "bt-hal.h"
  29 #include "bt-hal-log.h"
  30 #include "bt-hal-msg.h"
  31 #include "bt-hal-utils.h"
  32
  33 #include <bt-hal-adapter-dbus-handler.h>
  34 #include <bt-hal-device-dbus-handler.h>
  35 #include <bt-hal-hidhost.h>
  36 #include <bt-hal-socket.h>
  37 #include <bt-hal-av.h>
  38 #include <bt-hal-hf.h>
  39 #include <bt-hal-hdp.h>
  40 #include <bt-hal-a2dp-sink.h>
  41 #include <bt-hal-avrcp-tg.h>
  42 #include <bt-hal-avrcp-ctrl.h>
  43 #include <bt-hal-gatt.h>
  44 #ifdef TIZEN_BT_HAL
  45 #include <bt-hal-adapter-le.h>
  46 #include <bt-hal-agent.h>
  47 #endif
  48 #include <bt-hal-hf-client.h>
  49
  50 #define enum_prop_to_hal(prop, hal_prop, type) do { \
  51         static type e; \
  52         prop.val = &e; \
  53         prop.len = sizeof(e); \
  54         e = *((uint8_t *) (hal_prop->val)); \
  55 } while (0)
  56
  57 static const bt_callbacks_t *bt_hal_cbacks = NULL;
  58
  59
  60 /* Forward declarations */
  61 static void __bt_adapter_props_to_hal(bt_property_t *send_props, struct hal_property *prop, uint8_t num_props, uint16_t len);
  62 static void __bt_device_props_to_hal(bt_property_t *send_props,
  63                 struct hal_property *prop, uint8_t num_props,
  64                 uint16_t len);
  65 static void __bt_hal_handle_adapter_state_changed(void *buf, uint16_t len);
  66 static void __bt_hal_handle_adapter_property_changed(void *buf, uint16_t len);
  67 static void __bt_hal_handle_stack_messages(int message, void *buf, uint16_t len);
  68 static void __bt_hal_handle_adapter_discovery_state_changed(void *buf, uint16_t len);
  69 static void __bt_hal_handle_device_found_event(void *buf, uint16_t len);
  70 static void __bt_hal_handle_bond_state_changed_event(void *buf, uint16_t len);
  71 static void __bt_hal_handle_device_acl_state_changed_event(void *buf, uint16_t len);
  72 static void __bt_hal_handle_ssp_request_event(void *buf, uint16_t len);
  73 static void __bt_hal_handle_pin_request_event(void *buf, uint16_t len);
  74
  75 static void __bt_hal_handle_device_trust_state_changed_event(void *buf, uint16_t len);
  76
  77 static bool interface_ready(void)
  78 {
  79         return bt_hal_cbacks != NULL;
  80 }
  81
  82 static int init(bt_callbacks_t *callbacks)
  83 {
  84         int ret;
  85         DBG("HAL library Initialization..");
  86
  87         if (interface_ready())
  88                 return BT_STATUS_DONE;
  89         else {
  90                 bt_hal_cbacks = callbacks;
  91                 DBG("Store HAL stack msg handler callback");
  92                 _bt_hal_dbus_store_stack_msg_cb(__bt_hal_handle_stack_messages);
  93                 ret = _bt_hal_initialize_event_receiver(__bt_hal_handle_stack_messages);
  94
  95                 if (ret == BT_STATUS_SUCCESS)
  96                         return BT_STATUS_SUCCESS;
  97                 else
  98                         return BT_STATUS_FAIL;
  99
 100         }
 101         return BT_STATUS_SUCCESS;
 102 }
 103
 104 /* Enable Adapter */
 105 static int enable(void)
 106 {
 107         return _bt_hal_dbus_enable_adapter();
 108 }
 109
 110 /* Disable Adapter */
 111 static int disable(void)
 112 {
 113         return _bt_hal_dbus_disable_adapter();
 114 }
 115
 116 #ifdef  TIZEN_BT_HAL
 117 /* Tizen Specific Reset Adapter */
 118 static int reset(void)
 119 {
 120         return _bt_hal_dbus_reset_adapter();
 121 }
 122 #endif
 123
 124 static void cleanup(void)
 125 {
 126         return;
 127 }
 128
 129 #ifdef  TIZEN_BT_HAL
 130 /* Tizen Specific Get Powered state */
 131 static int get_adapter_powered_status(uint8_t *state)
 132 {
 133         if (!state) {
 134                 ERR("Invalid param");
 135                 return BT_STATUS_PARM_INVALID;
 136         }
 137
 138         return _bt_hal_get_adapter_powered_state(state);
 139 }
 140 #endif
 141
 142 static int get_adapter_properties(void)
 143 {
 144         return _bt_hal_dbus_get_adapter_properties();
 145 }
 146
 147 static int get_adapter_property(bt_property_type_t type)
 148 {
 149         return _bt_hal_dbus_get_adapter_property(type);
 150 }
 151
 152 static int set_adapter_property(const bt_property_t *property)
 153 {
 154         if (!property) {
 155                 ERR("Invalid param");
 156                 return BT_STATUS_PARM_INVALID;
 157         }
 158
 159         return _bt_hal_dbus_set_adapter_property(property);
 160 }
 161
 162 static int get_remote_device_properties(bt_bdaddr_t *remote_addr)
 163 {
 164         if (!remote_addr) {
 165                 ERR("Invalid param");
 166                 return BT_STATUS_PARM_INVALID;
 167         }
 168
 169         return _bt_hal_dbus_get_remote_device_properties(remote_addr);
 170 }
 171
 172 static int get_remote_device_property(bt_bdaddr_t *remote_addr,
 173                 bt_property_type_t type)
 174 {
 175         return BT_STATUS_UNSUPPORTED;
 176 }
 177
 178 static int set_remote_device_property(bt_bdaddr_t *remote_addr,
 179                 const bt_property_t *property)
 180 {
 181         return _bt_hal_dbus_set_remote_device_property(remote_addr, property);
 182 }
 183
 184 static int get_remote_service_record(bt_bdaddr_t *remote_addr, bt_uuid_t *uuid)
 185 {
 186         return BT_STATUS_UNSUPPORTED;
 187 }
 188
 189 static int get_remote_services(bt_bdaddr_t *remote_addr)
 190 {
 191         if (!remote_addr) {
 192                 ERR("Invalid param");
 193                 return BT_STATUS_PARM_INVALID;
 194         }
 195         return _bt_hal_dbus_get_remote_device_services(remote_addr);
 196 }
 197
 198 static int start_discovery(void)
 199 {
 200         return _bt_hal_dbus_start_discovery(false, 0x00);
 201 }
 202
 203 #ifdef  TIZEN_BT_HAL
 204 static int start_custom_discovery(bt_disc_role_type_t disc_type)
 205 {
 206         return _bt_hal_dbus_start_discovery(true, disc_type);
 207 }
 208 #endif
 209
 210 static int cancel_discovery(void)
 211 {
 212         return _bt_hal_dbus_stop_discovery();
 213 }
 214
 215 static int create_bond(const bt_bdaddr_t *bd_addr, int transport)
 216 {
 217         DBG("+");
 218         return _bt_hal_device_create_bond(bd_addr, transport);
 219 }
 220
 221 static int cancel_bond(const bt_bdaddr_t *bd_addr)
 222 {
 223         return _bt_hal_device_cancel_bond(bd_addr);
 224 }
 225
 226 static int remove_bond(const bt_bdaddr_t *bd_addr)
 227 {
 228         DBG("+");
 229         return _bt_hal_device_remove_bond(bd_addr);
 230 }
 231
 232 static int pin_reply(const bt_bdaddr_t *bd_addr, uint8_t accept,
 233                 uint8_t pin_len, bt_pin_code_t *pin_code)
 234 {
 235         return _bt_hal_device_legacy_pin_reply(bd_addr, accept, pin_len, (char*)pin_code);
 236 }
 237
 238 static int ssp_reply(const bt_bdaddr_t *bd_addr, bt_ssp_variant_t variant,
 239                 uint8_t accept, uint32_t passkey)
 240 {
 241         return _bt_hal_device_ssp_reply(bd_addr, variant, accept, passkey);
 242 }
 243
 244 static const void *get_profile_interface(const char *profile_id)
 245 {
 246         /*TODO: Profile interfaces to be included later*/
 247         DBG("%s", profile_id);
 248
 249         if (!interface_ready())
 250                 return NULL;
 251
 252         if (!strncmp(profile_id, BT_PROFILE_HIDHOST_ID, strlen(profile_id)))
 253                 return bt_get_hidhost_interface();
 254
 255         if (!strcmp(profile_id, BT_PROFILE_SOCKETS_ID))
 256                 return bt_get_socket_interface();
 257
 258         if (!strcmp(profile_id, BT_PROFILE_PAN_ID))
 259                 return NULL;
 260
 261         if (!strcmp(profile_id, BT_PROFILE_ADVANCED_AUDIO_ID))
 262                 return bt_get_av_interface();
 263
 264         if (!strcmp(profile_id, BT_PROFILE_AV_RC_ID))
 265                 return bt_get_avrcp_tg_interface();
 266
 267         if (!strcmp(profile_id, BT_PROFILE_HANDSFREE_ID))
 268                 return bt_get_hf_interface();
 269
 270         if (!strcmp(profile_id, BT_PROFILE_HANDSFREE_CLIENT_ID))
 271                 return bt_get_hf_client_interface();
 272
 273         if (!strcmp(profile_id, BT_PROFILE_GATT_ID))
 274                 return bt_get_gatt_interface();
 275
 276         if (!strcmp(profile_id, BT_PROFILE_HEALTH_ID))
 277                 return bt_get_hl_interface();
 278
 279         if (!strcmp(profile_id, BT_PROFILE_AV_RC_CTRL_ID))
 280                 return bt_get_avrcp_ctrl_interface();
 281
 282         if (!strcmp(profile_id, BT_PROFILE_HANDSFREE_CLIENT_ID))
 283                 return NULL;
 284
 285         if (!strcmp(profile_id, BT_PROFILE_MAP_CLIENT_ID))
 286                 return NULL;
 287
 288         if (!strcmp(profile_id, BT_PROFILE_ADVANCED_AUDIO_SINK_ID))
 289                 return bt_get_a2dp_sink_interface();
 290
 291         return NULL;
 292 }
 293
 294 static int dut_mode_configure(uint8_t enable)
 295 {
 296         return BT_STATUS_UNSUPPORTED;
 297 }
 298
 299 static int dut_mode_send(uint16_t opcode, uint8_t *buf, uint8_t buf_len)
 300 {
 301         return BT_STATUS_UNSUPPORTED;
 302 }
 303
 304 static int le_test_mode(uint16_t opcode, uint8_t *buf, uint8_t buf_len)
 305 {
 306         return BT_STATUS_UNSUPPORTED;
 307 }
 308
 309 static int config_hci_snoop_log(uint8_t enable)
 310 {
 311         return BT_STATUS_UNSUPPORTED;
 312 }
 313
 314 static int get_connection_state(const bt_bdaddr_t *bd_addr)
 315 {
 316         DBG("");
 317         return _bt_hal_device_get_connection_state(bd_addr);
 318 }
 319
 320 static int set_os_callouts(bt_os_callouts_t *callouts)
 321 {
 322         DBG("callouts: %p", callouts);
 323
 324         /* TODO: implement */
 325
 326         return BT_STATUS_UNSUPPORTED;
 327 }
 328
 329 static int read_energy_info(void)
 330 {
 331         return BT_STATUS_UNSUPPORTED;
 332 }
 333
 334 static int authorize_response(const bt_bdaddr_t *bd_addr, bt_service_id_t service_id,
 335                 uint8_t authorize, uint8_t save_settings)
 336 {
 337         DBG("+");
 338         return _bt_hal_device_authorize_response(bd_addr, service_id, authorize, save_settings);
 339 }
 340
 341 int set_authorization(bt_bdaddr_t *bd_addr, uint8_t auth)
 342 {
 343         DBG("+");
 344         return _bt_hal_device_set_trust(bd_addr, auth);
 345 }
 346
 347 #ifdef TIZEN_BT_HAL
 348 static int get_service_connection_state(const bt_bdaddr_t *bd_addr, bt_service_id_t rem_svc_id)
 349 {
 350         DBG("");
 351         return _bt_hal_device_get_service_connection_state(bd_addr, rem_svc_id);
 352 }
 353
 354 static int set_agent_osp_server(uint32_t type, uint8_t enable)
 355 {
 356         DBG("");
 357         return _bt_hal_device_set_osp_server(type, enable);
 358 }
 359
 360 static int set_trusted_profile(bt_bdaddr_t *bd_addr, bt_trusted_profile_t profile, uint8_t trust)
 361 {
 362         DBG("");
 363         return _bt_hal_device_set_trusted_profile(bd_addr, profile, trust);
 364 }
 365
 366 static int get_trusted_profile(bt_bdaddr_t *bd_addr, bt_trusted_profile_t profile, uint32_t *trusted)
 367 {
 368         DBG("");
 369         return _bt_hal_device_get_trusted_profile(bd_addr, profile, trusted);
 370 }
 371
 372 static int get_connected_link_rssi_strength(bt_bdaddr_t *bd_addr, uint32_t conn_link_type)
 373 {
 374         DBG("");
 375         return _bt_hal_device_get_connected_link_rssi_strength(bd_addr, conn_link_type);
 376 }
 377
 378 static int enable_rssi_monitoring(bt_bdaddr_t *bd_addr, uint32_t conn_link_type,
 379                 int low_threshold, int in_range_threshold, int high_threshold)
 380 {
 381         DBG("");
 382         return _bt_hal_device_enable_rssi_monitoring(bd_addr, conn_link_type,
 383                         low_threshold, in_range_threshold, high_threshold);
 384 }
 385
 386 static int enable_gap_auth_notifications(uint32_t type, uint8_t enable)
 387 {
 388         DBG("");
 389         _bt_hal_enable_gap_auth_notifications(type, ((enable == 0) ? FALSE : TRUE));
 390         return BT_STATUS_SUCCESS;
 391 }
 392
 393 static int set_hal_adapter_request_state(int enable)
 394 {
 395         DBG("");
 396         _bt_hal_set_adapter_request_state(enable);
 397         return BT_STATUS_SUCCESS;
 398 }
 399
 400 static int set_hal_le_request_state(int enable)
 401 {
 402         DBG("");
 403         _bt_hal_set_le_request_state(enable);
 404         return BT_STATUS_SUCCESS;
 405 }
 406
 407 static int dev_disconnect(const bt_bdaddr_t *bd_addr)
 408 {
 409         DBG("+");
 410         return _bt_hal_device_disconnect(bd_addr);
 411 }
 412 #endif
 413
 414 static const bt_interface_t bluetooth_if = {
 415         .size = sizeof(bt_interface_t),
 416         .init = init,
 417         .enable = enable,
 418         .disable = disable,
 419 #ifdef TIZEN_BT_HAL
 420         .reset = reset,
 421 #endif
 422
 423 #ifdef TIZEN_BT_HAL
 424         .le_enable = _bt_hal_le_enable,
 425         .le_disable = _bt_hal_le_disable,
 426         .le_init = _bt_hal_le_init,
 427         .le_deinit = _bt_hal_le_deinit,
 428         .is_advertising = _bt_hal_is_advertising,
 429 #endif
 430         .cleanup = cleanup,
 431 #ifdef TIZEN_BT_HAL
 432         .get_adapter_powered_status = get_adapter_powered_status,
 433 #endif
 434         .get_adapter_properties = get_adapter_properties,
 435         .get_adapter_property = get_adapter_property,
 436         .set_adapter_property = set_adapter_property,
 437         .get_remote_device_properties = get_remote_device_properties,
 438         .get_remote_device_property = get_remote_device_property,
 439         .set_remote_device_property = set_remote_device_property,
 440         .get_remote_service_record = get_remote_service_record,
 441         .get_remote_services = get_remote_services,
 442         .start_discovery = start_discovery,
 443 #ifdef TIZEN_BT_HAL
 444         .start_custom_discovery = start_custom_discovery,
 445 #endif
 446         .cancel_discovery = cancel_discovery,
 447         .create_bond = create_bond,
 448         .remove_bond = remove_bond,
 449         .cancel_bond = cancel_bond,
 450         .pin_reply = pin_reply,
 451         .ssp_reply = ssp_reply,
 452         .get_profile_interface = get_profile_interface,
 453         .dut_mode_configure = dut_mode_configure,
 454         .dut_mode_send = dut_mode_send,
 455         .le_test_mode = le_test_mode,
 456         .config_hci_snoop_log = config_hci_snoop_log,
 457         .get_connection_state = get_connection_state,
 458         .set_os_callouts = set_os_callouts,
 459         .read_energy_info = read_energy_info,
 460         /* Tizen Specific API's*/
 461         .authorize_response = authorize_response,
 462         .set_authorization = set_authorization,
 463 #ifdef TIZEN_BT_HAL
 464         .get_service_connection_state = get_service_connection_state,
 465         .set_agent_osp_server = set_agent_osp_server,
 466         .set_trusted_profile = set_trusted_profile,
 467         .get_trusted_profile = get_trusted_profile,
 468         .enable_rssi_monitoring = enable_rssi_monitoring,
 469         .get_connected_link_rssi_strength = get_connected_link_rssi_strength,
 470         .enable_gap_auth_notifications = enable_gap_auth_notifications,
 471         .set_le_static_random_address = _bt_hal_set_le_static_random_address,
 472         .set_hal_adapter_request_state = set_hal_adapter_request_state,
 473         .set_hal_le_request_state = set_hal_le_request_state,
 474         .adapter_le_set_manufacturer_data = _bt_hal_adapter_le_set_manufacturer_data,
 475         .adapter_le_set_white_list = _bt_hal_adapter_le_set_white_list,
 476         .adapter_le_set_privacy = _bt_hal_adapter_le_set_privacy,
 477         .device_disconnect = dev_disconnect,
 478 #endif
 479 };
 480
 481 static const bt_interface_t *get_bluetooth_interface(void)
 482 {
 483         DBG("");
 484         return &bluetooth_if;
 485 }
 486
 487 static int close_bluetooth(struct hw_device_t *device)
 488 {
 489         DBG("");
 490         cleanup();
 491         free(device);
 492         return 0;
 493 }
 494
 495 static int open_bluetooth(const struct hw_module_t *module, char const *name,
 496                 struct hw_device_t **device)
 497 {
 498         bluetooth_device_t *dev = g_malloc0(sizeof(bluetooth_device_t));
 499
 500         DBG("");
 501
 502         memset(dev, 0, sizeof(bluetooth_device_t));
 503         dev->common.tag = HARDWARE_DEVICE_TAG;
 504         dev->common.version = 0;
 505         dev->common.module = (struct hw_module_t *) module;
 506         dev->common.close = close_bluetooth;
 507         dev->get_bluetooth_interface = get_bluetooth_interface;
 508
 509         *device = (struct hw_device_t *) dev;
 510
 511         return 0;
 512 }
 513
 514 static struct hw_module_methods_t bluetooth_module_methods = {
 515         .open = open_bluetooth,
 516 };
 517
 518 struct hw_module_t HAL_MODULE_INFO_SYM = {
 519         .tag = HARDWARE_MODULE_TAG,
 520         .version_major = 1,
 521         .version_minor = 0,
 522         .id = BT_HARDWARE_MODULE_ID,
 523         .name = "Bluetooth stack",
 524         .author = "Intel Corporation",
 525         .methods = &bluetooth_module_methods
 526 };
 527
 528 static void __bt_hal_handle_adapter_state_changed(void *buf, uint16_t len)
 529 {
 530         struct hal_ev_adapter_state_changed *ev = buf;
 531
 532         DBG("Adapter State: %d", ev->state);
 533
 534         if (bt_hal_cbacks->adapter_state_changed_cb)
 535                 bt_hal_cbacks->adapter_state_changed_cb(ev->state);
 536 }
 537
 538 #ifdef TIZEN_BT_HAL
 539 static void __bt_hal_handle_le_state_changed(void *buf, uint16_t len)
 540 {
 541         struct hal_ev_le_state_changed *ev = buf;
 542
 543         DBG("Adapter State: %d", ev->state);
 544
 545         if (bt_hal_cbacks->le_state_changed_cb)
 546                 bt_hal_cbacks->le_state_changed_cb(ev->state);
 547 }
 548 #endif
 549
 550 static void __bt_adapter_props_to_hal(bt_property_t *send_props, struct hal_property *prop,
 551                 uint8_t num_props, uint16_t len)
 552 {
 553         void *buf = prop;
 554         uint8_t i;
 555
 556         for (i = 0; i < num_props; i++) {
 557                 if (sizeof(*prop) + prop->len > len) {
 558                         ERR("invalid adapter properties(%zu > %u), cant process further properties!!!",
 559                                         sizeof(*prop) + prop->len, len);
 560                         return;
 561                 }
 562
 563                 send_props[i].type = prop->type;
 564
 565                 switch (prop->type) {
 566                         /* TODO: Add Adapter Properties */
 567                 default:
 568                         send_props[i].len = prop->len;
 569                         send_props[i].val = prop->val;
 570                         break;
 571                 }
 572
 573                 DBG("prop[%d]: %s", i, btproperty2str(&send_props[i]));
 574
 575                 len -= sizeof(*prop) + prop->len;
 576                 buf += sizeof(*prop) + prop->len;
 577                 prop = buf;
 578         }
 579
 580         if (!len)
 581                 return;
 582 }
 583
 584 static void __bt_device_props_to_hal(bt_property_t *send_props,
 585                 struct hal_property *prop, uint8_t num_props,
 586                 uint16_t len)
 587 {
 588         void *buf = prop;
 589         uint8_t i;
 590
 591         DBG("+");
 592
 593         for (i = 0; i < num_props; i++) {
 594
 595                 if (sizeof(*prop) + prop->len > len) {
 596                         ERR("invalid device properties (%zu > %u), cant process further properties!!!",
 597                                         sizeof(*prop) + prop->len, len);
 598                         return;
 599                 }
 600
 601                 send_props[i].type = prop->type;
 602
 603                 DBG("HAL prop Type [%d]", prop->type);
 604
 605                 switch (prop->type) {
 606                 case HAL_PROP_DEVICE_TYPE:
 607                 {
 608                         DBG("Device property:HAL_PROP_DEVICE_TYPE:");
 609                         enum_prop_to_hal(send_props[i], prop,
 610                                         bt_device_type_t);
 611                         break;
 612                 }
 613                 case HAL_PROP_DEVICE_VERSION_INFO:
 614                 {
 615                         DBG("Device property: HAL_PROP_DEVICE_VERSION_INFO");
 616                         static bt_remote_version_t e;
 617                         const struct hal_prop_device_info *p;
 618                         send_props[i].val = &e;
 619                         send_props[i].len = sizeof(e);
 620                                 p = (struct hal_prop_device_info *) prop->val;
 621                                 e.manufacturer = p->manufacturer;
 622                         e.sub_ver = p->sub_version;
 623                         e.version = p->version;
 624                         break;
 625                 }
 626                 case HAL_PROP_DEVICE_SERVICE_REC:
 627                 {
 628                         DBG("Device property: HAL_PROP_DEVICE_SERVICE_REC");
 629                         static bt_service_record_t e;
 630                         const struct hal_prop_device_service_rec *p;
 631                         send_props[i].val = &e;
 632                         send_props[i].len = sizeof(e);
 633                                 p = (struct hal_prop_device_service_rec *) prop->val;
 634                                         memset(&e, 0, sizeof(e));
 635                         memcpy(&e.channel, &p->channel, sizeof(e.channel));
 636                         memcpy(e.uuid.uu, p->uuid, sizeof(e.uuid.uu));
 637                         memcpy(e.name, p->name, p->name_len);
 638                         break;
 639                 }
 640                 default:
 641                         send_props[i].len = prop->len;
 642                         send_props[i].val = prop->val;
 643                         break;
 644                 }
 645
 646                 DBG("prop[%d]: %s, len: %d", i, btproperty2str(&send_props[i]), prop->len);
 647                 len -= sizeof(*prop) + prop->len;
 648                 buf += sizeof(*prop) + prop->len;
 649                 prop = buf;
 650
 651         }
 652
 653         if (!len) {
 654                 DBG("-");
 655                 return;
 656         }
 657
 658         ERR("invalid device properties (%u bytes left), ", len);
 659 }
 660
 661 static void __bt_hal_handle_adapter_property_changed(void *buf, uint16_t len)
 662 {
 663         struct hal_ev_adapter_props_changed *ev = (struct hal_ev_adapter_props_changed *)buf;
 664         bt_property_t props[ev->num_props];
 665         DBG("+");
 666
 667         if (!bt_hal_cbacks->adapter_properties_cb)
 668                 return;
 669
 670         len -= sizeof(*ev);
 671         __bt_adapter_props_to_hal(props, ev->props, ev->num_props, len);
 672
 673         if (bt_hal_cbacks->adapter_properties_cb)
 674                 bt_hal_cbacks->adapter_properties_cb(ev->status, ev->num_props, props);
 675 }
 676
 677 static void __bt_hal_handle_adapter_discovery_state_changed(void *buf, uint16_t len)
 678 {
 679         struct hal_ev_discovery_state_changed *ev = (struct hal_ev_discovery_state_changed *)buf;
 680
 681         DBG("+");
 682
 683         if (bt_hal_cbacks->discovery_state_changed_cb)
 684                 bt_hal_cbacks->discovery_state_changed_cb(ev->state);
 685 }
 686
 687 static void __bt_hal_handle_device_found_event(void *buf, uint16_t len)
 688 {
 689         struct hal_ev_device_found *ev =  (struct hal_ev_device_found *) buf;
 690         bt_property_t props[ev->num_props];
 691         DBG("+");
 692
 693         if (!bt_hal_cbacks->device_found_cb)
 694                 return;
 695
 696         len -= sizeof(*ev);
 697         __bt_device_props_to_hal(props, ev->props, ev->num_props, len);
 698
 699         bt_hal_cbacks->device_found_cb(ev->num_props, props);
 700 }
 701
 702 static void __bt_hal_handle_remote_device_properties_event(void *buf, uint16_t len)
 703 {
 704         struct hal_ev_remote_device_props *ev = (struct hal_ev_remote_device_props *) buf;
 705         bt_bdaddr_t bd_addr;
 706         bt_property_t props[ev->num_props];
 707
 708         DBG("+");
 709
 710         if (!bt_hal_cbacks->remote_device_properties_cb)
 711                 return;
 712
 713         len -= sizeof(*ev);
 714         __bt_device_props_to_hal(props, ev->props, ev->num_props, len);
 715         memcpy(bd_addr.address, ev->bdaddr, 6);
 716         bt_hal_cbacks->remote_device_properties_cb(
 717                         ev->status, &bd_addr, ev->num_props, props);
 718         DBG("-");
 719 }
 720
 721 static void __bt_hal_handle_bond_state_changed_event(void *buf, uint16_t len)
 722 {
 723
 724         struct hal_ev_bond_state_changed *ev = (struct hal_ev_bond_state_changed *)buf;
 725         bt_bdaddr_t bd_addr;
 726         DBG("+");
 727
 728         memcpy(bd_addr.address, ev->bdaddr, 6);
 729         /* BD address*/
 730         DBG("[0x%x]", bd_addr.address[0]);
 731         DBG("[0x%x]", bd_addr.address[1]);
 732         DBG("[0x%x]", bd_addr.address[2]);
 733         DBG("[0x%x]", bd_addr.address[3]);
 734         DBG("[0x%x]", bd_addr.address[4]);
 735         DBG("[0x%x]", bd_addr.address[5]);
 736
 737         DBG("Bonding  State changed Status [0x%x]", ev->status);
 738         DBG("Bonding  State [0x%x]", ev->state);
 739
 740         if (!bt_hal_cbacks->bond_state_changed_cb) {
 741                 ERR("HAL User bond_state_changed_callback is not set!!");
 742                 return;
 743         }
 744
 745         bt_hal_cbacks->bond_state_changed_cb(ev->status, &bd_addr, ev->state);
 746         DBG("-");
 747 }
 748
 749 static void __bt_hal_handle_device_acl_state_changed_event(void *buf, uint16_t len)
 750 {
 751         struct hal_ev_acl_state_changed *ev = (struct hal_ev_acl_state_changed*)buf;
 752         bt_bdaddr_t bd_addr;
 753         DBG("+");
 754
 755         memcpy(bd_addr.address, ev->bdaddr, 6);
 756         /* BD address*/
 757         DBG("[0x%x]", bd_addr.address[0]);
 758         DBG("[0x%x]", bd_addr.address[1]);
 759         DBG("[0x%x]", bd_addr.address[2]);
 760         DBG("[0x%x]", bd_addr.address[3]);
 761         DBG("[0x%x]", bd_addr.address[4]);
 762         DBG("[0x%x]", bd_addr.address[5]);
 763
 764         DBG("ACL Status [0x%x]", ev->status);
 765         DBG("ACL State  [0x%x]", ev->state);
 766
 767         if (!bt_hal_cbacks->acl_state_changed_cb) {
 768                 ERR("HAL User acl_state_changed_cb is not set!!");
 769                 return;
 770         }
 771
 772         bt_hal_cbacks->acl_state_changed_cb(ev->status, &bd_addr, ev->state);
 773         DBG("-");
 774 }
 775
 776 static void __bt_hal_handle_device_le_conn_state_changed_event(void *buf, uint16_t len)
 777 {
 778         struct hal_ev_acl_state_changed *ev = (struct hal_ev_acl_state_changed*)buf;
 779         bt_bdaddr_t bd_addr;
 780         DBG("+");
 781
 782         memcpy(bd_addr.address, ev->bdaddr, 6);
 783         /* BD address */
 784         DBG("Address: [%02X:%02X:%02X:%02X:%02X:%02X]", bd_addr.address[0],
 785                         bd_addr.address[1], bd_addr.address[2], bd_addr.address[3],
 786                         bd_addr.address[4], bd_addr.address[5]);
 787         DBG("LE conn Status [0x%x]", ev->status);
 788         DBG("LE conn State  [0x%x]", ev->state);
 789
 790 #ifdef TIZEN_BT_HAL
 791         if (!bt_hal_cbacks->le_conn_state_changed_cb) {
 792                 ERR("HAL User le_conn_state_changed_cb is not set!!");
 793                 return;
 794         }
 795
 796         bt_hal_cbacks->le_conn_state_changed_cb(ev->status, &bd_addr, ev->state);
 797 #endif
 798         DBG("-");
 799 }
 800
 801 static void __bt_hal_handle_authorize_request_event(void *buf, uint16_t len)
 802 {
 803         struct hal_ev_authorize_request *ev = (struct hal_ev_authorize_request *)buf;
 804         bt_bdaddr_t bd_addr;
 805
 806         DBG("+");
 807
 808         memcpy(bd_addr.address, ev->bdaddr, 6);
 809
 810         /* BD address*/
 811         DBG("[0x%x]", bd_addr.address[0]);
 812         DBG("[0x%x]", bd_addr.address[1]);
 813         DBG("[0x%x]", bd_addr.address[2]);
 814         DBG("[0x%x]", bd_addr.address[3]);
 815         DBG("[0x%x]", bd_addr.address[4]);
 816         DBG("[0x%x]", bd_addr.address[5]);
 817
 818         DBG("Service Id: [%u]", ev->service_id);
 819
 820         if (!bt_hal_cbacks->authorize_request_cb) {
 821                 ERR("HAL User authorize_request_cb is not set!!");
 822                 return;
 823         }
 824
 825         bt_hal_cbacks->authorize_request_cb(&bd_addr, ev->service_id);
 826         DBG("-");
 827 }
 828
 829 #ifdef TIZEN_BT_HAL
 830 static void __bt_hal_handle_socket_authorize_request_event(void *buf, uint16_t len)
 831 {
 832         struct hal_ev_sock_conn_auth *ev = buf;
 833         bt_bdaddr_t bd_addr;
 834         bt_uuid_t uuid;
 835
 836         DBG("+");
 837
 838         memcpy(bd_addr.address, ev->bdaddr, 6);
 839         memcpy(uuid.uu, ev->uuid, 16);
 840
 841         if (!bt_hal_cbacks->socket_authorize_request_cb) {
 842                 ERR("HAL User socket_authorize_request_cb is not set!!");
 843                 return;
 844         }
 845
 846         bt_hal_cbacks->socket_authorize_request_cb(&bd_addr, &uuid);
 847         DBG("-");
 848 }
 849 #endif
 850
 851 static void __bt_hal_handle_ssp_request_event(void *buf, uint16_t len)
 852 {
 853         struct hal_ev_ssp_request *ev = (struct hal_ev_ssp_request *)buf;
 854         bt_bdaddr_t bd_addr;
 855         bt_bdname_t bd_name;
 856         DBG("+");
 857
 858         memcpy(bd_addr.address, ev->bdaddr, 6);
 859         memcpy(bd_name.name, ev->name, 248);
 860
 861         /* BD address*/
 862         DBG("[0x%x]", bd_addr.address[0]);
 863         DBG("[0x%x]", bd_addr.address[1]);
 864         DBG("[0x%x]", bd_addr.address[2]);
 865         DBG("[0x%x]", bd_addr.address[3]);
 866         DBG("[0x%x]", bd_addr.address[4]);
 867         DBG("[0x%x]", bd_addr.address[5]);
 868
 869         DBG("COD [%d]", ev->class_of_dev);
 870         DBG("pairing variant [%d]", ev->pairing_variant);
 871         DBG("passkey [%d]", ev->passkey);
 872
 873         if (!bt_hal_cbacks->ssp_request_cb) {
 874                 ERR("HAL User ssp_request_cb is not set!!");
 875                 return;
 876         }
 877
 878         bt_hal_cbacks->ssp_request_cb(&bd_addr, &bd_name,
 879                         ev->class_of_dev,
 880                         ev->pairing_variant, ev->passkey);
 881         DBG("-");
 882 }
 883
 884 static void __bt_hal_handle_pin_request_event(void *buf, uint16_t len)
 885 {
 886         struct hal_ev_pin_request *ev = (struct hal_ev_pin_request *)buf;
 887         bt_bdaddr_t bd_addr;
 888         bt_bdname_t bd_name;
 889         DBG("+");
 890
 891         memcpy(bd_addr.address, ev->bdaddr, 6);
 892         memcpy(bd_name.name, ev->name, 248);
 893
 894         /* BD address*/
 895         DBG("[0x%x]", bd_addr.address[0]);
 896         DBG("[0x%x]", bd_addr.address[1]);
 897         DBG("[0x%x]", bd_addr.address[2]);
 898         DBG("[0x%x]", bd_addr.address[3]);
 899         DBG("[0x%x]", bd_addr.address[4]);
 900         DBG("[0x%x]", bd_addr.address[5]);
 901
 902         DBG("COD [%u]", ev->class_of_dev);
 903
 904         if (!bt_hal_cbacks->pin_request_cb) {
 905                 ERR("HAL User pin_request_cb is not set!!");
 906                 return;
 907         }
 908
 909         bt_hal_cbacks->pin_request_cb(&bd_addr, &bd_name,
 910                         ev->class_of_dev);
 911         DBG("-");
 912 }
 913
 914 static void __bt_hal_handle_device_trust_state_changed_event(void *buf, uint16_t len)
 915 {
 916         struct hal_ev_device_trust_state_changed *ev = (struct hal_ev_device_trust_state_changed*)buf;
 917         bt_bdaddr_t bd_addr;
 918         DBG("+");
 919
 920         memcpy(bd_addr.address, ev->bdaddr, 6);
 921         /* BD address*/
 922         DBG("[0x%x]", bd_addr.address[0]);
 923         DBG("[0x%x]", bd_addr.address[1]);
 924         DBG("[0x%x]", bd_addr.address[2]);
 925         DBG("[0x%x]", bd_addr.address[3]);
 926         DBG("[0x%x]", bd_addr.address[4]);
 927         DBG("[0x%x]", bd_addr.address[5]);
 928
 929         DBG("Device Trusted?  [0x%x]", ev->trust);
 930
 931         if (!bt_hal_cbacks->device_trust_state_changed_cb) {
 932                 ERR("HAL User device_trust_state_changed_cb is not set!!");
 933                 return;
 934         }
 935
 936         bt_hal_cbacks->device_trust_state_changed_cb(&bd_addr, ev->trust);
 937         DBG("-");
 938 }
 939
 940 static void __bt_hal_handle_device_trusted_profiles_changed_event(void *buf, uint16_t len)
 941 {
 942         struct hal_ev_device_trusted_profiles_changed *ev = buf;
 943         bt_bdaddr_t bd_addr;
 944
 945         DBG("+");
 946 #ifdef TIZEN_BT_HAL
 947         memcpy(bd_addr.address, ev->bdaddr, 6);
 948         DBG("[0x%02X:%02X:%02X:%02X:%02X:%02X]",
 949                         bd_addr.address[0], bd_addr.address[1],
 950                         bd_addr.address[2], bd_addr.address[3],
 951                         bd_addr.address[4], bd_addr.address[5]);
 952
 953         if (!bt_hal_cbacks->device_trusted_profiles_changed_cb) {
 954                 ERR("device_trusted_profiles_changed_cb is NULL");
 955                 return;
 956         }
 957
 958         bt_hal_cbacks->device_trusted_profiles_changed_cb(&bd_addr, ev->trust_val);
 959 #endif
 960         DBG("-");
 961 }
 962
 963 static void __bt_handle_rssi_monitor_state_changed(void *buf, uint16_t len)
 964 {
 965         struct hal_ev_rssi_monitor_state_changed *ev = buf;
 966         bt_bdaddr_t bd_addr;
 967
 968         DBG("+");
 969 #ifdef TIZEN_BT_HAL
 970         memcpy(bd_addr.address, ev->bdaddr, 6);
 971         DBG("[0x%02X:%02X:%02X:%02X:%02X:%02X]",
 972                         bd_addr.address[0], bd_addr.address[1],
 973                         bd_addr.address[2], bd_addr.address[3],
 974                         bd_addr.address[4], bd_addr.address[5]);
 975
 976         if (bt_hal_cbacks->rssi_monitor_state_changed_cb)
 977                 bt_hal_cbacks->rssi_monitor_state_changed_cb(
 978                                 &bd_addr, ev->link_type, ev->state);
 979 #endif
 980         DBG("-");
 981 }
 982
 983 static void __bt_handle_rssi_alert_recieved(void *buf, uint16_t len)
 984 {
 985         struct hal_ev_rssi_alert_recieved *ev = buf;
 986         bt_bdaddr_t bd_addr;
 987
 988         DBG("+");
 989 #ifdef TIZEN_BT_HAL
 990         memcpy(bd_addr.address, ev->bdaddr, 6);
 991         DBG("[0x%02X:%02X:%02X:%02X:%02X:%02X]",
 992                         bd_addr.address[0], bd_addr.address[1],
 993                         bd_addr.address[2], bd_addr.address[3],
 994                         bd_addr.address[4], bd_addr.address[5]);
 995
 996         if (bt_hal_cbacks->rssi_alert_cb)
 997                 bt_hal_cbacks->rssi_alert_cb(
 998                                 &bd_addr, ev->link_type, ev->alert_type, ev->rssi);
 999 #endif
1000         DBG("-");
1001 }
1002
1003 static void __bt_handle_raw_rssi_recieved(void *buf, uint16_t len)
1004 {
1005         struct hal_ev_raw_rssi_recieved *ev = buf;
1006         bt_bdaddr_t bd_addr;
1007
1008         DBG("+");
1009 #ifdef TIZEN_BT_HAL
1010         memcpy(bd_addr.address, ev->bdaddr, 6);
1011         DBG("[0x%02X:%02X:%02X:%02X:%02X:%02X]",
1012                         bd_addr.address[0], bd_addr.address[1],
1013                         bd_addr.address[2], bd_addr.address[3],
1014                         bd_addr.address[4], bd_addr.address[5]);
1015
1016         if (bt_hal_cbacks->raw_rssi_received_cb)
1017                 bt_hal_cbacks->raw_rssi_received_cb(
1018                                 &bd_addr, ev->link_type, ev->rssi);
1019 #endif
1020         DBG("-");
1021 }
1022
1023 static void __bt_hal_handle_stack_messages(int message, void *buf, uint16_t len)
1024 {
1025         DBG("+");
1026         switch (message) {
1027         case HAL_EV_ADAPTER_STATE_CHANGED:
1028                 DBG("Event: HAL_EV_ADAPTER_STATE_CHANGED");
1029                 __bt_hal_handle_adapter_state_changed(buf, len);
1030                 break;
1031         case HAL_EV_ADAPTER_PROPS_CHANGED:
1032                 DBG("Event: HAL_EV_ADAPTER_PROPS_CHANGED");
1033                 __bt_hal_handle_adapter_property_changed(buf, len);
1034                 break;
1035         case HAL_EV_DISCOVERY_STATE_CHANGED:
1036                 DBG("Event: HAL_EV_DISCOVERY_STATE_CHANGED");
1037                 __bt_hal_handle_adapter_discovery_state_changed(buf, len);
1038                 break;
1039         case HAL_EV_DEVICE_FOUND:
1040                 DBG("Event: HAL_EV_DEVICE_FOUND");
1041                 __bt_hal_handle_device_found_event(buf, len);
1042                 break;
1043         case HAL_EV_REMOTE_DEVICE_PROPS:
1044                 DBG("Event: HAL_EV_REMOTE_DEVICE_PROPS");
1045                 __bt_hal_handle_remote_device_properties_event(buf, len);
1046                 break;
1047         case HAL_EV_BOND_STATE_CHANGED:
1048                 DBG("Event: HAL_EV_BOND_STATE_CHANGED:");
1049                 __bt_hal_handle_bond_state_changed_event(buf, len);
1050                 break;
1051         case HAL_EV_ACL_STATE_CHANGED:
1052                 DBG("Event: HAL_ACL_STATE_CONNECTED or Disconnected");
1053                 __bt_hal_handle_device_acl_state_changed_event(buf, len);
1054                 break;
1055         case HAL_EV_LE_CONN_STATE_CHANGED:
1056                 DBG("Event: HAL_LE_CONN_STATE_CONNECTED or Disconnected");
1057                 __bt_hal_handle_device_le_conn_state_changed_event(buf, len);
1058                 break;
1059         case HAL_EV_SSP_REQUEST:
1060                 DBG("Event: HAL_EV_SSP_REQUEST");
1061                 __bt_hal_handle_ssp_request_event(buf, len);
1062                 break;
1063         case HAL_EV_PIN_REQUEST:
1064                 DBG("Event: HAL_EV_PIN_REQUEST");
1065                 __bt_hal_handle_pin_request_event(buf, len);
1066                 break;
1067         case HAL_EV_AUTHORIZE_REQUEST:
1068                 DBG("Event: HAL_EV_AUTHORIZE_REQUEST");
1069                 __bt_hal_handle_authorize_request_event(buf, len);
1070                 break;
1071         case HAL_EV_DEVICE_TRUST_CHANGED:
1072                 DBG("Event: HAL_EV_DEVICE_TRUST_CHANGED");
1073                 __bt_hal_handle_device_trust_state_changed_event(buf, len);
1074                 break;
1075 #ifdef TIZEN_BT_HAL
1076         case HAL_EV_SOCK_AUTHORIZE_REQUEST:
1077                 DBG("Event: HAL_EV_AUTHORIZE_REQUEST");
1078                 __bt_hal_handle_socket_authorize_request_event(buf, len);
1079                 break;
1080         case HAL_EV_LE_STATE_CHANGED:
1081                 DBG("Event: HAL_EV_LE_STATE_CHANGED");
1082                 __bt_hal_handle_le_state_changed(buf, len);
1083                 break;
1084 #endif
1085         case HAL_EV_DEVICE_TRUSTED_PROFILES_CHANGED:
1086                 DBG("Event: HAL_EV_DEVICE_TRUST_CHANGED");
1087                 __bt_hal_handle_device_trusted_profiles_changed_event(buf, len);
1088                 break;
1089         case HAL_EV_RSSI_MONITOR_STATE_CHANGED:
1090                 DBG("Event: HAL_EV_RSSI_MONITOR_STATE_CHANGED");
1091                 __bt_handle_rssi_monitor_state_changed(buf, len);
1092                 break;
1093         case HAL_EV_RSSI_ALERT_RECIEVED:
1094                 DBG("Event: HAL_EV_RSSI_ALERT_RECIEVED");
1095                 __bt_handle_rssi_alert_recieved(buf, len);
1096                 break;
1097         case HAL_EV_RAW_RSSI_RECIEVED:
1098                 DBG("Event: HAL_EV_RAW_RSSI_RECIEVED");
1099                 __bt_handle_raw_rssi_recieved(buf, len);
1100                 break;
1101         default:
1102                 DBG("Event Currently not handled!!");
1103                 break;
1104         }
1105         DBG("-");
1106 }