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_get_local_irk(uint8_t *local_irk)
 450 {
 451         int ret = OAL_STATUS_SUCCESS;
 452         CHECK_OAL_INITIALIZED();
 453
 454         ret = blued_api->get_local_irk(local_irk);
 455         if (ret != BT_STATUS_SUCCESS) {
 456                 BT_ERR("get property local irk failed, status: %s", status2string(ret));
 457                 return convert_to_oal_status(ret);
 458         }
 459
 460         return OAL_STATUS_SUCCESS;
 461 }
 462
 463 oal_status_t adapter_stop_inquiry(void)
 464 {
 465         int ret;
 466
 467         API_TRACE();
 468
 469         CHECK_OAL_INITIALIZED();
 470
 471         ret = blued_api->cancel_discovery();
 472         if (ret != BT_STATUS_SUCCESS) {
 473                 BT_ERR("cancel_discovery failed: [%s]", status2string(ret));
 474                 return convert_to_oal_status(ret);
 475         }
 476
 477         return OAL_STATUS_SUCCESS;
 478 }
 479
 480 /* Callbacks from Stack */
 481 static void cb_adapter_state_change(bt_state_t status)
 482 {
 483         BT_DBG("+");
 484         oal_event_t event;
 485
 486         event = (BT_STATE_ON == status) ? OAL_EVENT_ADAPTER_ENABLED : OAL_EVENT_ADAPTER_DISABLED;
 487
 488         send_event(event, NULL, 0);
 489 }
 490
 491 #ifdef TIZEN_BT_HAL
 492 /* Callbacks from Stack */
 493 static void cb_ble_state_change(bt_state_t status)
 494 {
 495         BT_DBG("+");
 496         oal_event_t event;
 497
 498         event = (BT_STATE_ON == status) ? OAL_EVENT_BLE_ENABLED : OAL_EVENT_BLE_DISABLED;
 499
 500         send_event(event, NULL, 0);
 501 }
 502 #endif
 503
 504 static gboolean retry_enable_adapter(gpointer data)
 505 {
 506         adapter_enable();
 507         return FALSE;
 508 }
 509
 510 #ifdef TIZEN_BT_HAL
 511 static gboolean retry_enable_le(gpointer data)
 512 {
 513         le_enable();
 514         return FALSE;
 515 }
 516 #endif
 517 oal_status_t adapter_get_properties(void)
 518 {
 519         int ret;
 520
 521         API_TRACE();
 522         CHECK_OAL_INITIALIZED();
 523
 524         ret = blued_api->get_adapter_properties();
 525         if (ret != BT_STATUS_SUCCESS) {
 526                 BT_ERR("get_adapter_properties failed: [%s]", status2string(ret));
 527                 return convert_to_oal_status(ret);
 528         }
 529
 530         return OAL_STATUS_SUCCESS;
 531 }
 532
 533 oal_status_t adapter_get_address(void)
 534 {
 535         int ret;
 536
 537         API_TRACE();
 538         CHECK_OAL_INITIALIZED();
 539
 540         ret = blued_api->get_adapter_property(BT_PROPERTY_BDADDR);
 541         if (ret != BT_STATUS_SUCCESS) {
 542                 BT_ERR("get_adapter_property failed: [%s]", status2string(ret));
 543                 return convert_to_oal_status(ret);
 544         }
 545
 546         return OAL_STATUS_SUCCESS;
 547 }
 548
 549 oal_status_t adapter_get_version(void)
 550 {
 551         int ret;
 552
 553         API_TRACE();
 554         CHECK_OAL_INITIALIZED();
 555
 556         ret = blued_api->get_adapter_property(BT_PROPERTY_VERSION);
 557         if (ret != BT_STATUS_SUCCESS) {
 558                 BT_ERR("get_adapter_property failed: [%s]", status2string(ret));
 559                 return convert_to_oal_status(ret);
 560         }
 561
 562         return OAL_STATUS_SUCCESS;
 563 }
 564
 565 oal_status_t adapter_get_name(void)
 566 {
 567         int ret;
 568
 569         CHECK_OAL_INITIALIZED();
 570
 571         API_TRACE();
 572
 573         ret = blued_api->get_adapter_property(BT_PROPERTY_BDNAME);
 574         if (ret != BT_STATUS_SUCCESS) {
 575                 BT_ERR("get_adapter_property failed: [%s]", status2string(ret));
 576                 return convert_to_oal_status(ret);
 577         }
 578
 579         return OAL_STATUS_SUCCESS;
 580 }
 581
 582 oal_status_t adapter_get_connectable(void)
 583 {
 584         int ret;
 585
 586         CHECK_OAL_INITIALIZED();
 587
 588         API_TRACE();
 589
 590         ret = blued_api->get_adapter_property(BT_PROPERTY_ADAPTER_SCAN_MODE);
 591         if (ret != BT_STATUS_SUCCESS) {
 592                 BT_ERR("get_adapter_property failed: [%s]", status2string(ret));
 593                 return convert_to_oal_status(ret);
 594         }
 595
 596         return OAL_STATUS_SUCCESS;
 597 }
 598
 599 oal_status_t adapter_set_name(char * name)
 600 {
 601         int ret;
 602         bt_property_t prop;
 603
 604         CHECK_OAL_INITIALIZED();
 605
 606         OAL_CHECK_PARAMETER(name, return);
 607         API_TRACE("Name: %s", name);
 608
 609         prop.type = BT_PROPERTY_BDNAME;
 610         prop.len = strlen(name);
 611         prop.val = name;
 612
 613         ret = blued_api->set_adapter_property(&prop);
 614         if (ret != BT_STATUS_SUCCESS) {
 615                 BT_ERR("set_adapter_property: [%s]", status2string(ret));
 616                 ret = OAL_STATUS_INTERNAL_ERROR;
 617         } else
 618                 ret = OAL_STATUS_SUCCESS;
 619
 620         return ret;
 621 }
 622
 623 oal_status_t adapter_is_discoverable(int *p_discoverable)
 624 {
 625         OAL_CHECK_PARAMETER(p_discoverable, return);
 626
 627         *p_discoverable = (scan_mode == BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE);
 628
 629         API_TRACE("%d", *p_discoverable);
 630
 631         return OAL_STATUS_SUCCESS;
 632 }
 633
 634 oal_status_t adapter_is_connectable(int *p_connectable)
 635 {
 636         OAL_CHECK_PARAMETER(p_connectable, return);
 637
 638         *p_connectable = (scan_mode == BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE)
 639                 || (scan_mode == BT_SCAN_MODE_CONNECTABLE);
 640
 641         API_TRACE("%d", *p_connectable);
 642
 643         return OAL_STATUS_SUCCESS;
 644 }
 645
 646 oal_status_t adapter_get_discoverable_timeout(int *p_timeout)
 647 {
 648         API_TRACE("%d", discoverable_timeout);
 649
 650         *p_timeout = discoverable_timeout;
 651
 652         return OAL_STATUS_SUCCESS;
 653 }
 654
 655 oal_status_t adapter_get_service_uuids(void)
 656 {
 657         int ret;
 658
 659         CHECK_OAL_INITIALIZED();
 660
 661         API_TRACE();
 662         ret = blued_api->get_adapter_property(BT_PROPERTY_UUIDS);
 663         if (ret != BT_STATUS_SUCCESS) {
 664                 BT_ERR("get_adapter_property failed: [%s]", status2string(ret));
 665                 return convert_to_oal_status(ret);
 666         }
 667         return OAL_STATUS_SUCCESS;
 668 }
 669
 670 oal_status_t adapter_get_bonded_devices(void)
 671 {
 672         int ret;
 673
 674         CHECK_OAL_INITIALIZED();
 675
 676         API_TRACE();
 677
 678         ret = blued_api->get_adapter_property(BT_PROPERTY_ADAPTER_BONDED_DEVICES);
 679         if (ret != BT_STATUS_SUCCESS) {
 680                 BT_ERR("get_adapter_property failed: [%s]", status2string(ret));
 681                 return convert_to_oal_status(ret);
 682         }
 683
 684         return OAL_STATUS_SUCCESS;
 685 }
 686
 687 oal_status_t adapter_get_profile_connected_devices(const char *profile_uuid)
 688 {
 689         int ret;
 690
 691         CHECK_OAL_INITIALIZED();
 692
 693         API_TRACE();
 694
 695         ret = blued_api->get_profile_connected_devices(profile_uuid);
 696         if (ret != BT_STATUS_SUCCESS) {
 697                 BT_ERR("get_profile_connected_devices failed: [%s]", status2string(ret));
 698                 return convert_to_oal_status(ret);
 699         }
 700
 701         return OAL_STATUS_SUCCESS;
 702 }
 703
 704 static oal_status_t set_scan_mode(bt_scan_mode_t mode)
 705 {
 706         bt_property_t prop;
 707         int res;
 708
 709         BT_DBG("+");
 710
 711         CHECK_OAL_INITIALIZED();
 712
 713         prop.type = BT_PROPERTY_ADAPTER_SCAN_MODE;
 714         prop.len = sizeof(bt_scan_mode_t);
 715         prop.val = &mode;
 716         res = blued_api->set_adapter_property(&prop);
 717         if (res != BT_STATUS_SUCCESS) {
 718                 BT_ERR("set scan mode failed [%s]", status2string(res));
 719                 return convert_to_oal_status(res);
 720         }
 721
 722         BT_DBG("-");
 723         return OAL_STATUS_SUCCESS;
 724 }
 725
 726 oal_status_t adapter_set_connectable(int connectable)
 727 {
 728         bt_scan_mode_t mode;
 729
 730         API_TRACE("%d", connectable);
 731
 732         CHECK_OAL_INITIALIZED();
 733
 734         mode = connectable ? BT_SCAN_MODE_CONNECTABLE : BT_SCAN_MODE_NONE;
 735
 736         return set_scan_mode(mode);
 737 }
 738
 739 oal_status_t adapter_set_discoverable(void)
 740 {
 741         CHECK_OAL_INITIALIZED();
 742         API_TRACE();
 743
 744         return set_scan_mode(BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE);
 745 }
 746
 747 oal_status_t adapter_set_discoverable_timeout(int timeout)
 748 {
 749         bt_property_t prop;
 750         int res;
 751         uint32_t prop_val = timeout;
 752
 753         CHECK_OAL_INITIALIZED();
 754         API_TRACE("%d", timeout);
 755
 756         prop.type = BT_PROPERTY_ADAPTER_DISCOVERY_TIMEOUT;
 757         prop.len = sizeof(prop_val);
 758         prop.val = &prop_val;
 759         res = blued_api->set_adapter_property(&prop);
 760         if (res != BT_STATUS_SUCCESS) {
 761                 BT_ERR("set_adapter_property failed [%s]", status2string(res));
 762                 return convert_to_oal_status(res);
 763         }
 764         return OAL_STATUS_SUCCESS;
 765 }
 766
 767 oal_status_t adapter_ble_set_filter_policy(int filter_policy)
 768 {
 769         int ret = OAL_STATUS_SUCCESS;
 770
 771         CHECK_OAL_INITIALIZED();
 772         API_TRACE();
 773
 774         BT_DBG("Filter policy applied is [%d]", filter_policy);
 775
 776         ret = gatts_set_filter_policy(filter_policy);
 777
 778         if (ret != OAL_STATUS_SUCCESS) {
 779                 BT_ERR("gatts_set_filter_policy: [%d]", ret);
 780                 return ret;
 781         }
 782
 783         return OAL_STATUS_SUCCESS;
 784 }
 785
 786 oal_status_t adapter_ble_multi_adv_update(int Ins_id, int min_intv, int max_intv,
 787                         int adv_type, int chnl_map, int tx_power, int timeout_s,
 788                         bool is_legacy, int primary_phy, int secondary_phy)
 789 {
 790         int res;
 791         CHECK_OAL_INITIALIZED();
 792         API_TRACE();
 793
 794         res = gatts_multi_adv_update(Ins_id, min_intv, max_intv,
 795                         adv_type, chnl_map, tx_power, timeout_s,
 796                         is_legacy, primary_phy, secondary_phy);
 797         if (res != OAL_STATUS_SUCCESS) {
 798                 BT_ERR("gatts_multi_adv_update: [%d]", res);
 799                 return res;
 800         }
 801         return OAL_STATUS_SUCCESS;
 802 }
 803
 804 oal_status_t adapter_ble_multi_adv_set_inst_data(int instance_id,
 805                         oal_ble_multi_adv_param_setup_t * adv_param_setup)
 806 {
 807         int res;
 808         CHECK_OAL_INITIALIZED();
 809         OAL_CHECK_PARAMETER(adv_param_setup, return);
 810
 811         API_TRACE();
 812
 813         res = gatts_multi_adv_set_inst_data(instance_id, adv_param_setup);
 814         if (res != OAL_STATUS_SUCCESS) {
 815                 BT_ERR("failed: [%d]", res);
 816                 return res;
 817         }
 818         return OAL_STATUS_SUCCESS;
 819 }
 820
 821 oal_status_t adapter_ble_multi_adv_enable(int instance_id)
 822 {
 823         int res;
 824         CHECK_OAL_INITIALIZED();
 825         API_TRACE();
 826
 827         res = gatts_multi_adv_enable(instance_id);
 828         if (res != OAL_STATUS_SUCCESS) {
 829                 BT_ERR("failed: [%d]", res);
 830                 return res;
 831         }
 832
 833         return OAL_STATUS_SUCCESS;
 834 }
 835
 836 oal_status_t adapter_ble_multi_adv_disable(int instance_id)
 837 {
 838         int res;
 839         CHECK_OAL_INITIALIZED();
 840         API_TRACE();
 841
 842         res = gatts_multi_adv_disable(instance_id);
 843         if (res != OAL_STATUS_SUCCESS) {
 844                 BT_ERR("failed: [%d]", res);
 845                 return res;
 846         }
 847
 848         return OAL_STATUS_SUCCESS;
 849 }
 850
 851 oal_status_t adapter_set_le_static_random_address(int enable)
 852 {
 853         int ret;
 854
 855         CHECK_OAL_INITIALIZED();
 856         API_TRACE("%d", enable);
 857
 858 #ifdef TIZEN_BT_HAL
 859         ret = blued_api->set_le_static_random_address((enable ? 1 : 0));
 860         if (ret != BT_STATUS_SUCCESS)
 861                 BT_ERR("Static address set failed: [%s]", status2string(ret));
 862         ret = convert_to_oal_status(ret);
 863 #else
 864         BT_INFO("Not Supported");
 865         ret = OAL_STATUS_NOT_SUPPORT;
 866 #endif
 867
 868         return ret;
 869 }
 870
 871 oal_status_t adapter_set_manufacturer_data(oal_manufacturer_data_t *m_data)
 872 {
 873         int ret;
 874
 875         CHECK_OAL_INITIALIZED();
 876         API_TRACE();
 877
 878         OAL_CHECK_PARAMETER(m_data, return);
 879         ret = blued_api->adapter_le_set_manufacturer_data((bt_manufacturer_data_t*)m_data);
 880         if (ret != BT_STATUS_SUCCESS)
 881                 BT_ERR("Setting manufacturer data Failed: [%s]",status2string(ret));
 882
 883         ret = convert_to_oal_status(ret);
 884         return ret;
 885 }
 886
 887 oal_status_t adapter_set_allow_list(bt_address_t *device_address, int address_type, bool is_add)
 888 {
 889         int ret;
 890         bdstr_t bdstr;
 891
 892         CHECK_OAL_INITIALIZED();
 893
 894         BT_INFO("BT remote device Address: %s", bdt_bd2str(device_address, &bdstr) + 12);
 895
 896         ret = blued_api->adapter_le_set_allow_list((bt_bdaddr_t*)device_address, address_type, is_add);
 897         if (ret != BT_STATUS_SUCCESS) {
 898                 if(is_add)
 899                         BT_ERR("Add to allow List Failed: [%s]",status2string(ret));
 900                 else
 901                         BT_ERR("Remove from allow List Failed: [%s]",status2string(ret));
 902         }
 903         ret = convert_to_oal_status(ret);
 904         return ret;
 905 }
 906
 907 oal_status_t adapter_ble_set_privacy(int set_privacy)
 908 {
 909         int res;
 910
 911         CHECK_OAL_INITIALIZED();
 912         API_TRACE();
 913
 914         res = blued_api->adapter_le_set_privacy(set_privacy);
 915         if (res != BT_STATUS_SUCCESS)
 916                 BT_ERR("Setting LE Privacy Failed: [%s]", status2string(res));
 917         res = convert_to_oal_status(res);
 918
 919         return res;
 920 }
 921
 922 static void cb_adapter_properties(bt_status_t status,
 923                 int num_properties,
 924                 bt_property_t *properties)
 925 {
 926         int i;
 927
 928         BT_DBG("status: %d, count: %d", status, num_properties);
 929
 930         print_bt_properties(num_properties, properties);
 931
 932         if (status != BT_STATUS_SUCCESS) {
 933                 if (num_properties == 1) {
 934                         BT_ERR("Adapter Prop failed: status: [%s], count: %d, prop: %d",
 935                                 status2string(status), num_properties, properties[num_properties-1].type);
 936                 } else {
 937                         BT_ERR("Adapter Prop failed: status: [%s], count: %d", status2string(status), num_properties);
 938                 }
 939                 return;
 940         }
 941
 942         for (i = 0; i < num_properties; i++) {
 943                 BT_DBG("prop type %d, len %d", properties[i].type, properties[i].len);
 944                 switch (properties[i].type) {
 945                 case BT_PROPERTY_VERSION: {
 946                         g_strlcpy(local_version, properties[i].val, BT_VERSION_STR_LEN_MAX);
 947                         local_version[properties[i].len] = '\0';
 948
 949                         BT_DBG("Version: %s", local_version);
 950                         /* Send event to application */
 951                         if (num_properties == 1) {
 952                                 char *adapter_ver = g_strdup(local_version);
 953
 954                                 /* Application has requested this property SET/GET hence send EVENT */
 955                                 send_event(OAL_EVENT_ADAPTER_PROPERTY_VERSION, adapter_ver, strlen(adapter_ver));
 956                         }
 957                         break;
 958                 }
 959                 case BT_PROPERTY_BDNAME: {
 960                         g_strlcpy(local_name, properties[i].val, BT_DEVICE_NAME_LENGTH_MAX);
 961                         local_name[properties[i].len] = '\0';
 962
 963                         BT_DBG("Name: %s", local_name);
 964                         /* Send event to application */
 965                         if (num_properties == 1) {
 966                                 char * adap_name = g_strdup(local_name);
 967
 968                                 /* Application has requested this property SET/GET hence send EVENT */
 969                                 send_event(OAL_EVENT_ADAPTER_PROPERTY_NAME, adap_name, strlen(adap_name)+1);
 970                         }
 971                         break;
 972                 }
 973                 case BT_PROPERTY_BDADDR: {
 974                         bt_bdaddr_t * addr;
 975
 976                         addr =  properties[i].val;
 977                         memcpy(local_address.addr, addr->address, 6);
 978                         if (num_properties == 1) {
 979                                 /* Application has requested this property SET/GET hence send EVENT */
 980                                 send_event(OAL_EVENT_ADAPTER_PROPERTY_ADDRESS,
 981                                                 g_memdup2(&local_address, sizeof(local_address)),
 982                                                 sizeof(local_address));
 983                         }
 984                         break;
 985                 }
 986                 case BT_PROPERTY_UUIDS: {
 987                         int num_uuid;
 988
 989                         num_uuid = properties[i].len/sizeof(bt_uuid_t);
 990
 991                         BT_DBG("num_uuid: %d", num_uuid);
 992
 993                         /* Send event to application */
 994                         if (num_properties == 1) {
 995                                 event_adapter_services_t *uuids_event;
 996
 997                                 uuids_event = g_malloc(sizeof(event_adapter_services_t) + properties[i].len);
 998                                 memcpy(uuids_event->service_list, properties[i].val, properties[i].len);
 999                                 uuids_event->num = num_uuid;
1000
1001                                 /* Application has requested this property SET/GET hence send EVENT */
1002                                 send_event(OAL_EVENT_ADAPTER_PROPERTY_SERVICES,
1003                                                 uuids_event, (sizeof(event_adapter_services_t) + num_uuid * sizeof(bt_uuid_t)));
1004                         }
1005                         break;
1006                 }
1007                 case BT_PROPERTY_ADAPTER_SCAN_MODE: {
1008                         bt_scan_mode_t cur_mode = *((bt_scan_mode_t *)properties[i].val);
1009
1010                         BT_INFO("Scan mode (%d)", cur_mode);
1011
1012                         scan_mode = cur_mode;
1013
1014                         /* Send event to application */
1015                         if (num_properties == 1) {
1016                                 oal_event_t event = OAL_EVENT_ADAPTER_MODE_NON_CONNECTABLE;
1017
1018                                 if (BT_SCAN_MODE_CONNECTABLE == cur_mode)
1019                                         event = OAL_EVENT_ADAPTER_MODE_CONNECTABLE;
1020                                 else if (BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE == cur_mode)
1021                                         event = OAL_EVENT_ADAPTER_MODE_DISCOVERABLE;
1022
1023                                 /* Application has requested this property SET/GET hence send EVENT */
1024                                 send_event(event, NULL, 0);
1025                         }
1026                         break;
1027                 }
1028                 case BT_PROPERTY_ADAPTER_DISCOVERY_TIMEOUT: {
1029                         int timeout;
1030
1031                         timeout = *((uint32_t*)properties[i].val);
1032
1033                         BT_INFO("Discoverability timeout: %d", timeout);
1034                         discoverable_timeout = timeout;
1035
1036                         send_event(OAL_EVENT_ADAPTER_MODE_DISCOVERABLE_TIMEOUT,
1037                                         g_memdup2(properties[i].val, sizeof(uint32_t)),
1038                                         sizeof(uint32_t));
1039                         break;
1040                 }
1041                 case BT_PROPERTY_ADAPTER_BONDED_DEVICES: {
1042                         int j;
1043                         int num_bonded;
1044                         bt_bdaddr_t *bonded_addr_list;
1045                         event_device_list_t *event_data;
1046
1047                         num_bonded = properties[i].len/sizeof(bt_bdaddr_t);
1048                         BT_DBG("num_bonded %d", num_bonded);
1049
1050                         if (num_properties > 1) /* No explicit req for this prop, ignore */
1051                                 break;
1052
1053                         bonded_addr_list = properties[i].val;
1054                         event_data = g_malloc(sizeof(event_device_list_t) + num_bonded*sizeof(bt_address_t));
1055                         event_data->num = num_bonded;
1056
1057                         for (j = 0; j < num_bonded; j++)
1058                                 memcpy(event_data->devices[j].addr, bonded_addr_list[j].address, 6);
1059
1060                         send_event(OAL_EVENT_ADAPTER_BONDED_DEVICE_LIST,
1061                                         event_data, (sizeof(event_device_list_t) + num_bonded * sizeof(bt_bdaddr_t)));
1062                         break;
1063                 }
1064                 case BT_PROPERTY_A2DP_ROLE: {
1065                         unsigned int a2dp_role;
1066
1067                         a2dp_role = *((uint32_t*)properties[i].val);
1068
1069                         BT_INFO("A2DP role: %u", a2dp_role);
1070
1071                         send_event(OAL_EVENT_ADAPTER_PROPERTY_A2DP_ROLE,
1072                                         g_memdup2(properties[i].val, sizeof(uint32_t)),
1073                                         sizeof(uint32_t));
1074                         break;
1075                 }
1076                 case BT_PROPERTY_LOCAL_LE_FEATURES: {
1077                         event_adapter_le_features_t *le_features;
1078
1079                         le_features = g_malloc(sizeof(event_adapter_le_features_t));
1080
1081                         le_features->max_adv_instance = ((bt_local_le_features_t *)(properties[i].val))->max_adv_instance;
1082                         le_features->rpa_offloading = ((bt_local_le_features_t *)(properties[i].val))->rpa_offload_supported;
1083                         le_features->max_adv_filter = ((bt_local_le_features_t *)(properties[i].val))->max_adv_filter_supported;
1084                         le_features->le_2m_phy_support = ((bt_local_le_features_t *)(properties[i].val))->le_2m_phy_supported;
1085                         le_features->le_coded_phy_support = ((bt_local_le_features_t *)(properties[i].val))->le_2m_phy_supported;
1086                         le_features->le_extended_advertising_support =
1087                                 ((bt_local_le_features_t *)(properties[i].val))->le_extended_advertising_supported;
1088                         le_features->le_extended_scan_support =
1089                                 ((bt_local_le_features_t *)(properties[i].val))->extended_scan_support;
1090                         le_features->le_maximum_advertising_data_length =
1091                                 ((bt_local_le_features_t *)(properties[i].val))->le_maximum_advertising_data_length;
1092
1093                         BT_INFO("LE 2M PHY Support (%d)", le_features->le_2m_phy_support);
1094                         BT_INFO("LE CODED PHY Support (%d)", le_features->le_coded_phy_support);
1095
1096                         send_event(OAL_EVENT_BLE_LOCAL_FEATURES,
1097                                         le_features,
1098                                         sizeof(event_adapter_le_features_t));
1099                         break;
1100                 }
1101                 case BT_PROPERTY_ADAPTER_LE_DISCOVERY_STARTED: {
1102                         BT_INFO("LE Discovery started");
1103                         send_event(OAL_EVENT_BLE_DISCOVERY_STARTED, NULL, 0);
1104                         break;
1105                 }
1106                 case BT_PROPERTY_ADAPTER_LE_DISCOVERY_STOPPED: {
1107                         BT_INFO("LE Discovery stopped");
1108                         send_event(OAL_EVENT_BLE_DISCOVERY_STOPPED, NULL, 0);
1109                         break;
1110                 }
1111                 default:
1112                          BT_WARN("Unhandled property: %d", properties[i].type);
1113                          break;
1114                 }
1115         }
1116 }
1117
1118 static void cb_adapter_profile_connected_devices(uint8_t count, uint8_t addr_list[][6])
1119 {
1120         event_adapter_profile_connected_devices *event_data;
1121         int i;
1122
1123         event_data = g_malloc0(sizeof(event_adapter_profile_connected_devices));
1124         event_data->count = count;
1125         for (i = 0; i < count; i++) {
1126                 memcpy(event_data->addr_list[i].addr, addr_list[i], BT_ADDRESS_BYTES_NUM);
1127         }
1128         send_event(OAL_EVENT_ADAPTER_PROFILE_CONNECTED_DEVICES, event_data, sizeof(event_adapter_profile_connected_devices));
1129 }
1130
1131 static void cb_adapter_discovery_state_changed(bt_discovery_state_t state)
1132 {
1133         oal_event_t event;
1134
1135         event = (BT_DISCOVERY_STARTED == state) ? OAL_EVENT_ADAPTER_INQUIRY_STARTED : OAL_EVENT_ADAPTER_INQUIRY_FINISHED;
1136
1137         BT_DBG("%d", state);
1138         send_event(event, NULL, 0);
1139 }
1140
1141 static void cb_adapter_device_found(int num_properties, bt_property_t *properties)
1142 {
1143         remote_device_t dev_info;
1144         ble_adv_data_t adv_info;
1145         oal_event_t event;
1146         gpointer event_data;
1147         gsize size = 0;
1148         BT_DBG("+");
1149
1150         if (num_properties == 0) {
1151                 BT_ERR("Unexpected, properties count is zero!!");
1152                 return;
1153         }
1154
1155         memset(&dev_info, 0x00, sizeof(remote_device_t));
1156         memset(&adv_info, 0x00, sizeof(ble_adv_data_t));
1157
1158         print_bt_properties(num_properties, properties);
1159         parse_device_properties(num_properties, properties, &dev_info, &adv_info);
1160
1161         BT_INFO("number of properties= [%d] ", num_properties);
1162
1163         if (dev_info.type != DEV_TYPE_BREDR) {
1164                 /* BLE Single or DUAL mode found, so it should have Adv data */
1165                 event_ble_dev_found_t * ble_dev_event = g_new0(event_ble_dev_found_t, 1);
1166
1167                 ble_dev_event->adv_len = adv_info.len;
1168
1169                 if (adv_info.len > 0 && adv_info.adv_data) {
1170                         memcpy(ble_dev_event->adv_data, adv_info.adv_data, adv_info.len);
1171                         ble_dev_event->adv_len = adv_info.len;
1172                 } else
1173                         ble_dev_event->adv_len = 0;
1174
1175                 ble_dev_event->device_info = dev_info;
1176
1177                 event_data = ble_dev_event;
1178                 size = sizeof(event_ble_dev_found_t);
1179                 event = OAL_EVENT_ADAPTER_INQUIRY_RESULT_BLE;
1180         } else {
1181                 /* BREDR device, so No Adv data */
1182                 event_dev_found_t * dev_event = g_new0(event_dev_found_t, 1);
1183
1184                 memcpy(dev_event, &dev_info, sizeof(remote_device_t));
1185                 event_data = dev_event;
1186                 size = sizeof(remote_device_t);
1187                 event = OAL_EVENT_ADAPTER_INQUIRY_RESULT_BREDR_ONLY;
1188         }
1189
1190         send_event(event, event_data, size);
1191
1192         BT_DBG("-");
1193 }
1194
1195 void cb_controller_error_received(uint8_t error_code)
1196 {
1197         uint8_t *event_data;
1198
1199         event_data = g_new0(uint8_t, 1);
1200         *event_data = error_code;
1201
1202         send_event(OAL_EVENT_CONTROLLER_ERROR_RECEIVED,
1203                 (gpointer)event_data, sizeof(uint8_t));
1204 }