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