bt-oal/oal-adapter-mgr.c

   1 /*
   2  * Open Adaptation Layer (OAL)
   3  *
   4  * Copyright (c) 2014-2015 Samsung Electronics Co., Ltd.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <dlog.h>
  23 #include <string.h>
  24 #include <vconf.h>
  25 #include <sys/wait.h>
  26
  27 #include <bluetooth.h>
  28
  29 #include "oal-event.h"
  30 #include "oal-internal.h"
  31 #include "oal-manager.h"
  32 #include "oal-hardware.h"
  33 #include "oal-common.h"
  34 #include "oal-utils.h"
  35 #include "oal-gatt.h"
  36
  37 #define CHECK_MAX(max, x) (((max) > (x)) ? (x) : (max))
  38
  39 static const bt_interface_t * blued_api;
  40
  41 static bt_address_t local_address;
  42 static char local_name[BT_DEVICE_NAME_LENGTH_MAX + 1] = {'O', 'A', 'L', 0};
  43 static char local_version[BT_VERSION_STR_LEN_MAX + 1];
  44 static bt_scan_mode_t scan_mode = BT_SCAN_MODE_NONE;
  45 static int discoverable_timeout = 0;
  46
  47 /* Forward declarations */
  48 oal_status_t convert_to_oal_status(bt_status_t status);
  49 static gboolean retry_enable_adapter(gpointer data);
  50 #ifdef TIZEN_BT_HAL
  51 static gboolean retry_enable_le(gpointer data);
  52 #endif
  53 oal_status_t oal_mgr_init_internal(void);
  54
  55
  56 /* Callback registered with Stack */
  57 static void cb_adapter_state_change(bt_state_t status);
  58 static void cb_adapter_discovery_state_changed(bt_discovery_state_t state);
  59 static void cb_adapter_device_found(int num_properties, bt_property_t *properties);
  60 static void cb_adapter_properties(bt_status_t status,
  61                 int num_properties, bt_property_t *properties);
  62 static void cb_adapter_profile_connected_devices(uint8_t count, uint8_t bdaddr_list[][6]);
  63 extern void cb_device_properties(bt_status_t status, bt_bdaddr_t *bd_addr,
  64                 int num_properties, bt_property_t *properties);
  65 extern void cb_device_bond_state_changed(bt_status_t status, bt_bdaddr_t *bd_addr,
  66                 bt_bond_state_t state);
  67 extern void cb_device_acl_state_changed(bt_status_t status, bt_bdaddr_t *remote_bd_addr,
  68                 bt_acl_state_t state);
  69 extern void cb_device_pin_request(bt_bdaddr_t *bd_addr, bt_bdname_t *bdname, uint32_t device_class);
  70 extern void cb_device_ssp_request(bt_bdaddr_t *bd_addr, bt_bdname_t *bdname, uint32_t device_class,
  71                         bt_ssp_variant_t pairing_variant, uint32_t pass_key);
  72 extern void cb_device_authorize_request(bt_bdaddr_t *remote_bd_addr, bt_service_id_t service_d);
  73 extern void cb_device_trust_state_changed(bt_bdaddr_t *remote_bd_addr, bt_device_trust_state_t trusted);
  74 #ifdef TIZEN_BT_HAL
  75 extern void cb_socket_conn_authorize_request(bt_bdaddr_t *remote_bd_addr, bt_uuid_t *uuid, uint8_t *name, uint8_t *path, uint32_t fd);
  76 static void cb_ble_state_change(bt_state_t status);
  77 extern void cb_device_le_conn_state_changed(bt_status_t status, bt_bdaddr_t *bd_addr,
  78                 bt_le_conn_state_t state);
  79 extern void cb_device_trusted_profiles_changed(bt_bdaddr_t *bd_addr, uint32_t trust_val);
  80 extern void cb_rssi_monitor_state_changed(bt_bdaddr_t *bd_addr, int32_t link_type, uint8_t state);
  81 extern void cb_rssi_alert(bt_bdaddr_t *bd_addr, int32_t link_type, int32_t alert_type, int32_t rssi);
  82 extern void cb_raw_rssi_received(bt_bdaddr_t *bd_addr, int32_t link_type, int32_t rssi);
  83 extern void cb_dbfw_plus_info_received(unsigned char *data, uint32_t length, uint8_t event_code);
  84 extern void cb_controller_error_received(uint8_t error_code);
  85 #endif
  86
  87 static bt_callbacks_t callbacks = {
  88         .size = sizeof(callbacks),
  89         .adapter_state_changed_cb = cb_adapter_state_change,
  90         .adapter_properties_cb = cb_adapter_properties,
  91         .adapter_profile_connected_devices_cb = cb_adapter_profile_connected_devices,
  92         .remote_device_properties_cb = cb_device_properties,
  93         .device_found_cb = cb_adapter_device_found,
  94         .discovery_state_changed_cb = cb_adapter_discovery_state_changed,
  95         .pin_request_cb = cb_device_pin_request,
  96         .ssp_request_cb = cb_device_ssp_request,
  97         .bond_state_changed_cb = cb_device_bond_state_changed,
  98         .acl_state_changed_cb = cb_device_acl_state_changed,
  99         .thread_evt_cb = NULL,
 100         .dut_mode_recv_cb = NULL,
 101         .le_test_mode_cb = NULL,
 102         .energy_info_cb = NULL,
 103         .authorize_request_cb = cb_device_authorize_request,
 104         .device_trust_state_changed_cb = cb_device_trust_state_changed,
 105 #ifdef TIZEN_BT_HAL
 106         .socket_authorize_request_cb = cb_socket_conn_authorize_request,
 107         .le_state_changed_cb = cb_ble_state_change,
 108         .le_conn_state_changed_cb = cb_device_le_conn_state_changed,
 109         .device_trusted_profiles_changed_cb = cb_device_trusted_profiles_changed,
 110         .rssi_monitor_state_changed_cb = cb_rssi_monitor_state_changed,
 111         .rssi_alert_cb = cb_rssi_alert,
 112         .raw_rssi_received_cb = cb_raw_rssi_received,
 113         .dbfw_plus_info_received_cb = cb_dbfw_plus_info_received,
 114         .controller_error_received_cb = cb_controller_error_received,
 115 #endif
 116 };
 117
 118 oal_status_t adapter_mgr_init(const bt_interface_t * stack_if)
 119 {
 120         int ret;
 121         blued_api = stack_if;
 122
 123         ret = blued_api->init(&callbacks);
 124
 125         if (ret != BT_STATUS_SUCCESS) {
 126                 BT_ERR("Adapter callback registration failed: [%s]", status2string(ret));
 127                 blued_api->cleanup();
 128                 return convert_to_oal_status(ret);
 129         }
 130
 131         return OAL_STATUS_SUCCESS;
 132 }
 133
 134 const bt_interface_t* adapter_get_stack_interface(void)
 135 {
 136         return blued_api;
 137 }
 138
 139 void adapter_mgr_cleanup(void)
 140 {
 141         /* Nothing to clean yet , do not set blued_api NULL as it will be used to clean Bluedroid states */
 142         BT_DBG();
 143 }
 144
 145 #ifdef TIZEN_BT_HAL
 146 int oal_set_adapter_request_state(int enable)
 147 {
 148         CHECK_OAL_INITIALIZED();
 149
 150         return blued_api->set_hal_adapter_request_state(enable);
 151 }
 152
 153 int oal_set_le_request_state(int enable)
 154 {
 155         CHECK_OAL_INITIALIZED();
 156
 157         return blued_api->set_hal_le_request_state(enable);
 158 }
 159 #endif
 160
 161 oal_status_t adapter_enable(void)
 162 {
 163         int ret = BT_STATUS_SUCCESS;
 164
 165         API_TRACE();
 166
 167         if (blued_api == NULL) {
 168                 BT_INFO("Stack is initializing, so pending enable");
 169                 g_timeout_add(200, retry_enable_adapter, NULL);
 170                 return OAL_STATUS_PENDING;
 171         }
 172
 173         if (OAL_STATUS_SUCCESS != hw_is_module_ready()) {
 174                 g_timeout_add(200, retry_enable_adapter, NULL);
 175                 return OAL_STATUS_PENDING;
 176         }
 177
 178         ret = blued_api->enable();
 179
 180         if (ret != BT_STATUS_SUCCESS) {
 181                 BT_ERR("Enable failed: [%s]", status2string(ret));
 182                 return convert_to_oal_status(ret);
 183         }
 184
 185         return OAL_STATUS_SUCCESS;
 186 }
 187
 188 oal_status_t adapter_disable(void)
 189 {
 190         int ret;
 191
 192         API_TRACE();
 193
 194         CHECK_OAL_INITIALIZED();
 195
 196         ret = blued_api->disable();
 197
 198         if (ret != BT_STATUS_SUCCESS) {
 199                 BT_ERR("Disable failed: [%s]", status2string(ret));
 200                 return convert_to_oal_status(ret);
 201         }
 202         return OAL_STATUS_SUCCESS;
 203 }
 204
 205 oal_status_t le_enable(void)
 206 {
 207         int ret = BT_STATUS_SUCCESS;
 208
 209         API_TRACE();
 210         CHECK_OAL_INITIALIZED();
 211
 212 #ifdef TIZEN_BT_HAL
 213         if (OAL_STATUS_SUCCESS != hw_is_module_ready()) {
 214                 g_timeout_add(200, retry_enable_le, NULL);
 215                 return OAL_STATUS_PENDING;
 216         }
 217
 218         ret = blued_api->le_enable();
 219
 220         if (ret != BT_STATUS_SUCCESS) {
 221                 BT_ERR("Enable failed: [%s]", status2string(ret));
 222                 return convert_to_oal_status(ret);
 223         }
 224 #else
 225         BT_INFO("Not Supported");
 226         ret = OAL_STATUS_NOT_SUPPORT;
 227 #endif
 228
 229         return ret;
 230 }
 231
 232 oal_status_t le_disable(void)
 233 {
 234         int ret;
 235
 236         API_TRACE();
 237
 238         CHECK_OAL_INITIALIZED();
 239
 240 #ifdef TIZEN_BT_HAL
 241         ret = blued_api->le_disable();
 242
 243         if (ret != BT_STATUS_SUCCESS) {
 244                 BT_ERR("Disable failed: [%s]", status2string(ret));
 245                 return convert_to_oal_status(ret);
 246         }
 247 #else
 248         BT_INFO("Not Supported");
 249         ret = OAL_STATUS_NOT_SUPPORT;
 250 #endif
 251         return ret;
 252 }
 253
 254 oal_status_t le_init(void)
 255 {
 256         int ret = BT_STATUS_SUCCESS;
 257         API_TRACE();
 258         CHECK_OAL_INITIALIZED();
 259 #ifdef TIZEN_BT_HAL
 260         if (OAL_STATUS_SUCCESS != hw_is_module_ready()) {
 261                 g_timeout_add(200, retry_enable_le, NULL);
 262                 return OAL_STATUS_PENDING;
 263         }
 264         ret = blued_api->le_init();
 265         if (ret != BT_STATUS_SUCCESS) {
 266                 BT_ERR("Enable failed: [%s]", status2string(ret));
 267                 return convert_to_oal_status(ret);
 268         }
 269 #else
 270         BT_INFO("Not Supported");
 271         ret = OAL_STATUS_NOT_SUPPORT;
 272 #endif
 273         return ret;
 274 }
 275 oal_status_t le_deinit(void)
 276 {
 277         int ret = BT_STATUS_SUCCESS;
 278         API_TRACE();
 279         CHECK_OAL_INITIALIZED();
 280 #ifdef TIZEN_BT_HAL
 281         if (OAL_STATUS_SUCCESS != hw_is_module_ready()) {
 282                 g_timeout_add(200, retry_enable_le, NULL);
 283                 return OAL_STATUS_PENDING;
 284         }
 285         blued_api->le_deinit();
 286 #else
 287         BT_INFO("Not Supported");
 288         ret = OAL_STATUS_NOT_SUPPORT;
 289 #endif
 290         return ret;
 291 }
 292 oal_status_t is_advertising(void)
 293 {
 294         int ret = BT_STATUS_SUCCESS;
 295         API_TRACE();
 296         CHECK_OAL_INITIALIZED();
 297 #ifdef TIZEN_BT_HAL
 298         if (OAL_STATUS_SUCCESS != hw_is_module_ready()) {
 299                 g_timeout_add(200, retry_enable_le, NULL);
 300                 return OAL_STATUS_PENDING;
 301         }
 302         int r = blued_api->is_advertising();
 303         if (r == TRUE)
 304                 ret = BT_STATUS_SUCCESS;
 305         else
 306                 ret = BT_STATUS_FAIL;
 307 #else
 308         BT_INFO("Not Supported");
 309         ret = OAL_STATUS_NOT_SUPPORT;
 310 #endif
 311         return ret;
 312 }
 313 oal_status_t adapter_start_custom_inquiry(discovery_type_t disc_type)
 314 {
 315         int ret;
 316
 317         API_TRACE();
 318
 319         CHECK_OAL_INITIALIZED();
 320         BT_INFO("Custom Discovery Type [0x%x]", disc_type);
 321
 322 #ifdef TIZEN_BT_HAL
 323         ret = blued_api->start_custom_discovery(disc_type);
 324         if (ret != BT_STATUS_SUCCESS) {
 325                 BT_ERR("start_custom_discovery failed: [%s]", status2string(ret));
 326                 return convert_to_oal_status(ret);
 327         }
 328 #else
 329         BT_INFO("Not Supported");
 330         ret = OAL_STATUS_NOT_SUPPORT;
 331 #endif
 332         return ret;
 333 }
 334
 335 oal_status_t adapter_get_powered_status(gboolean *status)
 336 {
 337         int ret;
 338         unsigned char powered = 0;
 339
 340         API_TRACE();
 341
 342         CHECK_OAL_INITIALIZED();
 343
 344         OAL_CHECK_PARAMETER(status, return);
 345         BT_INFO("Get Adapter Powered status");
 346
 347 #ifdef TIZEN_BT_HAL
 348         ret = blued_api->get_adapter_powered_status(&powered);
 349         if (ret != BT_STATUS_SUCCESS) {
 350                 BT_ERR("adapter_get_powered_status failed: [%s]", status2string(ret));
 351                 *status = FALSE;
 352                 return convert_to_oal_status(ret);
 353         }
 354         if (powered == 1)
 355                 *status = TRUE;
 356         else
 357                 *status = FALSE;
 358 #else
 359         BT_INFO("Not Supported");
 360         ret = OAL_STATUS_NOT_SUPPORT;
 361 #endif
 362         return ret;
 363 }
 364
 365 oal_status_t adapter_get_energy_info(uint32_t *tx_time, uint32_t *rx_time,
 366                                         uint32_t *idle_time, uint32_t *energy_used)
 367 {
 368         int ret;
 369
 370         CHECK_OAL_INITIALIZED();
 371
 372         OAL_CHECK_PARAMETER(tx_time, return);
 373         OAL_CHECK_PARAMETER(rx_time, return);
 374         OAL_CHECK_PARAMETER(idle_time, return);
 375         OAL_CHECK_PARAMETER(energy_used, return);
 376
 377         BT_DBG("Get Adapter Energy Info");
 378
 379 #ifdef TIZEN_BT_HAL
 380         ret = blued_api->get_adapter_energy_info(tx_time, rx_time, idle_time, energy_used);
 381         if (ret != BT_STATUS_SUCCESS) {
 382                 BT_ERR("get_adapter_energy_info failed: [%s]", status2string(ret));
 383                 return convert_to_oal_status(ret);
 384         }
 385 #else
 386         BT_INFO("Not Supported");
 387         ret = OAL_STATUS_NOT_SUPPORT;
 388 #endif
 389         return ret;
 390 }
 391
 392 oal_status_t adapter_reset(void)
 393 {
 394         int ret;
 395
 396         API_TRACE();
 397
 398         CHECK_OAL_INITIALIZED();
 399         BT_INFO("Adapter Reset");
 400
 401 #ifdef TIZEN_BT_HAL
 402         ret = blued_api->reset();
 403         if (ret != BT_STATUS_SUCCESS) {
 404                 BT_ERR("Adapter Reset failed: [%s]", status2string(ret));
 405                 return convert_to_oal_status(ret);
 406         }
 407 #else
 408         BT_INFO("Not Supported");
 409         ret = OAL_STATUS_NOT_SUPPORT;
 410 #endif
 411         return ret;
 412 }
 413
 414 oal_status_t adapter_recover(void)
 415 {
 416         int result;
 417
 418         API_TRACE();
 419
 420         CHECK_OAL_INITIALIZED();
 421         BT_INFO("Adapter Recover");
 422
 423         result = blued_api->recover();
 424         if (result != BT_STATUS_SUCCESS) {
 425                 BT_ERR("Adapter Recover Failed: [%s]", status2string(result));
 426                 return convert_to_oal_status(result);
 427         }
 428
 429         return result;
 430 }
 431
 432 oal_status_t adapter_start_inquiry(unsigned short duration)
 433 {
 434         int ret;
 435
 436         API_TRACE();
 437
 438         CHECK_OAL_INITIALIZED();
 439
 440         ret = blued_api->start_discovery();
 441         if (ret != BT_STATUS_SUCCESS) {
 442                 BT_ERR("start_discovery failed: [%s]", status2string(ret));
 443                 return convert_to_oal_status(ret);
 444         }
 445
 446         return OAL_STATUS_SUCCESS;
 447 }
 448
 449 oal_status_t adapter_stop_inquiry(void)
 450 {
 451         int ret;
 452
 453         API_TRACE();
 454
 455         CHECK_OAL_INITIALIZED();
 456
 457         ret = blued_api->cancel_discovery();
 458         if (ret != BT_STATUS_SUCCESS) {
 459                 BT_ERR("cancel_discovery failed: [%s]", status2string(ret));
 460                 return convert_to_oal_status(ret);
 461         }
 462
 463         return OAL_STATUS_SUCCESS;
 464 }
 465
 466 /* Callbacks from Stack */
 467 static void cb_adapter_state_change(bt_state_t status)
 468 {
 469         BT_DBG("+");
 470         oal_event_t event;
 471
 472         event = (BT_STATE_ON == status) ? OAL_EVENT_ADAPTER_ENABLED : OAL_EVENT_ADAPTER_DISABLED;
 473
 474         send_event(event, NULL, 0);
 475 }
 476
 477 #ifdef TIZEN_BT_HAL
 478 /* Callbacks from Stack */
 479 static void cb_ble_state_change(bt_state_t status)
 480 {
 481         BT_DBG("+");
 482         oal_event_t event;
 483
 484         event = (BT_STATE_ON == status) ? OAL_EVENT_BLE_ENABLED : OAL_EVENT_BLE_DISABLED;
 485
 486         send_event(event, NULL, 0);
 487 }
 488 #endif
 489
 490 static gboolean retry_enable_adapter(gpointer data)
 491 {
 492         adapter_enable();
 493         return FALSE;
 494 }
 495
 496 #ifdef TIZEN_BT_HAL
 497 static gboolean retry_enable_le(gpointer data)
 498 {
 499         le_enable();
 500         return FALSE;
 501 }
 502 #endif
 503 oal_status_t adapter_get_properties(void)
 504 {
 505         int ret;
 506
 507         API_TRACE();
 508         CHECK_OAL_INITIALIZED();
 509
 510         ret = blued_api->get_adapter_properties();
 511         if (ret != BT_STATUS_SUCCESS) {
 512                 BT_ERR("get_adapter_properties failed: [%s]", status2string(ret));
 513                 return convert_to_oal_status(ret);
 514         }
 515
 516         return OAL_STATUS_SUCCESS;
 517 }
 518
 519 oal_status_t adapter_get_address(void)
 520 {
 521         int ret;
 522
 523         API_TRACE();
 524         CHECK_OAL_INITIALIZED();
 525
 526         ret = blued_api->get_adapter_property(BT_PROPERTY_BDADDR);
 527         if (ret != BT_STATUS_SUCCESS) {
 528                 BT_ERR("get_adapter_property failed: [%s]", status2string(ret));
 529                 return convert_to_oal_status(ret);
 530         }
 531
 532         return OAL_STATUS_SUCCESS;
 533 }
 534
 535 oal_status_t adapter_get_version(void)
 536 {
 537         int ret;
 538
 539         API_TRACE();
 540         CHECK_OAL_INITIALIZED();
 541
 542         ret = blued_api->get_adapter_property(BT_PROPERTY_VERSION);
 543         if (ret != BT_STATUS_SUCCESS) {
 544                 BT_ERR("get_adapter_property failed: [%s]", status2string(ret));
 545                 return convert_to_oal_status(ret);
 546         }
 547
 548         return OAL_STATUS_SUCCESS;
 549 }
 550
 551 oal_status_t adapter_get_name(void)
 552 {
 553         int ret;
 554
 555         CHECK_OAL_INITIALIZED();
 556
 557         API_TRACE();
 558
 559         ret = blued_api->get_adapter_property(BT_PROPERTY_BDNAME);
 560         if (ret != BT_STATUS_SUCCESS) {
 561                 BT_ERR("get_adapter_property failed: [%s]", status2string(ret));
 562                 return convert_to_oal_status(ret);
 563         }
 564
 565         return OAL_STATUS_SUCCESS;
 566 }
 567
 568 oal_status_t adapter_get_connectable(void)
 569 {
 570         int ret;
 571
 572         CHECK_OAL_INITIALIZED();
 573
 574         API_TRACE();
 575
 576         ret = blued_api->get_adapter_property(BT_PROPERTY_ADAPTER_SCAN_MODE);
 577         if (ret != BT_STATUS_SUCCESS) {
 578                 BT_ERR("get_adapter_property failed: [%s]", status2string(ret));
 579                 return convert_to_oal_status(ret);
 580         }
 581
 582         return OAL_STATUS_SUCCESS;
 583 }
 584
 585 oal_status_t adapter_set_name(char * name)
 586 {
 587         int ret;
 588         bt_property_t prop;
 589
 590         CHECK_OAL_INITIALIZED();
 591
 592         OAL_CHECK_PARAMETER(name, return);
 593         API_TRACE("Name: %s", name);
 594
 595         prop.type = BT_PROPERTY_BDNAME;
 596         prop.len = strlen(name);
 597         prop.val = name;
 598
 599         ret = blued_api->set_adapter_property(&prop);
 600         if (ret != BT_STATUS_SUCCESS) {
 601                 BT_ERR("set_adapter_property: [%s]", status2string(ret));
 602                 ret = OAL_STATUS_INTERNAL_ERROR;
 603         } else
 604                 ret = OAL_STATUS_SUCCESS;
 605
 606         return ret;
 607 }
 608
 609 oal_status_t adapter_is_discoverable(int *p_discoverable)
 610 {
 611         OAL_CHECK_PARAMETER(p_discoverable, return);
 612
 613         *p_discoverable = (scan_mode == BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE);
 614
 615         API_TRACE("%d", *p_discoverable);
 616
 617         return OAL_STATUS_SUCCESS;
 618 }
 619
 620 oal_status_t adapter_is_connectable(int *p_connectable)
 621 {
 622         OAL_CHECK_PARAMETER(p_connectable, return);
 623
 624         *p_connectable = (scan_mode == BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE)
 625                 || (scan_mode == BT_SCAN_MODE_CONNECTABLE);
 626
 627         API_TRACE("%d", *p_connectable);
 628
 629         return OAL_STATUS_SUCCESS;
 630 }
 631
 632 oal_status_t adapter_get_discoverable_timeout(int *p_timeout)
 633 {
 634         API_TRACE("%d", discoverable_timeout);
 635
 636         *p_timeout = discoverable_timeout;
 637
 638         return OAL_STATUS_SUCCESS;
 639 }
 640
 641 oal_status_t adapter_get_service_uuids(void)
 642 {
 643         int ret;
 644
 645         CHECK_OAL_INITIALIZED();
 646
 647         API_TRACE();
 648         ret = blued_api->get_adapter_property(BT_PROPERTY_UUIDS);
 649         if (ret != BT_STATUS_SUCCESS) {
 650                 BT_ERR("get_adapter_property failed: [%s]", status2string(ret));
 651                 return convert_to_oal_status(ret);
 652         }
 653         return OAL_STATUS_SUCCESS;
 654 }
 655
 656 oal_status_t adapter_get_bonded_devices(void)
 657 {
 658         int ret;
 659
 660         CHECK_OAL_INITIALIZED();
 661
 662         API_TRACE();
 663
 664         ret = blued_api->get_adapter_property(BT_PROPERTY_ADAPTER_BONDED_DEVICES);
 665         if (ret != BT_STATUS_SUCCESS) {
 666                 BT_ERR("get_adapter_property failed: [%s]", status2string(ret));
 667                 return convert_to_oal_status(ret);
 668         }
 669
 670         return OAL_STATUS_SUCCESS;
 671 }
 672
 673 oal_status_t adapter_get_profile_connected_devices(const char *profile_uuid)
 674 {
 675         int ret;
 676
 677         CHECK_OAL_INITIALIZED();
 678
 679         API_TRACE();
 680
 681         ret = blued_api->get_profile_connected_devices(profile_uuid);
 682         if (ret != BT_STATUS_SUCCESS) {
 683                 BT_ERR("get_profile_connected_devices failed: [%s]", status2string(ret));
 684                 return convert_to_oal_status(ret);
 685         }
 686
 687         return OAL_STATUS_SUCCESS;
 688 }
 689
 690 static oal_status_t set_scan_mode(bt_scan_mode_t mode)
 691 {
 692         bt_property_t prop;
 693         int res;
 694
 695         BT_DBG("+");
 696
 697         CHECK_OAL_INITIALIZED();
 698
 699         prop.type = BT_PROPERTY_ADAPTER_SCAN_MODE;
 700         prop.len = sizeof(bt_scan_mode_t);
 701         prop.val = &mode;
 702         res = blued_api->set_adapter_property(&prop);
 703         if (res != BT_STATUS_SUCCESS) {
 704                 BT_ERR("set scan mode failed [%s]", status2string(res));
 705                 return convert_to_oal_status(res);
 706         }
 707
 708         BT_DBG("-");
 709         return OAL_STATUS_SUCCESS;
 710 }
 711
 712 oal_status_t adapter_set_connectable(int connectable)
 713 {
 714         bt_scan_mode_t mode;
 715
 716         API_TRACE("%d", connectable);
 717
 718         CHECK_OAL_INITIALIZED();
 719
 720         mode = connectable ? BT_SCAN_MODE_CONNECTABLE : BT_SCAN_MODE_NONE;
 721
 722         return set_scan_mode(mode);
 723 }
 724
 725 oal_status_t adapter_set_discoverable(void)
 726 {
 727         CHECK_OAL_INITIALIZED();
 728         API_TRACE();
 729
 730         return set_scan_mode(BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE);
 731 }
 732
 733 oal_status_t adapter_set_discoverable_timeout(int timeout)
 734 {
 735         bt_property_t prop;
 736         int res;
 737         uint32_t prop_val = timeout;
 738
 739         CHECK_OAL_INITIALIZED();
 740         API_TRACE("%d", timeout);
 741
 742         prop.type = BT_PROPERTY_ADAPTER_DISCOVERY_TIMEOUT;
 743         prop.len = sizeof(prop_val);
 744         prop.val = &prop_val;
 745         res = blued_api->set_adapter_property(&prop);
 746         if (res != BT_STATUS_SUCCESS) {
 747                 BT_ERR("set_adapter_property failed [%s]", status2string(res));
 748                 return convert_to_oal_status(res);
 749         }
 750         return OAL_STATUS_SUCCESS;
 751 }
 752
 753 oal_status_t adapter_ble_set_filter_policy(int filter_policy)
 754 {
 755         int ret = OAL_STATUS_SUCCESS;
 756
 757         CHECK_OAL_INITIALIZED();
 758         API_TRACE();
 759
 760         BT_DBG("Filter policy applied is [%d]", filter_policy);
 761
 762         ret = gatts_set_filter_policy(filter_policy);
 763
 764         if (ret != OAL_STATUS_SUCCESS) {
 765                 BT_ERR("gatts_set_filter_policy: [%d]", ret);
 766                 return ret;
 767         }
 768
 769         return OAL_STATUS_SUCCESS;
 770 }
 771
 772 oal_status_t adapter_ble_multi_adv_update(int Ins_id, int min_intv, int max_intv,
 773                         int adv_type, int chnl_map, int tx_power, int timeout_s)
 774 {
 775         int res;
 776         CHECK_OAL_INITIALIZED();
 777         API_TRACE();
 778
 779         res = gatts_multi_adv_update(Ins_id, min_intv, max_intv,
 780                         adv_type, chnl_map, tx_power, timeout_s);
 781         if (res != OAL_STATUS_SUCCESS) {
 782                 BT_ERR("gatts_multi_adv_update: [%d]", res);
 783                 return res;
 784         }
 785         return OAL_STATUS_SUCCESS;
 786 }
 787
 788 oal_status_t adapter_ble_multi_adv_set_inst_data(int instance_id,
 789                         oal_ble_multi_adv_param_setup_t * adv_param_setup)
 790 {
 791         int res;
 792         CHECK_OAL_INITIALIZED();
 793         OAL_CHECK_PARAMETER(adv_param_setup, return);
 794
 795         API_TRACE();
 796
 797         res = gatts_multi_adv_set_inst_data(instance_id, adv_param_setup);
 798         if (res != OAL_STATUS_SUCCESS) {
 799                 BT_ERR("failed: [%d]", res);
 800                 return res;
 801         }
 802         return OAL_STATUS_SUCCESS;
 803 }
 804
 805 oal_status_t adapter_ble_multi_adv_enable(int instance_id)
 806 {
 807         int res;
 808         CHECK_OAL_INITIALIZED();
 809         API_TRACE();
 810
 811         res = gatts_multi_adv_enable(instance_id);
 812         if (res != OAL_STATUS_SUCCESS) {
 813                 BT_ERR("failed: [%d]", res);
 814                 return res;
 815         }
 816
 817         return OAL_STATUS_SUCCESS;
 818 }
 819
 820 oal_status_t adapter_ble_multi_adv_disable(int instance_id)
 821 {
 822         int res;
 823         CHECK_OAL_INITIALIZED();
 824         API_TRACE();
 825
 826         res = gatts_multi_adv_disable(instance_id);
 827         if (res != OAL_STATUS_SUCCESS) {
 828                 BT_ERR("failed: [%d]", res);
 829                 return res;
 830         }
 831
 832         return OAL_STATUS_SUCCESS;
 833 }
 834
 835 oal_status_t adapter_set_le_static_random_address(int enable)
 836 {
 837         int ret;
 838
 839         CHECK_OAL_INITIALIZED();
 840         API_TRACE("%d", enable);
 841
 842 #ifdef TIZEN_BT_HAL
 843         ret = blued_api->set_le_static_random_address((enable ? 1 : 0));
 844         if (ret != BT_STATUS_SUCCESS)
 845                 BT_ERR("Static address set failed: [%s]", status2string(ret));
 846         ret = convert_to_oal_status(ret);
 847 #else
 848         BT_INFO("Not Supported");
 849         ret = OAL_STATUS_NOT_SUPPORT;
 850 #endif
 851
 852         return ret;
 853 }
 854
 855 oal_status_t adapter_set_manufacturer_data(oal_manufacturer_data_t *m_data)
 856 {
 857         int ret;
 858
 859         CHECK_OAL_INITIALIZED();
 860         API_TRACE();
 861
 862         OAL_CHECK_PARAMETER(m_data, return);
 863         ret = blued_api->adapter_le_set_manufacturer_data((bt_manufacturer_data_t*)m_data);
 864         if (ret != BT_STATUS_SUCCESS)
 865                 BT_ERR("Setting manufacturer data Failed: [%s]",status2string(ret));
 866
 867         ret = convert_to_oal_status(ret);
 868         return ret;
 869 }
 870
 871 oal_status_t adapter_set_white_list(bt_address_t *device_address, int address_type, bool is_add)
 872 {
 873         int ret;
 874         bdstr_t bdstr;
 875
 876         CHECK_OAL_INITIALIZED();
 877
 878         BT_INFO("BT remote device Address: %s", bdt_bd2str(device_address, &bdstr) + 12);
 879
 880         ret = blued_api->adapter_le_set_white_list((bt_bdaddr_t*)device_address, address_type, is_add);
 881         if (ret != BT_STATUS_SUCCESS) {
 882                 if(is_add)
 883                         BT_ERR("Add to White List Failed: [%s]",status2string(ret));
 884                 else
 885                         BT_ERR("Remove from White List Failed: [%s]",status2string(ret));
 886         }
 887         ret = convert_to_oal_status(ret);
 888         return ret;
 889 }
 890
 891 oal_status_t adapter_ble_set_privacy(int set_privacy)
 892 {
 893         int res;
 894
 895         CHECK_OAL_INITIALIZED();
 896         API_TRACE();
 897
 898         res = blued_api->adapter_le_set_privacy(set_privacy);
 899         if (res != BT_STATUS_SUCCESS)
 900                 BT_ERR("Setting LE Privacy Failed: [%s]", status2string(res));
 901         res = convert_to_oal_status(res);
 902
 903         return res;
 904 }
 905
 906 static void cb_adapter_properties(bt_status_t status,
 907                 int num_properties,
 908                 bt_property_t *properties)
 909 {
 910         int i;
 911
 912         BT_DBG("status: %d, count: %d", status, num_properties);
 913
 914         print_bt_properties(num_properties, properties);
 915
 916         if (status != BT_STATUS_SUCCESS) {
 917                 if (num_properties == 1) {
 918                         BT_ERR("Adapter Prop failed: status: [%s], count: %d, prop: %d",
 919                                 status2string(status), num_properties, properties[num_properties-1].type);
 920                 } else {
 921                         BT_ERR("Adapter Prop failed: status: [%s], count: %d", status2string(status), num_properties);
 922                 }
 923                 return;
 924         }
 925
 926         for (i = 0; i < num_properties; i++) {
 927                 BT_DBG("prop type %d, len %d", properties[i].type, properties[i].len);
 928                 switch (properties[i].type) {
 929                 case BT_PROPERTY_VERSION: {
 930                         g_strlcpy(local_version, properties[i].val, BT_VERSION_STR_LEN_MAX);
 931                         local_version[properties[i].len] = '\0';
 932
 933                         BT_DBG("Version: %s", local_version);
 934                         /* Send event to application */
 935                         if (num_properties == 1) {
 936                                 char *adapter_ver = g_strdup(local_version);
 937
 938                                 /* Application has requested this property SET/GET hence send EVENT */
 939                                 send_event(OAL_EVENT_ADAPTER_PROPERTY_VERSION, adapter_ver, strlen(adapter_ver));
 940                         }
 941                         break;
 942                 }
 943                 case BT_PROPERTY_BDNAME: {
 944                         g_strlcpy(local_name, properties[i].val, BT_DEVICE_NAME_LENGTH_MAX);
 945                         local_name[properties[i].len] = '\0';
 946
 947                         BT_DBG("Name: %s", local_name);
 948                         /* Send event to application */
 949                         if (num_properties == 1) {
 950                                 char * adap_name = g_strdup(local_name);
 951
 952                                 /* Application has requested this property SET/GET hence send EVENT */
 953                                 send_event(OAL_EVENT_ADAPTER_PROPERTY_NAME, adap_name, strlen(adap_name)+1);
 954                         }
 955                         break;
 956                 }
 957                 case BT_PROPERTY_BDADDR: {
 958                         bt_bdaddr_t * addr;
 959
 960                         addr =  properties[i].val;
 961                         memcpy(local_address.addr, addr->address, 6);
 962                         if (num_properties == 1) {
 963                                 /* Application has requested this property SET/GET hence send EVENT */
 964                                 send_event(OAL_EVENT_ADAPTER_PROPERTY_ADDRESS,
 965                                                 g_memdup(&local_address, sizeof(local_address)),
 966                                                 sizeof(local_address));
 967                         }
 968                         break;
 969                 }
 970                 case BT_PROPERTY_UUIDS: {
 971                         int num_uuid;
 972
 973                         num_uuid = properties[i].len/sizeof(bt_uuid_t);
 974
 975                         BT_DBG("num_uuid: %d", num_uuid);
 976
 977                         /* Send event to application */
 978                         if (num_properties == 1) {
 979                                 event_adapter_services_t *uuids_event;
 980
 981                                 uuids_event = g_malloc(sizeof(event_adapter_services_t) + properties[i].len);
 982                                 memcpy(uuids_event->service_list, properties[i].val, properties[i].len);
 983                                 uuids_event->num = num_uuid;
 984
 985                                 /* Application has requested this property SET/GET hence send EVENT */
 986                                 send_event(OAL_EVENT_ADAPTER_PROPERTY_SERVICES,
 987                                                 uuids_event, (sizeof(event_adapter_services_t) + num_uuid * sizeof(bt_uuid_t)));
 988                         }
 989                         break;
 990                 }
 991                 case BT_PROPERTY_ADAPTER_SCAN_MODE: {
 992                         bt_scan_mode_t cur_mode = *((bt_scan_mode_t *)properties[i].val);
 993
 994                         BT_INFO("Scan mode (%d)", cur_mode);
 995
 996                         scan_mode = cur_mode;
 997
 998                         /* Send event to application */
 999                         if (num_properties == 1) {
1000                                 oal_event_t event = OAL_EVENT_ADAPTER_MODE_NON_CONNECTABLE;
1001
1002                                 if (BT_SCAN_MODE_CONNECTABLE == cur_mode)
1003                                         event = OAL_EVENT_ADAPTER_MODE_CONNECTABLE;
1004                                 else if (BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE == cur_mode)
1005                                         event = OAL_EVENT_ADAPTER_MODE_DISCOVERABLE;
1006
1007                                 /* Application has requested this property SET/GET hence send EVENT */
1008                                 send_event(event, NULL, 0);
1009                         }
1010                         break;
1011                 }
1012                 case BT_PROPERTY_ADAPTER_DISCOVERY_TIMEOUT: {
1013                         int timeout;
1014
1015                         timeout = *((uint32_t*)properties[i].val);
1016
1017                         BT_INFO("Discoverability timeout: %d", timeout);
1018                         discoverable_timeout = timeout;
1019
1020                         send_event(OAL_EVENT_ADAPTER_MODE_DISCOVERABLE_TIMEOUT,
1021                                         g_memdup(properties[i].val, sizeof(uint32_t)),
1022                                         sizeof(uint32_t));
1023                         break;
1024                 }
1025                 case BT_PROPERTY_ADAPTER_BONDED_DEVICES: {
1026                         int j;
1027                         int num_bonded;
1028                         bt_bdaddr_t *bonded_addr_list;
1029                         event_device_list_t *event_data;
1030
1031                         num_bonded = properties[i].len/sizeof(bt_bdaddr_t);
1032                         BT_DBG("num_bonded %d", num_bonded);
1033
1034                         if (num_properties > 1) /* No explicit req for this prop, ignore */
1035                                 break;
1036
1037                         bonded_addr_list = properties[i].val;
1038                         event_data = g_malloc(sizeof(event_device_list_t) + num_bonded*sizeof(bt_address_t));
1039                         event_data->num = num_bonded;
1040
1041                         for (j = 0; j < num_bonded; j++)
1042                                 memcpy(event_data->devices[j].addr, bonded_addr_list[j].address, 6);
1043
1044                         send_event(OAL_EVENT_ADAPTER_BONDED_DEVICE_LIST,
1045                                         event_data, (sizeof(event_device_list_t) + num_bonded * sizeof(bt_bdaddr_t)));
1046                         break;
1047                 }
1048                 case BT_PROPERTY_A2DP_ROLE: {
1049                         unsigned int a2dp_role;
1050
1051                         a2dp_role = *((uint32_t*)properties[i].val);
1052
1053                         BT_INFO("A2DP role: %u", a2dp_role);
1054
1055                         send_event(OAL_EVENT_ADAPTER_PROPERTY_A2DP_ROLE,
1056                                         g_memdup(properties[i].val, sizeof(uint32_t)),
1057                                         sizeof(uint32_t));
1058                         break;
1059                 }
1060                 case BT_PROPERTY_LOCAL_LE_FEATURES: {
1061                         event_adapter_le_features_t *le_features;
1062
1063                         le_features = g_malloc(sizeof(event_adapter_le_features_t));
1064
1065                         le_features->max_adv_instance = ((bt_local_le_features_t *)(properties[i].val))->max_adv_instance;
1066                         le_features->rpa_offloading = ((bt_local_le_features_t *)(properties[i].val))->rpa_offload_supported;
1067                         le_features->max_adv_filter = ((bt_local_le_features_t *)(properties[i].val))->max_adv_filter_supported;
1068                         le_features->le_2m_phy_support = ((bt_local_le_features_t *)(properties[i].val))->le_2m_phy_supported;
1069                         le_features->le_coded_phy_support = ((bt_local_le_features_t *)(properties[i].val))->le_2m_phy_supported;
1070
1071                         BT_INFO("LE 2M PHY Support (%d)", le_features->le_2m_phy_support);
1072                         BT_INFO("LE CODED PHY Support (%d)", le_features->le_coded_phy_support);
1073
1074                         send_event(OAL_EVENT_BLE_LOCAL_FEATURES,
1075                                         le_features,
1076                                         sizeof(event_adapter_le_features_t));
1077                         break;
1078                 }
1079                 case BT_PROPERTY_ADAPTER_LE_DISCOVERY_STARTED: {
1080                         BT_INFO("LE Discovery started");
1081                         send_event(OAL_EVENT_BLE_DISCOVERY_STARTED, NULL, 0);
1082                         break;
1083                 }
1084                 case BT_PROPERTY_ADAPTER_LE_DISCOVERY_STOPPED: {
1085                         BT_INFO("LE Discovery stopped");
1086                         send_event(OAL_EVENT_BLE_DISCOVERY_STOPPED, NULL, 0);
1087                         break;
1088                 }
1089                 default:
1090                          BT_WARN("Unhandled property: %d", properties[i].type);
1091                          break;
1092                 }
1093         }
1094 }
1095
1096 static void cb_adapter_profile_connected_devices(uint8_t count, uint8_t addr_list[][6])
1097 {
1098         event_adapter_profile_connected_devices *event_data;
1099         int i;
1100
1101         event_data = g_malloc0(sizeof(event_adapter_profile_connected_devices));
1102         event_data->count = count;
1103         for (i = 0; i < count; i++) {
1104                 memcpy(event_data->addr_list[i].addr, addr_list[i], BT_ADDRESS_BYTES_NUM);
1105         }
1106         send_event(OAL_EVENT_ADAPTER_PROFILE_CONNECTED_DEVICES, event_data, sizeof(event_adapter_profile_connected_devices));
1107 }
1108
1109 static void cb_adapter_discovery_state_changed(bt_discovery_state_t state)
1110 {
1111         oal_event_t event;
1112
1113         event = (BT_DISCOVERY_STARTED == state) ? OAL_EVENT_ADAPTER_INQUIRY_STARTED : OAL_EVENT_ADAPTER_INQUIRY_FINISHED;
1114
1115         BT_DBG("%d", state);
1116         send_event(event, NULL, 0);
1117 }
1118
1119 static void cb_adapter_device_found(int num_properties, bt_property_t *properties)
1120 {
1121         remote_device_t dev_info;
1122         ble_adv_data_t adv_info;
1123         oal_event_t event;
1124         gpointer event_data;
1125         gsize size = 0;
1126         BT_DBG("+");
1127
1128         if (num_properties == 0) {
1129                 BT_ERR("Unexpected, properties count is zero!!");
1130                 return;
1131         }
1132
1133         memset(&dev_info, 0x00, sizeof(remote_device_t));
1134         memset(&adv_info, 0x00, sizeof(ble_adv_data_t));
1135
1136         print_bt_properties(num_properties, properties);
1137         parse_device_properties(num_properties, properties, &dev_info, &adv_info);
1138
1139         BT_INFO("number of properties= [%d] ", num_properties);
1140
1141         if (dev_info.type != DEV_TYPE_BREDR) {
1142                 /* BLE Single or DUAL mode found, so it should have Adv data */
1143                 event_ble_dev_found_t * ble_dev_event = g_new0(event_ble_dev_found_t, 1);
1144
1145                 ble_dev_event->adv_len = adv_info.len;
1146
1147                 if (adv_info.len > 0 && adv_info.adv_data) {
1148                         memcpy(ble_dev_event->adv_data, adv_info.adv_data, adv_info.len);
1149                         ble_dev_event->adv_len = adv_info.len;
1150                 } else
1151                         ble_dev_event->adv_len = 0;
1152
1153                 ble_dev_event->device_info = dev_info;
1154
1155                 event_data = ble_dev_event;
1156                 size = sizeof(event_ble_dev_found_t);
1157                 event = OAL_EVENT_ADAPTER_INQUIRY_RESULT_BLE;
1158         } else {
1159                 /* BREDR device, so No Adv data */
1160                 event_dev_found_t * dev_event = g_new0(event_dev_found_t, 1);
1161
1162                 memcpy(dev_event, &dev_info, sizeof(remote_device_t));
1163                 event_data = dev_event;
1164                 size = sizeof(remote_device_t);
1165                 event = OAL_EVENT_ADAPTER_INQUIRY_RESULT_BREDR_ONLY;
1166         }
1167
1168         send_event(event, event_data, size);
1169
1170         BT_DBG("-");
1171 }
1172
1173 void cb_controller_error_received(uint8_t error_code)
1174 {
1175         uint8_t *event_data;
1176
1177         event_data = g_new0(uint8_t, 1);
1178         *event_data = error_code;
1179
1180         send_event(OAL_EVENT_CONTROLLER_ERROR_RECEIVED,
1181                 (gpointer)event_data, sizeof(uint8_t));
1182 }