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         return _bt_hal_device_create_bond(bd_addr, transport);
 227 }
 228
 229 static int cancel_bond(const bt_bdaddr_t *bd_addr)
 230 {
 231         return _bt_hal_device_cancel_bond(bd_addr);
 232 }
 233
 234 static int remove_bond(const bt_bdaddr_t *bd_addr)
 235 {
 236         return _bt_hal_device_remove_bond(bd_addr);
 237 }
 238
 239 static int pin_reply(const bt_bdaddr_t *bd_addr, uint8_t accept,
 240                 uint8_t pin_len, bt_pin_code_t *pin_code)
 241 {
 242         return _bt_hal_device_legacy_pin_reply(bd_addr, accept, pin_len, (char*)pin_code);
 243 }
 244
 245 static int ssp_reply(const bt_bdaddr_t *bd_addr, bt_ssp_variant_t variant,
 246                 uint8_t accept, uint32_t passkey)
 247 {
 248         return _bt_hal_device_ssp_reply(bd_addr, variant, accept, passkey);
 249 }
 250
 251 static const void *get_profile_interface(const char *profile_id)
 252 {
 253         /*TODO: Profile interfaces to be included later*/
 254         DBG("%s", profile_id);
 255
 256         if (!interface_ready())
 257                 return NULL;
 258
 259         if (!strncmp(profile_id, BT_PROFILE_HIDHOST_ID, strlen(profile_id)))
 260                 return bt_get_hidhost_interface();
 261
 262         if (!strcmp(profile_id, BT_PROFILE_HIDDEVICE_ID))
 263                 return bt_get_hiddevice_interface();
 264
 265         if (!strcmp(profile_id, BT_PROFILE_SOCKETS_ID))
 266                 return bt_get_socket_interface();
 267
 268         if (!strcmp(profile_id, BT_PROFILE_PAN_ID))
 269                 return NULL;
 270
 271         if (!strcmp(profile_id, BT_PROFILE_ADVANCED_AUDIO_ID))
 272                 return bt_get_av_interface();
 273
 274         if (!strcmp(profile_id, BT_PROFILE_AV_RC_ID))
 275                 return bt_get_avrcp_tg_interface();
 276
 277         if (!strcmp(profile_id, BT_PROFILE_HANDSFREE_ID))
 278                 return bt_get_hf_interface();
 279
 280         if (!strcmp(profile_id, BT_PROFILE_HANDSFREE_CLIENT_ID))
 281                 return bt_get_hf_client_interface();
 282
 283         if (!strcmp(profile_id, BT_PROFILE_GATT_ID))
 284                 return bt_get_gatt_interface();
 285
 286         if (!strcmp(profile_id, BT_PROFILE_HEALTH_ID))
 287                 return bt_get_hl_interface();
 288
 289         if (!strcmp(profile_id, BT_PROFILE_AV_RC_CTRL_ID))
 290                 return bt_get_avrcp_ctrl_interface();
 291
 292         if (!strcmp(profile_id, BT_PROFILE_HANDSFREE_CLIENT_ID))
 293                 return NULL;
 294
 295         if (!strcmp(profile_id, BT_PROFILE_MAP_CLIENT_ID))
 296                 return NULL;
 297
 298         if (!strcmp(profile_id, BT_PROFILE_ADVANCED_AUDIO_SINK_ID))
 299                 return bt_get_a2dp_sink_interface();
 300
 301         return NULL;
 302 }
 303
 304 static int dut_mode_configure(uint8_t enable)
 305 {
 306         return BT_STATUS_UNSUPPORTED;
 307 }
 308
 309 static int dut_mode_send(uint16_t opcode, uint8_t *buf, uint8_t buf_len)
 310 {
 311         return BT_STATUS_UNSUPPORTED;
 312 }
 313
 314 static int le_test_mode(uint16_t opcode, uint8_t *buf, uint8_t buf_len)
 315 {
 316         return BT_STATUS_UNSUPPORTED;
 317 }
 318
 319 static int config_hci_snoop_log(uint8_t enable)
 320 {
 321         return BT_STATUS_UNSUPPORTED;
 322 }
 323
 324 static int get_connection_state(const bt_bdaddr_t *bd_addr)
 325 {
 326         DBG("");
 327         return _bt_hal_device_get_connection_state(bd_addr);
 328 }
 329
 330 static int set_os_callouts(bt_os_callouts_t *callouts)
 331 {
 332         DBG("callouts: %p", callouts);
 333
 334         /* TODO: implement */
 335
 336         return BT_STATUS_UNSUPPORTED;
 337 }
 338
 339 static int read_energy_info(void)
 340 {
 341         return BT_STATUS_UNSUPPORTED;
 342 }
 343
 344 static int authorize_response(const bt_bdaddr_t *bd_addr, bt_service_id_t service_id,
 345                 uint8_t authorize, uint8_t save_settings)
 346 {
 347         return _bt_hal_device_authorize_response(bd_addr, service_id, authorize, save_settings);
 348 }
 349
 350 int set_authorization(bt_bdaddr_t *bd_addr, uint8_t auth)
 351 {
 352         return _bt_hal_device_set_trust(bd_addr, auth);
 353 }
 354
 355 #ifdef TIZEN_BT_HAL
 356 static int get_service_connection_state(const bt_bdaddr_t *bd_addr, bt_service_id_t rem_svc_id)
 357 {
 358         DBG("");
 359         return _bt_hal_device_get_service_connection_state(bd_addr, rem_svc_id);
 360 }
 361
 362 static int register_agent_osp_server(uint32_t type, char *uuid, char *path, int fd)
 363 {
 364         DBG("");
 365         return _bt_hal_device_register_osp_server(type, uuid, path, fd);
 366 }
 367
 368 static int unregister_agent_osp_server(uint32_t type, char *uuid)
 369 {
 370         DBG("");
 371         return _bt_hal_device_unregister_osp_server(type, uuid);
 372 }
 373
 374 static int set_trusted_profile(bt_bdaddr_t *bd_addr, bt_trusted_profile_t profile, uint8_t trust)
 375 {
 376         DBG("");
 377         return _bt_hal_device_set_trusted_profile(bd_addr, profile, trust);
 378 }
 379
 380 static int get_trusted_profile(bt_bdaddr_t *bd_addr, bt_trusted_profile_t profile, uint32_t *trusted)
 381 {
 382         DBG("");
 383         return _bt_hal_device_get_trusted_profile(bd_addr, profile, trusted);
 384 }
 385
 386 static int get_device_ida(bt_bdaddr_t *bd_addr, bt_bdaddr_t *id_addr)
 387 {
 388         DBG("");
 389         return _bt_hal_device_get_ida(bd_addr, id_addr);
 390 }
 391
 392 static int get_connected_link_rssi_strength(bt_bdaddr_t *bd_addr, uint32_t conn_link_type)
 393 {
 394         DBG("");
 395         return _bt_hal_device_get_connected_link_rssi_strength(bd_addr, conn_link_type);
 396 }
 397
 398 static int enable_rssi_monitoring(bt_bdaddr_t *bd_addr, uint32_t conn_link_type,
 399                 int low_threshold, int in_range_threshold, int high_threshold)
 400 {
 401         DBG("");
 402         return _bt_hal_device_enable_rssi_monitoring(bd_addr, conn_link_type,
 403                         low_threshold, in_range_threshold, high_threshold);
 404 }
 405
 406 static int enable_gap_auth_notifications(uint32_t type, uint8_t enable)
 407 {
 408         DBG("");
 409         _bt_hal_enable_gap_auth_notifications(type, ((enable == 0) ? FALSE : TRUE));
 410         return BT_STATUS_SUCCESS;
 411 }
 412
 413 static int set_hal_adapter_request_state(int enable)
 414 {
 415         DBG("");
 416         _bt_hal_set_adapter_request_state(enable);
 417         return BT_STATUS_SUCCESS;
 418 }
 419
 420 static int set_hal_le_request_state(int enable)
 421 {
 422         DBG("");
 423         _bt_hal_set_le_request_state(enable);
 424         return BT_STATUS_SUCCESS;
 425 }
 426
 427 static int dev_disconnect(const bt_bdaddr_t *bd_addr)
 428 {
 429         return _bt_hal_device_disconnect(bd_addr);
 430 }
 431 #endif
 432
 433 static const bt_interface_t bluetooth_if = {
 434         .size = sizeof(bt_interface_t),
 435         .init = init,
 436         .enable = enable,
 437         .disable = disable,
 438
 439 #ifdef TIZEN_BT_HAL
 440         .recover = recover,
 441         .reset = reset,
 442 #endif
 443
 444 #ifdef TIZEN_BT_HAL
 445         .le_enable = _bt_hal_le_enable,
 446         .le_disable = _bt_hal_le_disable,
 447         .le_init = _bt_hal_le_init,
 448         .le_deinit = _bt_hal_le_deinit,
 449         .is_advertising = _bt_hal_is_advertising,
 450 #endif
 451         .cleanup = cleanup,
 452 #ifdef TIZEN_BT_HAL
 453         .get_adapter_powered_status = get_adapter_powered_status,
 454 #endif
 455         .get_adapter_properties = get_adapter_properties,
 456         .get_adapter_property = get_adapter_property,
 457         .set_adapter_property = set_adapter_property,
 458         .get_remote_device_properties = get_remote_device_properties,
 459         .get_remote_device_property = get_remote_device_property,
 460         .set_remote_device_property = set_remote_device_property,
 461         .get_remote_service_record = get_remote_service_record,
 462         .get_remote_services = get_remote_services,
 463         .start_discovery = start_discovery,
 464 #ifdef TIZEN_BT_HAL
 465         .start_custom_discovery = start_custom_discovery,
 466 #endif
 467         .cancel_discovery = cancel_discovery,
 468         .create_bond = create_bond,
 469         .remove_bond = remove_bond,
 470         .cancel_bond = cancel_bond,
 471         .pin_reply = pin_reply,
 472         .ssp_reply = ssp_reply,
 473         .get_profile_interface = get_profile_interface,
 474         .dut_mode_configure = dut_mode_configure,
 475         .dut_mode_send = dut_mode_send,
 476         .le_test_mode = le_test_mode,
 477         .config_hci_snoop_log = config_hci_snoop_log,
 478         .get_connection_state = get_connection_state,
 479         .set_os_callouts = set_os_callouts,
 480         .read_energy_info = read_energy_info,
 481         /* Tizen Specific API's*/
 482         .authorize_response = authorize_response,
 483         .set_authorization = set_authorization,
 484 #ifdef TIZEN_BT_HAL
 485         .get_service_connection_state = get_service_connection_state,
 486         .register_agent_osp_server = register_agent_osp_server,
 487         .unregister_agent_osp_server = unregister_agent_osp_server,
 488         .set_trusted_profile = set_trusted_profile,
 489         .get_trusted_profile = get_trusted_profile,
 490         .get_device_ida = get_device_ida,
 491         .enable_rssi_monitoring = enable_rssi_monitoring,
 492         .get_connected_link_rssi_strength = get_connected_link_rssi_strength,
 493         .enable_gap_auth_notifications = enable_gap_auth_notifications,
 494         .set_le_static_random_address = _bt_hal_set_le_static_random_address,
 495         .set_hal_adapter_request_state = set_hal_adapter_request_state,
 496         .set_hal_le_request_state = set_hal_le_request_state,
 497         .adapter_le_set_manufacturer_data = _bt_hal_adapter_le_set_manufacturer_data,
 498         .adapter_le_set_white_list = _bt_hal_adapter_le_set_white_list,
 499         .adapter_le_set_privacy = _bt_hal_adapter_le_set_privacy,
 500         .device_disconnect = dev_disconnect,
 501 #endif
 502 };
 503
 504 static const bt_interface_t *get_bluetooth_interface(void)
 505 {
 506         DBG("");
 507         return &bluetooth_if;
 508 }
 509
 510 static int close_bluetooth(struct hw_device_t *device)
 511 {
 512         DBG("");
 513         cleanup();
 514         free(device);
 515         return 0;
 516 }
 517
 518 static int open_bluetooth(const struct hw_module_t *module, char const *name,
 519                 struct hw_device_t **device)
 520 {
 521         bluetooth_device_t *dev = g_malloc0(sizeof(bluetooth_device_t));
 522
 523         DBG("");
 524
 525         memset(dev, 0, sizeof(bluetooth_device_t));
 526         dev->common.tag = HARDWARE_DEVICE_TAG;
 527         dev->common.version = 0;
 528         dev->common.module = (struct hw_module_t *) module;
 529         dev->common.close = close_bluetooth;
 530         dev->get_bluetooth_interface = get_bluetooth_interface;
 531
 532         *device = (struct hw_device_t *) dev;
 533
 534         return 0;
 535 }
 536
 537 static struct hw_module_methods_t bluetooth_module_methods = {
 538         .open = open_bluetooth,
 539 };
 540
 541 struct hw_module_t HAL_MODULE_INFO_SYM = {
 542         .tag = HARDWARE_MODULE_TAG,
 543         .version_major = 1,
 544         .version_minor = 0,
 545         .id = BT_HARDWARE_MODULE_ID,
 546         .name = "bluez",
 547         .author = "Intel Corporation",
 548         .methods = &bluetooth_module_methods
 549 };
 550
 551 static void __bt_hal_handle_adapter_state_changed(void *buf, uint16_t len)
 552 {
 553         struct hal_ev_adapter_state_changed *ev = buf;
 554
 555         DBG("Adapter State: %d", ev->state);
 556
 557         if (bt_hal_cbacks->adapter_state_changed_cb)
 558                 bt_hal_cbacks->adapter_state_changed_cb(ev->state);
 559 }
 560
 561 #ifdef TIZEN_BT_HAL
 562 static void __bt_hal_handle_le_state_changed(void *buf, uint16_t len)
 563 {
 564         struct hal_ev_le_state_changed *ev = buf;
 565
 566         DBG("Adapter State: %d", ev->state);
 567
 568         if (bt_hal_cbacks->le_state_changed_cb)
 569                 bt_hal_cbacks->le_state_changed_cb(ev->state);
 570 }
 571 #endif
 572
 573 static void __bt_adapter_props_to_hal(bt_property_t *send_props, struct hal_property *prop,
 574                 uint8_t num_props, uint16_t len)
 575 {
 576         void *buf = prop;
 577         uint8_t i;
 578
 579         for (i = 0; i < num_props; i++) {
 580                 if (sizeof(*prop) + prop->len > len) {
 581                         ERR("invalid adapter properties(%zu > %u), cant process further properties!!!",
 582                                         sizeof(*prop) + prop->len, len);
 583                         return;
 584                 }
 585
 586                 send_props[i].type = prop->type;
 587
 588                 switch (prop->type) {
 589                         /* TODO: Add Adapter Properties */
 590                 default:
 591                         send_props[i].len = prop->len;
 592                         send_props[i].val = prop->val;
 593                         break;
 594                 }
 595
 596                 DBG("prop[%d]: %s", i, btproperty2str(&send_props[i]));
 597
 598                 len -= sizeof(*prop) + prop->len;
 599                 buf += sizeof(*prop) + prop->len;
 600                 prop = buf;
 601         }
 602
 603         if (!len)
 604                 return;
 605 }
 606
 607 static void __bt_device_props_to_hal(bt_property_t *send_props,
 608                 struct hal_property *prop, uint8_t num_props,
 609                 uint16_t len)
 610 {
 611         void *buf = prop;
 612         uint8_t i;
 613
 614         for (i = 0; i < num_props; i++) {
 615                 if (sizeof(*prop) + prop->len > len) {
 616                         ERR("invalid device properties (%zu > %u), cant process further properties!!!",
 617                                         sizeof(*prop) + prop->len, len);
 618                         return;
 619                 }
 620
 621                 send_props[i].type = prop->type;
 622
 623                 switch (prop->type) {
 624                 case HAL_PROP_DEVICE_TYPE:
 625                 {
 626                         DBG("Device property:HAL_PROP_DEVICE_TYPE:");
 627                         enum_prop_to_hal(send_props[i], prop,
 628                                         bt_device_type_t);
 629                         break;
 630                 }
 631                 case HAL_PROP_DEVICE_VERSION_INFO:
 632                 {
 633                         DBG("Device property: HAL_PROP_DEVICE_VERSION_INFO");
 634                         static bt_remote_version_t e;
 635                         const struct hal_prop_device_info *p;
 636                         send_props[i].val = &e;
 637                         send_props[i].len = sizeof(e);
 638                                 p = (struct hal_prop_device_info *) prop->val;
 639                                 e.manufacturer = p->manufacturer;
 640                         e.sub_ver = p->sub_version;
 641                         e.version = p->version;
 642                         break;
 643                 }
 644                 case HAL_PROP_DEVICE_SERVICE_REC:
 645                 {
 646                         DBG("Device property: HAL_PROP_DEVICE_SERVICE_REC");
 647                         static bt_service_record_t e;
 648                         const struct hal_prop_device_service_rec *p;
 649                         send_props[i].val = &e;
 650                         send_props[i].len = sizeof(e);
 651                                 p = (struct hal_prop_device_service_rec *) prop->val;
 652                                         memset(&e, 0, sizeof(e));
 653                         memcpy(&e.channel, &p->channel, sizeof(e.channel));
 654                         memcpy(e.uuid.uu, p->uuid, sizeof(e.uuid.uu));
 655                         memcpy(e.name, p->name, p->name_len);
 656                         break;
 657                 }
 658                 default:
 659                         send_props[i].len = prop->len;
 660                         send_props[i].val = prop->val;
 661                         break;
 662                 }
 663
 664                 DBG("prop[%d]: %s, len: %d", i, btproperty2str(&send_props[i]), prop->len);
 665                 len -= sizeof(*prop) + prop->len;
 666                 buf += sizeof(*prop) + prop->len;
 667                 prop = buf;
 668
 669         }
 670
 671         if (!len) {
 672                 return;
 673         }
 674
 675         ERR("invalid device properties (%u bytes left), ", len);
 676 }
 677
 678 static void __bt_hal_handle_adapter_property_changed(void *buf, uint16_t len)
 679 {
 680         struct hal_ev_adapter_props_changed *ev = (struct hal_ev_adapter_props_changed *)buf;
 681         bt_property_t props[ev->num_props];
 682
 683         if (!bt_hal_cbacks->adapter_properties_cb)
 684                 return;
 685
 686         len -= sizeof(*ev);
 687         __bt_adapter_props_to_hal(props, ev->props, ev->num_props, len);
 688
 689         if (bt_hal_cbacks->adapter_properties_cb)
 690                 bt_hal_cbacks->adapter_properties_cb(ev->status, ev->num_props, props);
 691 }
 692
 693 static void __bt_hal_handle_adapter_discovery_state_changed(void *buf, uint16_t len)
 694 {
 695         struct hal_ev_discovery_state_changed *ev = (struct hal_ev_discovery_state_changed *)buf;
 696
 697         if (bt_hal_cbacks->discovery_state_changed_cb)
 698                 bt_hal_cbacks->discovery_state_changed_cb(ev->state);
 699 }
 700
 701 static void __bt_hal_handle_device_found_event(void *buf, uint16_t len)
 702 {
 703         struct hal_ev_device_found *ev =  (struct hal_ev_device_found *) buf;
 704         bt_property_t props[ev->num_props];
 705
 706         if (!bt_hal_cbacks->device_found_cb)
 707                 return;
 708
 709         len -= sizeof(*ev);
 710         __bt_device_props_to_hal(props, ev->props, ev->num_props, len);
 711
 712         bt_hal_cbacks->device_found_cb(ev->num_props, props);
 713 }
 714
 715 static void __bt_hal_handle_remote_device_properties_event(void *buf, uint16_t len)
 716 {
 717         struct hal_ev_remote_device_props *ev = (struct hal_ev_remote_device_props *) buf;
 718         bt_bdaddr_t bd_addr;
 719         bt_property_t props[ev->num_props];
 720
 721         if (!bt_hal_cbacks->remote_device_properties_cb)
 722                 return;
 723
 724         len -= sizeof(*ev);
 725         __bt_device_props_to_hal(props, ev->props, ev->num_props, len);
 726         memcpy(bd_addr.address, ev->bdaddr, 6);
 727         bt_hal_cbacks->remote_device_properties_cb(
 728                         ev->status, &bd_addr, ev->num_props, props);
 729 }
 730
 731 static void __bt_hal_handle_bond_state_changed_event(void *buf, uint16_t len)
 732 {
 733
 734         struct hal_ev_bond_state_changed *ev = (struct hal_ev_bond_state_changed *)buf;
 735         bt_bdaddr_t bd_addr;
 736
 737         memcpy(bd_addr.address, ev->bdaddr, 6);
 738
 739         DBG("Bonding  State changed Status [0x%x]", ev->status);
 740         DBG("Bonding  State [0x%x]", ev->state);
 741
 742         if (!bt_hal_cbacks->bond_state_changed_cb) {
 743                 ERR("HAL User bond_state_changed_callback is not set!!");
 744                 return;
 745         }
 746
 747         bt_hal_cbacks->bond_state_changed_cb(ev->status, &bd_addr, ev->state);
 748 }
 749
 750 static void __bt_hal_handle_device_acl_state_changed_event(void *buf, uint16_t len)
 751 {
 752         struct hal_ev_acl_state_changed *ev = (struct hal_ev_acl_state_changed*)buf;
 753         bt_bdaddr_t bd_addr;
 754
 755         memcpy(bd_addr.address, ev->bdaddr, 6);
 756         DBG("ACL status[0x%x], Link state[0x%x] XX:XX:XX:XX:%02X:%02X",
 757                         ev->status, ev->state, bd_addr.address[4], bd_addr.address[5]);
 758
 759         if (!bt_hal_cbacks->acl_state_changed_cb) {
 760                 ERR("HAL User acl_state_changed_cb is not set!!");
 761                 return;
 762         }
 763
 764         bt_hal_cbacks->acl_state_changed_cb(ev->status, &bd_addr, ev->state);
 765 }
 766
 767 static void __bt_hal_handle_device_le_conn_state_changed_event(void *buf, uint16_t len)
 768 {
 769         struct hal_ev_acl_state_changed *ev = (struct hal_ev_acl_state_changed*)buf;
 770         bt_bdaddr_t bd_addr;
 771
 772         memcpy(bd_addr.address, ev->bdaddr, 6);
 773
 774         DBG("ACL status[0x%x], Link state[0x%x] XX:XX:XX:XX:%02X:%02X",
 775                         ev->status, ev->state, bd_addr.address[4], bd_addr.address[5]);
 776
 777 #ifdef TIZEN_BT_HAL
 778         if (!bt_hal_cbacks->le_conn_state_changed_cb) {
 779                 ERR("HAL User le_conn_state_changed_cb is not set!!");
 780                 return;
 781         }
 782
 783         bt_hal_cbacks->le_conn_state_changed_cb(ev->status, &bd_addr, ev->state);
 784 #endif
 785 }
 786
 787 static void __bt_hal_handle_authorize_request_event(void *buf, uint16_t len)
 788 {
 789         struct hal_ev_authorize_request *ev = (struct hal_ev_authorize_request *)buf;
 790         bt_bdaddr_t bd_addr;
 791
 792         memcpy(bd_addr.address, ev->bdaddr, 6);
 793
 794         /* BD address*/
 795         DBG("[0x%x]", bd_addr.address[0]);
 796         DBG("[0x%x]", bd_addr.address[1]);
 797         DBG("[0x%x]", bd_addr.address[2]);
 798         DBG("[0x%x]", bd_addr.address[3]);
 799         DBG("[0x%x]", bd_addr.address[4]);
 800         DBG("[0x%x]", bd_addr.address[5]);
 801
 802         DBG("Service Id: [%u]", ev->service_id);
 803
 804         if (!bt_hal_cbacks->authorize_request_cb) {
 805                 ERR("HAL User authorize_request_cb is not set!!");
 806                 return;
 807         }
 808
 809         bt_hal_cbacks->authorize_request_cb(&bd_addr, ev->service_id);
 810 }
 811
 812 #ifdef TIZEN_BT_HAL
 813 static void __bt_hal_handle_socket_authorize_request_event(void *buf, uint16_t len)
 814 {
 815         struct hal_ev_sock_conn_auth *ev = buf;
 816         bt_bdaddr_t bd_addr;
 817         bt_uuid_t uuid;
 818         uint8_t name[249] = {0, };
 819         uint8_t path[249] = {0, };
 820         uint32_t fd;
 821
 822         memcpy(bd_addr.address, ev->bdaddr, 6);
 823         memcpy(uuid.uu, ev->uuid, 16);
 824         memcpy(name, ev->name, sizeof(name) - 1);
 825         memcpy(path, ev->path, sizeof(name) - 1);
 826         fd = ev->fd;
 827
 828         if (!bt_hal_cbacks->socket_authorize_request_cb) {
 829                 ERR("HAL User socket_authorize_request_cb is not set!!");
 830                 return;
 831         }
 832
 833         bt_hal_cbacks->socket_authorize_request_cb(&bd_addr, &uuid, name, path, fd);
 834 }
 835 #endif
 836
 837 static void __bt_hal_handle_ssp_request_event(void *buf, uint16_t len)
 838 {
 839         struct hal_ev_ssp_request *ev = (struct hal_ev_ssp_request *)buf;
 840         bt_bdaddr_t bd_addr;
 841         bt_bdname_t bd_name;
 842
 843         memcpy(bd_addr.address, ev->bdaddr, 6);
 844         memcpy(bd_name.name, ev->name, 248);
 845
 846         /* BD address*/
 847         DBG("[0x%x]", bd_addr.address[0]);
 848         DBG("[0x%x]", bd_addr.address[1]);
 849         DBG("[0x%x]", bd_addr.address[2]);
 850         DBG("[0x%x]", bd_addr.address[3]);
 851         DBG("[0x%x]", bd_addr.address[4]);
 852         DBG("[0x%x]", bd_addr.address[5]);
 853
 854         DBG("COD [%d]", ev->class_of_dev);
 855         DBG("pairing variant [%d]", ev->pairing_variant);
 856         DBG("passkey [%d]", ev->passkey);
 857
 858         if (!bt_hal_cbacks->ssp_request_cb) {
 859                 ERR("HAL User ssp_request_cb is not set!!");
 860                 return;
 861         }
 862
 863         bt_hal_cbacks->ssp_request_cb(&bd_addr, &bd_name,
 864                         ev->class_of_dev,
 865                         ev->pairing_variant, ev->passkey);
 866 }
 867
 868 static void __bt_hal_handle_pin_request_event(void *buf, uint16_t len)
 869 {
 870         struct hal_ev_pin_request *ev = (struct hal_ev_pin_request *)buf;
 871         bt_bdaddr_t bd_addr;
 872         bt_bdname_t bd_name;
 873
 874         memcpy(bd_addr.address, ev->bdaddr, 6);
 875         memcpy(bd_name.name, ev->name, 248);
 876
 877         /* BD address*/
 878         DBG("[0x%x]", bd_addr.address[0]);
 879         DBG("[0x%x]", bd_addr.address[1]);
 880         DBG("[0x%x]", bd_addr.address[2]);
 881         DBG("[0x%x]", bd_addr.address[3]);
 882         DBG("[0x%x]", bd_addr.address[4]);
 883         DBG("[0x%x]", bd_addr.address[5]);
 884
 885         DBG("COD [%u]", ev->class_of_dev);
 886
 887         if (!bt_hal_cbacks->pin_request_cb) {
 888                 ERR("HAL User pin_request_cb is not set!!");
 889                 return;
 890         }
 891
 892         bt_hal_cbacks->pin_request_cb(&bd_addr, &bd_name,
 893                         ev->class_of_dev);
 894 }
 895
 896 static void __bt_hal_handle_device_trust_state_changed_event(void *buf, uint16_t len)
 897 {
 898         struct hal_ev_device_trust_state_changed *ev = (struct hal_ev_device_trust_state_changed*)buf;
 899         bt_bdaddr_t bd_addr;
 900
 901         memcpy(bd_addr.address, ev->bdaddr, 6);
 902         /* BD address*/
 903         DBG("[0x%x]", bd_addr.address[0]);
 904         DBG("[0x%x]", bd_addr.address[1]);
 905         DBG("[0x%x]", bd_addr.address[2]);
 906         DBG("[0x%x]", bd_addr.address[3]);
 907         DBG("[0x%x]", bd_addr.address[4]);
 908         DBG("[0x%x]", bd_addr.address[5]);
 909
 910         DBG("Device Trusted?  [0x%x]", ev->trust);
 911
 912         if (!bt_hal_cbacks->device_trust_state_changed_cb) {
 913                 ERR("HAL User device_trust_state_changed_cb is not set!!");
 914                 return;
 915         }
 916
 917         bt_hal_cbacks->device_trust_state_changed_cb(&bd_addr, ev->trust);
 918 }
 919
 920 static void __bt_hal_handle_device_trusted_profiles_changed_event(void *buf, uint16_t len)
 921 {
 922         struct hal_ev_device_trusted_profiles_changed *ev = buf;
 923         bt_bdaddr_t bd_addr;
 924
 925 #ifdef TIZEN_BT_HAL
 926         memcpy(bd_addr.address, ev->bdaddr, 6);
 927         DBG("[0x%02X:%02X:%02X:%02X:%02X:%02X]",
 928                         bd_addr.address[0], bd_addr.address[1],
 929                         bd_addr.address[2], bd_addr.address[3],
 930                         bd_addr.address[4], bd_addr.address[5]);
 931
 932         if (!bt_hal_cbacks->device_trusted_profiles_changed_cb) {
 933                 ERR("device_trusted_profiles_changed_cb is NULL");
 934                 return;
 935         }
 936
 937         bt_hal_cbacks->device_trusted_profiles_changed_cb(&bd_addr, ev->trust_val);
 938 #endif
 939 }
 940
 941 static void __bt_handle_rssi_monitor_state_changed(void *buf, uint16_t len)
 942 {
 943         struct hal_ev_rssi_monitor_state_changed *ev = buf;
 944         bt_bdaddr_t bd_addr;
 945
 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->rssi_monitor_state_changed_cb)
 954                 bt_hal_cbacks->rssi_monitor_state_changed_cb(
 955                                 &bd_addr, ev->link_type, ev->state);
 956 #endif
 957 }
 958
 959 static void __bt_handle_rssi_alert_recieved(void *buf, uint16_t len)
 960 {
 961         struct hal_ev_rssi_alert_recieved *ev = buf;
 962         bt_bdaddr_t bd_addr;
 963
 964 #ifdef TIZEN_BT_HAL
 965         memcpy(bd_addr.address, ev->bdaddr, 6);
 966         DBG("[0x%02X:%02X:%02X:%02X:%02X:%02X]",
 967                         bd_addr.address[0], bd_addr.address[1],
 968                         bd_addr.address[2], bd_addr.address[3],
 969                         bd_addr.address[4], bd_addr.address[5]);
 970
 971         if (bt_hal_cbacks->rssi_alert_cb)
 972                 bt_hal_cbacks->rssi_alert_cb(
 973                                 &bd_addr, ev->link_type, ev->alert_type, ev->rssi);
 974 #endif
 975 }
 976
 977 static void __bt_handle_raw_rssi_recieved(void *buf, uint16_t len)
 978 {
 979         struct hal_ev_raw_rssi_recieved *ev = buf;
 980         bt_bdaddr_t bd_addr;
 981
 982 #ifdef TIZEN_BT_HAL
 983         memcpy(bd_addr.address, ev->bdaddr, 6);
 984         DBG("[0x%02X:%02X:%02X:%02X:%02X:%02X]",
 985                         bd_addr.address[0], bd_addr.address[1],
 986                         bd_addr.address[2], bd_addr.address[3],
 987                         bd_addr.address[4], bd_addr.address[5]);
 988
 989         if (bt_hal_cbacks->raw_rssi_received_cb)
 990                 bt_hal_cbacks->raw_rssi_received_cb(
 991                                 &bd_addr, ev->link_type, ev->rssi);
 992 #endif
 993 }
 994
 995 static void __bt_handle_dbfw_plus_info_recieved(void *buf, uint16_t len)
 996 {
 997         struct hal_ev_dbfw_plus_info_recieved *info = buf;
 998
 999 #ifdef TIZEN_BT_HAL
1000         if (bt_hal_cbacks->dbfw_plus_info_received_cb)
1001                 bt_hal_cbacks->dbfw_plus_info_received_cb(
1002                                 info->data, info->data_len, info->event_code);
1003 #endif
1004 }
1005
1006 static void __bt_handle_controller_error_recieved(void *buf, uint16_t len)
1007 {
1008         struct hal_ev_controller_error_recieved *info = buf;
1009         uint8_t error_code = info->code;
1010
1011 #ifdef TIZEN_BT_HAL
1012         if (bt_hal_cbacks->controller_error_received_cb)
1013                 bt_hal_cbacks->controller_error_received_cb(error_code);
1014 #endif
1015 }
1016
1017 static void __bt_hal_handle_stack_messages(int message, void *buf, uint16_t len)
1018 {
1019         switch (message) {
1020         case HAL_EV_ADAPTER_STATE_CHANGED:
1021                 DBG("Event: HAL_EV_ADAPTER_STATE_CHANGED");
1022                 __bt_hal_handle_adapter_state_changed(buf, len);
1023                 break;
1024         case HAL_EV_ADAPTER_PROPS_CHANGED:
1025                 DBG("Event: HAL_EV_ADAPTER_PROPS_CHANGED");
1026                 __bt_hal_handle_adapter_property_changed(buf, len);
1027                 break;
1028         case HAL_EV_DISCOVERY_STATE_CHANGED:
1029                 DBG("Event: HAL_EV_DISCOVERY_STATE_CHANGED");
1030                 __bt_hal_handle_adapter_discovery_state_changed(buf, len);
1031                 break;
1032         case HAL_EV_DEVICE_FOUND:
1033                 DBG("Event: HAL_EV_DEVICE_FOUND");
1034                 __bt_hal_handle_device_found_event(buf, len);
1035                 break;
1036         case HAL_EV_REMOTE_DEVICE_PROPS:
1037                 DBG("Event: HAL_EV_REMOTE_DEVICE_PROPS");
1038                 __bt_hal_handle_remote_device_properties_event(buf, len);
1039                 break;
1040         case HAL_EV_BOND_STATE_CHANGED:
1041                 DBG("Event: HAL_EV_BOND_STATE_CHANGED:");
1042                 __bt_hal_handle_bond_state_changed_event(buf, len);
1043                 break;
1044         case HAL_EV_ACL_STATE_CHANGED:
1045                 __bt_hal_handle_device_acl_state_changed_event(buf, len);
1046                 break;
1047         case HAL_EV_LE_CONN_STATE_CHANGED:
1048                 DBG("Event: HAL_LE_CONN_STATE_CONNECTED or Disconnected");
1049                 __bt_hal_handle_device_le_conn_state_changed_event(buf, len);
1050                 break;
1051         case HAL_EV_SSP_REQUEST:
1052                 DBG("Event: HAL_EV_SSP_REQUEST");
1053                 __bt_hal_handle_ssp_request_event(buf, len);
1054                 break;
1055         case HAL_EV_PIN_REQUEST:
1056                 DBG("Event: HAL_EV_PIN_REQUEST");
1057                 __bt_hal_handle_pin_request_event(buf, len);
1058                 break;
1059         case HAL_EV_AUTHORIZE_REQUEST:
1060                 DBG("Event: HAL_EV_AUTHORIZE_REQUEST");
1061                 __bt_hal_handle_authorize_request_event(buf, len);
1062                 break;
1063         case HAL_EV_DEVICE_TRUST_CHANGED:
1064                 DBG("Event: HAL_EV_DEVICE_TRUST_CHANGED");
1065                 __bt_hal_handle_device_trust_state_changed_event(buf, len);
1066                 break;
1067 #ifdef TIZEN_BT_HAL
1068         case HAL_EV_SOCK_AUTHORIZE_REQUEST:
1069                 DBG("Event: HAL_EV_AUTHORIZE_REQUEST");
1070                 __bt_hal_handle_socket_authorize_request_event(buf, len);
1071                 break;
1072         case HAL_EV_LE_STATE_CHANGED:
1073                 DBG("Event: HAL_EV_LE_STATE_CHANGED");
1074                 __bt_hal_handle_le_state_changed(buf, len);
1075                 break;
1076 #endif
1077         case HAL_EV_DEVICE_TRUSTED_PROFILES_CHANGED:
1078                 DBG("Event: HAL_EV_DEVICE_TRUST_CHANGED");
1079                 __bt_hal_handle_device_trusted_profiles_changed_event(buf, len);
1080                 break;
1081         case HAL_EV_RSSI_MONITOR_STATE_CHANGED:
1082                 DBG("Event: HAL_EV_RSSI_MONITOR_STATE_CHANGED");
1083                 __bt_handle_rssi_monitor_state_changed(buf, len);
1084                 break;
1085         case HAL_EV_RSSI_ALERT_RECIEVED:
1086                 DBG("Event: HAL_EV_RSSI_ALERT_RECIEVED");
1087                 __bt_handle_rssi_alert_recieved(buf, len);
1088                 break;
1089         case HAL_EV_RAW_RSSI_RECIEVED:
1090                 DBG("Event: HAL_EV_RAW_RSSI_RECIEVED");
1091                 __bt_handle_raw_rssi_recieved(buf, len);
1092                 break;
1093         case HAL_EV_DBFW_PLUS_INFO_RECIEVED:
1094                 DBG("Event: HAL_EV_DBFW_PLUS_INFO_RECIEVED");
1095                 __bt_handle_dbfw_plus_info_recieved(buf, len);
1096                 break;
1097         case HAL_EV_CONTROLLER_ERROR_RECIEVED:
1098                 DBG("Event: HAL_EV_CONTROLLER_ERROR_RECIEVED");
1099                 __bt_handle_controller_error_recieved(buf, len);
1100                 break;
1101         default:
1102                 DBG("Event Currently not handled!!");
1103                 break;
1104         }
1105 }