bt-oal/oal-gatt.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 #include <dlog.h>
  20 #include <bluetooth.h>
  21 #include "bt_gatt.h"
  22 #include "oal-event.h"
  23 #include "oal-internal.h"
  24 #include "oal-manager.h"
  25 #include "oal-adapter-mgr.h"
  26 #include "oal-utils.h"
  27 #include "oal-gatt.h"
  28 #include "oal-common.h"
  29
  30 #define DEV_APPEARANCE  0x0000
  31 #define DEFAULT_GATT_CLIENT_UUID "0000A00A-1111-1111-0123-456789ABCDEF"
  32 #define MAX_PROP_LEN 90
  33 #define MAX_PERM_LEN 70
  34
  35 #define NUM_SERVER_INST 10 // Maximum slots supported by stack is set to 10
  36 #define CHECK_OAL_GATT_ENABLED() \
  37         do { \
  38                 if (gatt_api == NULL) { \
  39                         BT_ERR("GATT Not Enabled"); \
  40                         return OAL_STATUS_NOT_READY; \
  41                 } \
  42         } while (0)
  43
  44 #define CHECK_SERVER_INSTANCE(instance_id) \
  45         do { \
  46                 if (instance_id < 1 || instance_id > NUM_SERVER_INST) { \
  47                         BT_ERR("Invalid Instance"); \
  48                         return OAL_STATUS_INVALID_PARAM; \
  49                 } \
  50         } while (0)
  51
  52 #define CHECK_SERVER_REGISTRATION(instance_id) \
  53         do { \
  54                 if (gatt_servers[instance_id - 1].server_id < 0)  {\
  55                         BT_INFO("GATT server registeration is not done for server Instance : %d", instance_id);\
  56                         return OAL_STATUS_INTERNAL_ERROR;\
  57                 } \
  58         } while (0)
  59
  60 #define CHECK_CORRECT_SERVER_ID(instance_id, server_if, server_inst)\
  61         do { \
  62                 for (instance_id = 1 ; instance_id <= NUM_SERVER_INST; instance_id++) { \
  63                         if (gatt_servers[instance_id - 1].server_id == server_if) { \
  64                                 server_inst = instance_id; \
  65                                 goto sendevent;\
  66                         } \
  67                 } \
  68         } while (0)
  69
  70 #define PRINT_ADV_DATA(length, manuf_data, data_type) \
  71         do { \
  72                 char * buf_str = g_malloc0(3*length + 1);\
  73                 if (NULL != buf_str) { \
  74                         convert_hex_2_str(manuf_data, length, buf_str);\
  75                         if (TRUE == data_type) \
  76                         BT_INFO("Scan Response Data:%s\n", buf_str);\
  77                         else \
  78                         BT_INFO("Advertising Data:%s\n", buf_str);\
  79                         g_free(buf_str);\
  80                 } \
  81         } while (0)
  82
  83 typedef enum {
  84         GATT_INS_DISABLED,
  85         GATT_INS_DATA_SETTING,
  86         GATT_INS_DATA_SET,
  87         GATT_INS_ENABLING,
  88         GATT_INS_ENABLED,
  89 } gatt_data_state;
  90
  91 typedef struct {
  92         int server_id;
  93         oal_uuid_t uuid;
  94         int state;
  95 } gatt_server_t;
  96
  97 const char *oal_device_type[] = {
  98         "UNKNOWN",
  99         "BR/EDR",
 100         "BLE",
 101         "DUAL_MODE",
 102 };
 103
 104 typedef enum {
 105         OAL_REQ_NONE,
 106         OAL_REQ_LE_SCAN,
 107         OAL_REQ_LE_CONNECT,
 108 } oal_pending_gattc_req_e;
 109
 110 static const btgatt_interface_t * gatt_api;
 111 static gboolean cur_adv_state[NUM_SERVER_INST];
 112 static gatt_server_t gatt_servers[NUM_SERVER_INST];
 113
 114 static int default_client_id = -1;
 115 static int pending_gattc_req = OAL_REQ_NONE;
 116
 117 /* Forward declarations of GATT Server callbacks */
 118 static void cb_gatts_register_app(int status, int server_if, bt_uuid_t *uuid);
 119 static void cb_gatts_multi_adv_enable(int server_if, int status);
 120 static void cb_gatts_multi_adv_set_inst_data(int server_if, int status);
 121 static void cb_gatts_multi_adv_disable(int server_if, int status);
 122 static void cb_gatts_multi_adv_update(int server_if, int status);
 123
 124 static void cb_gatts_listen(int status, int server_if);
 125
 126
 127 static void cb_gatts_service_added(int status, int server_if, btgatt_srvc_id_t *srvc_id, int srvc_handle);
 128 static void cb_gatts_included_service_added(int status, int server_if, int srvc_handle, int incl_srvc_handle);
 129 static void cb_gatts_characteristic_added(int status, int server_if, bt_uuid_t *char_id, int srvc_handle, int char_handle);
 130 static void cb_gatts_descriptor_added(int status, int server_if, bt_uuid_t *descr_id, int srvc_handle, int descr_handle);
 131
 132 static void cb_gatts_service_started(int status, int server_if, int srvc_handle);
 133 static void cb_gatts_service_stopped(int status, int server_if, int srvc_handle);
 134 static void cb_gatts_service_deleted(int status, int server_if, int srvc_handle);
 135
 136 static void cb_gatts_request_read(int conn_id, int trans_id, bt_bdaddr_t *bda, int attr_handle, int offset, bool is_long);
 137 static void cb_gatts_request_write(int conn_id, int trans_id, bt_bdaddr_t *bda, int attr_handle, int offset, int length,
 138                                         bool need_rsp, bool is_prep, uint8_t* value);
 139 static void cb_gatts_response_confirmation(int status, int handle);
 140
 141 static void cb_indication_confirmation(int conn_id, int trans_id, int attr_handle, bt_bdaddr_t *bda);
 142 static void cb_gatts_connection(int conn_id, int server_if, int connected, bt_bdaddr_t *bda);
 143
 144 static void cb_gatts_mtu_changed(int conn_id, int mtu);
 145
 146 #ifdef TIZEN_BT_HAL
 147 static void cb_notifcation_changed(int conn_id, int trans_id, int attr_handle, bool notify,  bt_bdaddr_t *bda);
 148 #endif
 149
 150 /************************************HAL Interface *************************************/
 151
 152 /*TODO GATT Server callbacks will be implemented in subsequent patches */
 153 static const btgatt_server_callbacks_t btgatt_server_callbacks = {
 154         cb_gatts_register_app,
 155         cb_gatts_connection,
 156         cb_gatts_service_added,
 157         cb_gatts_included_service_added,
 158         cb_gatts_characteristic_added,
 159         cb_gatts_descriptor_added,
 160         cb_gatts_service_started,
 161         cb_gatts_service_stopped,
 162         cb_gatts_service_deleted,
 163         cb_indication_confirmation,
 164         cb_gatts_request_read,
 165         cb_gatts_request_write,
 166         NULL, /*cb_gatts_request_exec_write,*/
 167         cb_gatts_response_confirmation,
 168         cb_gatts_listen,
 169         cb_gatts_multi_adv_enable,
 170         cb_gatts_multi_adv_update,
 171         cb_gatts_multi_adv_set_inst_data,
 172         cb_gatts_multi_adv_disable,
 173         cb_gatts_mtu_changed,
 174 #ifdef TIZEN_BT_HAL
 175         cb_notifcation_changed,
 176 #endif
 177 };
 178
 179 /* Forward declaration for GATT client callbacks */
 180 static void cb_gattc_register_app(int status, int clientIf, bt_uuid_t *app_uuid);
 181 static void cb_gattc_scan_result(bt_bdaddr_t* bdaddress, int rssi, uint8_t *adv_data);
 182
 183 /*TODO GATT CLient callbacks will be implemented in subsequent patches */
 184 static const btgatt_client_callbacks_t btgatt_client_callbacks = {
 185         cb_gattc_register_app,
 186         cb_gattc_scan_result,
 187         NULL, /*cb_gattc_connection*/
 188         NULL, /*cb_gattc_disconnect*/
 189         NULL, /*cb_gattc_search_complete*/
 190         NULL, /*cb_gattc_search_result*/
 191         NULL, /*cb_gattc_get_characteristics*/
 192         NULL, /*cb_gattc_get_descriptor*/
 193         NULL, /*cb_gattc_get_included_service*/
 194         NULL, /*cb_gattc_register_for_notification*/
 195         NULL, /*cb_gattc_notify*/
 196         NULL, /*cb_gattc_read_characteristic*/
 197         NULL, /*cb_gattc_write_characteristic*/
 198         NULL, /*cb_gattc_read_descriptor*/
 199         NULL, /*cb_gattc_write_descriptor*/
 200         NULL, /*cb_gattc_execute_write*/
 201         NULL, /*cb_gattc_remote_rssi*/
 202         NULL, /*cb_gattc_configure_mtu_cmpl*/
 203 #ifdef PLATFORM_ANDROID_HAL
 204         NULL, /*cb_scan_filter_cfg*/
 205         NULL, /*cb_scan_filter_param*/
 206         NULL, /*cb_scan_filter_status*/
 207         NULL, /*cb_congestion*/
 208         NULL, /*cb_batchscan_cfg_storag*/
 209         NULL, /*cb_batchscan_enb_disable*/
 210         NULL, /*cb_batchscan_reports*/
 211         NULL, /*cb_batchscan_threshold*/
 212         NULL, /*cb_track_adv_event*/
 213 #endif
 214 };
 215
 216 static btgatt_callbacks_t btgatt_callbacks = {
 217         sizeof(btgatt_callbacks_t),
 218         &btgatt_client_callbacks,
 219         &btgatt_server_callbacks
 220 };
 221
 222 /*******************************GATT Initialisation - Deinitialisation********************************/
 223 oal_status_t gatt_enable(void)
 224 {
 225         const bt_interface_t * blued_api;
 226         int ret;
 227         int i = 0;
 228
 229         for (i = 0; i < NUM_SERVER_INST; i++) {
 230                 gatt_servers[i].server_id = -1;
 231                 gatt_servers[i].state = GATT_INS_DISABLED;
 232                 memset(&gatt_servers[i].uuid, 0, sizeof(oal_uuid_t));
 233                 cur_adv_state[i] = FALSE;
 234         }
 235
 236         /* Get stack interface */
 237         blued_api = (const bt_interface_t *) adapter_get_stack_interface();
 238
 239         if (blued_api == NULL) {
 240                 BT_ERR("Stack is not initialized");
 241                 return OAL_STATUS_NOT_READY;
 242         }
 243
 244         if (gatt_api) {
 245                 BT_WARN("GATT Interface is already initialized...");
 246                 return OAL_STATUS_ALREADY_DONE;
 247         }
 248
 249         gatt_api = (const btgatt_interface_t *)blued_api->get_profile_interface(BT_PROFILE_GATT_ID);
 250         if (gatt_api == NULL) {
 251                 BT_ERR("GATT interface failed");
 252                 return OAL_STATUS_INTERNAL_ERROR;
 253         }
 254
 255         if ((ret = gatt_api->init(&btgatt_callbacks)) != BT_STATUS_SUCCESS) {
 256                 BT_ERR("Error: Unable to initialise GATT :%s", status2string(ret));
 257                 gatt_api->cleanup();
 258                 gatt_api = NULL;
 259                 return convert_to_oal_status(ret);
 260         }
 261
 262         BT_INFO("GATT successfully initialized");
 263         return OAL_STATUS_SUCCESS;
 264 }
 265
 266 oal_status_t gatt_disable(void)
 267 {
 268         int i;
 269         if (gatt_api) {
 270                 gatt_api->cleanup();
 271                 gatt_api = NULL;
 272         }
 273
 274         for (i = 0; i < NUM_SERVER_INST; i++) {
 275                 gatt_servers[i].server_id = -1;
 276                 gatt_servers[i].state = GATT_INS_DISABLED;
 277                 memset(&gatt_servers[i].uuid, 0, sizeof(oal_uuid_t));
 278         }
 279         return OAL_STATUS_SUCCESS;
 280 }
 281
 282 /************************************GATT Server Functions*************************************/
 283 /*Public */
 284 oal_status_t gatts_register(oal_uuid_t* server_uuid)
 285 {
 286         char str[2*BT_UUID_STRING_MAX];
 287         int ret = OAL_STATUS_SUCCESS;
 288         int i;
 289
 290         CHECK_OAL_GATT_ENABLED();
 291         uuid_to_stringname((service_uuid_t*)server_uuid->uuid, str);
 292         API_TRACE("Register the server instance: UUID: [%s]", str);
 293
 294         for (i = 0; i < NUM_SERVER_INST; i++) {
 295                 if (memcmp(server_uuid->uuid, gatt_servers[i].uuid.uuid, sizeof(oal_uuid_t)) == 0) {
 296                         if (gatt_servers[i].server_id != -1) {
 297                                 BT_ERR("This is resevered UUID for easy set up application i = %d \
 298                                                 gatt_servers[i].server_id = %d", i, gatt_servers[i].server_id);
 299                                 return OAL_STATUS_ALREADY_DONE;
 300                         }
 301                 }
 302         }
 303
 304         ret = gatt_api->server->register_server((bt_uuid_t*)server_uuid);
 305
 306         if (ret != BT_STATUS_SUCCESS) {
 307                 BT_ERR("GATT server registration with UUID:%s failed: %s", str, status2string(ret));
 308                 return convert_to_oal_status(ret);
 309         }
 310         return OAL_STATUS_SUCCESS;
 311 }
 312
 313 oal_status_t gatts_unregister(int instance_id)
 314 {
 315         int ret = OAL_STATUS_SUCCESS;
 316         API_TRACE("Unregister the registered server, instance_id: %d", instance_id);
 317
 318         CHECK_OAL_GATT_ENABLED();
 319         CHECK_SERVER_INSTANCE(instance_id);
 320         CHECK_SERVER_REGISTRATION(instance_id);
 321
 322         ret = gatt_api->server->unregister_server(gatt_servers[instance_id - 1].server_id);
 323
 324         if (ret != BT_STATUS_SUCCESS) {
 325                 BT_ERR("GATT server unregistration failed: %d", instance_id);
 326                 return convert_to_oal_status(ret);
 327         }
 328
 329         gatt_servers[instance_id-1].server_id = -1;
 330         gatt_servers[instance_id-1].state = GATT_INS_DISABLED;
 331
 332         if (instance_id != 1 && instance_id != 2)
 333                 memset(&gatt_servers[instance_id-1].uuid, 0, sizeof(oal_uuid_t));
 334
 335         return OAL_STATUS_SUCCESS;
 336 }
 337
 338 /* Legacy Advertisement */
 339 oal_status_t gatts_start_listen(int instance_id, gboolean enable)
 340 {
 341         int ret = OAL_STATUS_SUCCESS;
 342         API_TRACE("server-id:%d enable: %d", gatt_servers[instance_id-1].server_id, enable);
 343
 344         CHECK_OAL_GATT_ENABLED();
 345         CHECK_SERVER_INSTANCE(instance_id);
 346         CHECK_SERVER_REGISTRATION(instance_id);
 347
 348         ret = gatt_api->server->listen(gatt_servers[instance_id-1].server_id, enable);
 349
 350         if (ret != BT_STATUS_SUCCESS) {
 351                 BT_ERR("Error:Advertising start/stop on server-id:%d failed With Status: [%s]",
 352                                 gatt_servers[instance_id-1].server_id, status2string(ret));
 353                 return convert_to_oal_status(ret);
 354         }
 355
 356         return OAL_STATUS_SUCCESS;
 357 }
 358
 359 oal_status_t gatts_stop_advertising(int instance_id)
 360 {
 361         int ret = OAL_STATUS_SUCCESS;
 362         API_TRACE("Stop advertising");
 363
 364         CHECK_OAL_GATT_ENABLED();
 365         CHECK_SERVER_INSTANCE(instance_id);
 366         CHECK_SERVER_REGISTRATION(instance_id);
 367
 368         ret = gatt_api->server->listen(gatt_servers[instance_id - 1].server_id, FALSE);
 369
 370         if (ret != BT_STATUS_SUCCESS) {
 371                 BT_ERR("Stop Advertising failed for server Instance:%d With Status: %s",
 372                         instance_id, status2string(ret));
 373                 return convert_to_oal_status(ret);
 374         }
 375         return OAL_STATUS_SUCCESS;
 376 }
 377
 378 #if 0
 379 /* Below API's need to be removed as they are hardcoded API's.
 380    If at all, product specific API's are required to set specific data, then new naming should
 381    be adopted for these API's */
 382 oal_status_t gatts_set_advertising_params(int instance_id, float min_intv, float max_intv)
 383 {
 384         int ret = OAL_STATUS_SUCCESS;
 385
 386         API_TRACE("Set advertising params min_int:%f, max_int:%f", min_intv, max_intv);
 387         CHECK_OAL_GATT_ENABLED();
 388         CHECK_SERVER_INSTANCE(instance_id);
 389         CHECK_SERVER_REGISTRATION(instance_id);
 390
 391         /* Historically used for Legacy Advertising */
 392         return OAL_STATUS_NOT_SUPPORT;
 393 }
 394
 395 oal_status_t gatts_set_advertising_data(int instance_id, uint16_t manufac_len, char* manufac_data)
 396 {
 397         int ret = OAL_STATUS_SUCCESS;
 398
 399         API_TRACE("Set advertising data");
 400         CHECK_OAL_GATT_ENABLED();
 401         CHECK_SERVER_INSTANCE(instance_id);
 402         CHECK_SERVER_REGISTRATION(instance_id);
 403
 404         /* Historically used for Legacy Advertising */
 405         return OAL_STATUS_NOT_SUPPORT;
 406 }
 407
 408 oal_status_t gatts_set_scan_response(int instance_id, uint16_t manufac_len, char* manufac_data)
 409 {
 410         int ret = OAL_STATUS_SUCCESS;
 411
 412         API_TRACE("Set Scan Response data");
 413         CHECK_OAL_GATT_ENABLED();
 414         CHECK_SERVER_INSTANCE(instance_id);
 415         CHECK_SERVER_REGISTRATION(instance_id);
 416
 417         /* Historically used for Legacy Advertising */
 418         return OAL_STATUS_NOT_SUPPORT;
 419 }
 420 #endif
 421
 422 oal_status_t gatts_multi_adv_enable(int instance_id)
 423 {
 424         int ret = OAL_STATUS_SUCCESS;
 425         API_TRACE("Start Multi advertising, srv_if: %d, instance_id: %d",
 426                         gatt_servers[instance_id - 1].server_id, instance_id);
 427
 428         CHECK_OAL_GATT_ENABLED();
 429         CHECK_SERVER_INSTANCE(instance_id);
 430         CHECK_SERVER_REGISTRATION(instance_id);
 431
 432         if (gatt_api->server->multi_adv_enable == NULL)
 433                 return OAL_STATUS_NOT_SUPPORT;
 434
 435 /* Platform Requirement: Advertising to be enabled even when no data is set: i.e Empty Advertisement
 436         if (gatt_servers[instance_id - 1].state != GATT_INS_DATA_SET){
 437                 BT_ERR("Not allowed, state: %d, instance_id: %d",
 438                                 gatt_servers[instance_id - 1].state, instance_id);
 439                 return OAL_STATUS_BUSY;
 440         }
 441 */
 442         if (gatt_servers[instance_id - 1].state == GATT_INS_ENABLED) {
 443                 BT_ERR("Not allowed, state: %d, instance_id: %d",
 444                                 gatt_servers[instance_id - 1].state, instance_id);
 445                 return OAL_STATUS_ALREADY_DONE;
 446         }
 447
 448         if (gatt_servers[instance_id - 1].state == GATT_INS_ENABLING) {
 449                 BT_ERR("Not allowed, state: %d, instance_id: %d",
 450                                 gatt_servers[instance_id - 1].state, instance_id);
 451                 return OAL_STATUS_BUSY;
 452         }
 453
 454         gatt_servers[instance_id - 1].state = GATT_INS_ENABLING;
 455
 456         ret = gatt_api->server->multi_adv_enable(gatt_servers[instance_id - 1].server_id);
 457
 458         if (ret != BT_STATUS_SUCCESS) {
 459                 BT_ERR("GATT enable multi advertising failed for server Instance: %d With Status: %s",
 460                                 instance_id, status2string(ret));
 461 //              gatt_servers[instance_id - 1].state = GATT_INS_DATA_SET;
 462                 return convert_to_oal_status(ret);
 463         }
 464         return OAL_STATUS_SUCCESS;
 465 }
 466
 467 oal_status_t gatts_multi_adv_disable(int instance_id)
 468 {
 469         int ret = OAL_STATUS_SUCCESS;
 470         API_TRACE("Stop Multi advertising, srv_if: %d, instance_id: %d",
 471                         gatt_servers[instance_id - 1].server_id, instance_id);
 472
 473         CHECK_OAL_GATT_ENABLED();
 474         CHECK_SERVER_INSTANCE(instance_id);
 475         CHECK_SERVER_REGISTRATION(instance_id);
 476
 477         if (gatt_api->server->multi_adv_disable == NULL)
 478                 return OAL_STATUS_NOT_SUPPORT;
 479
 480         if ((gatt_servers[instance_id - 1].state != GATT_INS_ENABLED)) {
 481                 BT_ERR("Not Allowed, state: %d, instance_id: %d",
 482                         gatt_servers[instance_id - 1].state, instance_id);
 483                 return OAL_STATUS_BUSY;
 484         }
 485
 486         ret = gatt_api->server->multi_adv_disable(gatt_servers[instance_id - 1].server_id);
 487
 488         if (ret != BT_STATUS_SUCCESS) {
 489                 BT_ERR("GATT disable multi advertising failed for server Instance: %d With Status: %s",
 490                                 instance_id, status2string(ret));
 491                 return convert_to_oal_status(ret);
 492         }
 493         return OAL_STATUS_SUCCESS;
 494 }
 495
 496 oal_status_t gatts_multi_adv_update(int instance_id,
 497                 int min_intv, int max_intv,
 498                 int adv_type, int chnl_map,
 499                 int tx_power, int timeout_s)
 500 {
 501         int ret = OAL_STATUS_SUCCESS;
 502         API_TRACE("Multi advertising Update");
 503
 504         CHECK_OAL_GATT_ENABLED();
 505         CHECK_SERVER_INSTANCE(instance_id);
 506         CHECK_SERVER_REGISTRATION(instance_id);
 507
 508         if (gatt_api->server->multi_adv_update == NULL)
 509                 return OAL_STATUS_NOT_SUPPORT;
 510
 511         ret = gatt_api->server->multi_adv_update(gatt_servers[instance_id - 1].server_id,
 512                         min_intv, max_intv,
 513                         adv_type, chnl_map,
 514                         tx_power, timeout_s);
 515
 516         if (ret != BT_STATUS_SUCCESS) {
 517                 BT_ERR("GATT update multi advertising failed for server Instance: %d With Status: %s",
 518                                 instance_id, status2string(ret));
 519                 return convert_to_oal_status(ret);
 520         }
 521         return OAL_STATUS_SUCCESS;
 522 }
 523
 524 oal_status_t gatts_multi_adv_set_inst_data(int instance_id,
 525                 oal_ble_multi_adv_param_setup_t *adv_param_setup)
 526 {
 527         int ret = OAL_STATUS_SUCCESS;
 528         btgatt_adv_param_setup_t adv_setup;
 529         API_TRACE("Set Multi advertising data, srv_if: %d, instance_id: %d",
 530                         gatt_servers[instance_id - 1].server_id, instance_id);
 531
 532         CHECK_OAL_GATT_ENABLED();
 533         CHECK_SERVER_INSTANCE(instance_id);
 534         CHECK_SERVER_REGISTRATION(instance_id);
 535
 536         if (gatt_api->server->multi_adv_set_inst_data == NULL)
 537                 return OAL_STATUS_NOT_SUPPORT;
 538
 539         if ((gatt_servers[instance_id - 1].state >= GATT_INS_DATA_SETTING) && (gatt_servers[instance_id - 1].state != GATT_INS_DATA_SET)) {
 540                 BT_ERR("Not Allowed, state: %d, instance_id: %d", gatt_servers[instance_id - 1].state, instance_id);
 541                 return OAL_STATUS_BUSY;
 542         }
 543
 544         gatt_servers[instance_id - 1].state = GATT_INS_DATA_SETTING;
 545
 546
 547         adv_setup.set_scan_rsp = adv_param_setup->set_scan_rsp;
 548         adv_setup.include_name = adv_param_setup->include_name;
 549         adv_setup.include_txpower = adv_param_setup->include_txpower;
 550         adv_setup.appearance = adv_param_setup->appearance;
 551         adv_setup.manufacturer_data = adv_param_setup->manufacturer_data;
 552         adv_setup.manufacturer_data_len = adv_param_setup->manufacturer_data_len;
 553         adv_setup.service_data = adv_param_setup->service_data;
 554         adv_setup.service_data_len = adv_param_setup->service_data_len;
 555         adv_setup.service_uuid = adv_param_setup->service_uuid;
 556         adv_setup.service_uuid_len = adv_param_setup->service_uuid_len;
 557         /* Solicit UUID handler: Start */
 558         adv_setup.solicit_uuid = adv_param_setup->solicit_uuid;
 559         adv_setup.solicit_uuid_len = adv_param_setup->solicit_uuid_len;
 560         /* Solicit UUID handler: End */
 561         adv_setup.min_interval = adv_param_setup->min_interval;
 562         adv_setup.max_interval = adv_param_setup->min_interval;
 563         adv_setup.adv_type = adv_param_setup->adv_type;
 564         adv_setup.chnl_map = adv_param_setup->chnl_map;
 565         adv_setup.tx_power = adv_param_setup->tx_power;
 566         adv_setup.timeout_s = adv_param_setup->timeout_s;
 567
 568         adv_setup.server_if = gatt_servers[instance_id - 1].server_id;
 569         if (adv_setup.manufacturer_data_len > 0 && adv_setup.manufacturer_data != NULL) {
 570                 BT_INFO("Manufacture data.....\n");
 571                 PRINT_ADV_DATA(adv_setup.manufacturer_data_len, adv_setup.manufacturer_data, adv_setup.set_scan_rsp);
 572         }
 573
 574         if (adv_setup.service_uuid_len > 0 && adv_setup.service_uuid != NULL) {
 575                 BT_INFO("Service uuid.....\n");
 576                 PRINT_ADV_DATA(adv_setup.service_uuid_len, adv_setup.service_uuid, FALSE);
 577         }
 578
 579
 580         ret = gatt_api->server->multi_adv_set_inst_data(adv_setup);
 581
 582         if (ret != BT_STATUS_SUCCESS) {
 583                 BT_ERR("GATT Set Multi advertising data failed: %s", status2string(ret));
 584                 gatt_servers[instance_id - 1].state = GATT_INS_DISABLED;
 585                 return convert_to_oal_status(ret);
 586         }
 587         return OAL_STATUS_SUCCESS;
 588 }
 589
 590 /************************************GATT Server Functions*************************************/
 591 /*Server Callbacks*/
 592 static void cb_gatts_register_app(int status, int server_if, bt_uuid_t *uuid)
 593 {
 594         int i;
 595         char str[2*BT_UUID_STRING_MAX];
 596         uuid_to_stringname((service_uuid_t*)uuid, str);
 597
 598         event_gatts_register_t *event = g_malloc0(sizeof(event_gatts_register_t));
 599
 600         BT_INFO("BTGATT SERVER REGISTER APP CB, status:%d, server_if:%d", status, server_if);
 601         BT_INFO("UUID: [%s]", str);
 602
 603         for (i = 0; i < NUM_SERVER_INST; i++) {
 604                 if (gatt_servers[i].server_id == -1) {
 605                         BT_INFO("Server Instance registered with stack [%d]", i+1);
 606                         gatt_servers[i].server_id = server_if;
 607                         event->server_inst = i+1;
 608                         memcpy(gatt_servers[i].uuid.uuid, uuid->uu, sizeof(bt_uuid_t));
 609                         memcpy(event->server_uuid.uuid, uuid->uu, sizeof(bt_uuid_t));
 610                         break;
 611                 }
 612         }
 613         send_event(OAL_EVENT_BLE_SERVER_INSTANCE_INITIALISED, event, sizeof(event_gatts_register_t));
 614 }
 615
 616 static void cb_gatts_listen(int status, int server_if)
 617 {
 618         gboolean prev_state[NUM_SERVER_INST];
 619         gboolean new_state;
 620         event_ble_adv_status *event = g_malloc0(sizeof(event_ble_adv_status));
 621         int instance_id;
 622
 623         for (instance_id = 1 ; instance_id <= NUM_SERVER_INST ; instance_id++) {
 624                 if (gatt_servers[instance_id - 1].server_id == server_if) {
 625                         event->server_inst = instance_id;
 626                         break;
 627                 } else {
 628                         BT_WARN("Server ID:%d recevied server Id:%d\n", gatt_servers[instance_id - 1].server_id, server_if);
 629                 }
 630         }
 631         if ((event->server_inst > 0) && (event->server_inst <= 10)) {
 632                 prev_state[event->server_inst - 1] = cur_adv_state[event->server_inst - 1];
 633                 new_state = (status == BT_STATUS_SUCCESS) ? !(prev_state[event->server_inst - 1]) : (prev_state[event->server_inst - 1]);
 634                 cur_adv_state[event->server_inst - 1] = new_state;
 635         } else {
 636                 BT_ERR("Invalid Callback...");
 637                 return;
 638         }
 639
 640         BT_INFO("Adv State of server instance %d :%d", instance_id, new_state);
 641
 642         if (TRUE == new_state)
 643                 send_event(OAL_EVENT_BLE_ADVERTISING_STARTED, event, sizeof(event_ble_adv_status));
 644         else
 645                 send_event(OAL_EVENT_BLE_ADVERTISING_STOPPED, event, sizeof(event_ble_adv_status));
 646 }
 647
 648 static void cb_gatts_multi_adv_enable(int server_if, int status)
 649 {
 650
 651         BT_INFO("BTGATT SERVER MULTI ADV ENABLE CB, status:%d, srv_if: %d", status, server_if);
 652         event_ble_multiadv_status *event = g_malloc0(sizeof(event_ble_multiadv_status));
 653         int instance_id;
 654
 655         if (status != BT_STATUS_SUCCESS)
 656                 BT_ERR("MULTI ADV ENABLE failed, status:%d, srv_if: %d", status, server_if);
 657
 658         for (instance_id = 1 ; instance_id <= NUM_SERVER_INST ; instance_id++) {
 659                 if (gatt_servers[instance_id - 1].server_id == server_if) {
 660                         event->server_inst = instance_id;
 661                         gatt_servers[instance_id - 1].state = GATT_INS_ENABLED;
 662                         goto sendevent;
 663                 }
 664         }
 665         BT_ERR("Invalid Interface, srv_if: %d", server_if);
 666         event->server_inst = -1;
 667 sendevent:
 668         event->status = convert_to_oal_status(status);
 669         send_event(OAL_EVENT_BLE_MULTI_ADVERTISING_ENABLE, event, sizeof(event_ble_multiadv_status));
 670 }
 671
 672 static void cb_gatts_multi_adv_disable(int server_if, int status)
 673 {
 674         BT_INFO("BTGATT SERVER MULTI ADV DISABLE CB, status:%d, srv_if: %d", status, server_if);
 675         event_ble_multiadv_status *event = g_malloc0(sizeof(event_ble_multiadv_status));
 676         int instance_id;
 677
 678         if (status != BT_STATUS_SUCCESS)
 679                 BT_ERR("MULTI ADV DISABLE failed, status:%d, srv_if: %d", status, server_if);
 680
 681         for (instance_id = 1 ; instance_id <= NUM_SERVER_INST; instance_id++) {
 682                 if (gatt_servers[instance_id - 1].server_id == server_if) {
 683                         event->server_inst = instance_id;
 684                         gatt_servers[instance_id - 1].state = GATT_INS_DISABLED;
 685                         goto sendevent;
 686                 }
 687         }
 688         BT_ERR("Invalid Interface, srv_if: %d", server_if);
 689         event->server_inst = -1;
 690 sendevent:
 691         event->status = convert_to_oal_status(status);
 692         send_event(OAL_EVENT_BLE_MULTI_ADVERTISING_DISABLE, event, sizeof(event_ble_multiadv_status));
 693 }
 694
 695 static void cb_gatts_multi_adv_update(int server_if, int status)
 696 {
 697         BT_INFO("BTGATT SERVER MULTI ADV UPDATE CB, status:%d, srv_if: %d", status, server_if);
 698         event_ble_multiadv_status *event = g_malloc0(sizeof(event_ble_multiadv_status));
 699         int instance_id;
 700
 701         if (status != BT_STATUS_SUCCESS)
 702                 BT_ERR("MULTI ADV UPDATE failed, status:%d, srv_if: %d", status, server_if);
 703
 704         for (instance_id = 1 ; instance_id <= NUM_SERVER_INST ; instance_id++) {
 705                 if (gatt_servers[instance_id - 1].server_id == server_if) {
 706                         event->server_inst = instance_id;
 707                         goto sendevent;
 708                 }
 709         }
 710         BT_ERR("Invalid Interface, srv_if: %d", server_if);
 711         event->server_inst = -1;
 712 sendevent:
 713         event->status = convert_to_oal_status(status);
 714         send_event(OAL_EVENT_BLE_MULTI_ADVERTISING_UPDATE, event, sizeof(event_ble_multiadv_status));
 715 }
 716
 717 static void cb_gatts_multi_adv_set_inst_data(int server_if, int status)
 718 {
 719         BT_INFO("BTGATT SERVER MULTI ADV SET INST DATA CB, status:%d, srv_if: %d", status, server_if);
 720         event_ble_multiadv_status *event = g_malloc0(sizeof(event_ble_multiadv_status));
 721         int instance_id;
 722
 723         if (status != BT_STATUS_SUCCESS)
 724                 BT_ERR("MULTI ADV SET DATA failed, status:%d, srv_if: %d", status, server_if);
 725
 726         for (instance_id = 1 ; instance_id <= NUM_SERVER_INST ; instance_id++) {
 727                 if (gatt_servers[instance_id - 1].server_id == server_if) {
 728                         event->server_inst = instance_id;
 729                         gatt_servers[instance_id - 1].state = GATT_INS_DATA_SET;
 730                         goto sendevent;
 731                 }
 732         }
 733         BT_ERR("Invalid Interface, srv_if: %d", server_if);
 734         event->server_inst = -1;
 735 sendevent:
 736         event->status = convert_to_oal_status(status);
 737         send_event(OAL_EVENT_BLE_MULTI_ADVERTISING_SET_INST_DATA, event, sizeof(event_ble_multiadv_status));
 738 }
 739
 740 oal_status_t gatts_get_att_mtu(int conn_id, int *mtu)
 741 {
 742         int ret = OAL_STATUS_SUCCESS;
 743         API_TRACE("Get ATT MTU, conn_id: %d", conn_id);
 744         CHECK_OAL_GATT_ENABLED();
 745         OAL_CHECK_PARAMETER(mtu, return);
 746
 747         /* To prevent crash in case other libraries not support this api */
 748         if (gatt_api->server->get_att_mtu == NULL) {
 749                 BT_WARN("get_att_mtu is NULL");
 750                 return OAL_STATUS_NOT_SUPPORT;
 751         }
 752
 753         ret = gatt_api->server->get_att_mtu(conn_id, mtu);
 754         if (ret != BT_STATUS_SUCCESS) {
 755                 BT_ERR("GATT MTU Size failed, status: %d", status2string(ret));
 756                 return convert_to_oal_status(ret);
 757         }
 758
 759         BT_INFO("Current ATT MTU Size: %d", *mtu);
 760         return OAL_STATUS_SUCCESS;
 761 }
 762
 763 oal_status_t gatts_add_service(int instance_id, oal_gatt_srvc_id_t *gatt_serv_id,
 764                 int num_handles)
 765 {
 766         int ret = OAL_STATUS_SUCCESS;
 767         btgatt_srvc_id_t btgatt_srvc_id;
 768         char str[2*BT_UUID_STRING_MAX];
 769
 770         API_TRACE("Server Add Service : instance_id = %d, num_handles = %d", instance_id, num_handles);
 771         CHECK_OAL_GATT_ENABLED();
 772
 773         CHECK_SERVER_INSTANCE(instance_id);
 774         CHECK_SERVER_REGISTRATION(instance_id);
 775
 776         if (gatt_servers[instance_id - 1].server_id < 0)        {
 777                 BT_INFO("GATT server registeration is not done for server Instance : %d", instance_id);
 778                 return gatts_register(&gatt_servers[instance_id - 1].uuid);
 779         }
 780
 781         if (gatt_serv_id != NULL) {
 782                 uuid_to_stringname(&(gatt_serv_id->id.uuid), str);
 783                 API_TRACE("Service uuid: [%s]", str);
 784                 memcpy(btgatt_srvc_id.id.uuid.uu,  gatt_serv_id->id.uuid.uuid, sizeof(gatt_serv_id->id.uuid));
 785                 btgatt_srvc_id.id.inst_id  = gatt_serv_id->id.inst_id;
 786                 btgatt_srvc_id.is_primary = gatt_serv_id->is_prmry;
 787         } else {
 788                 BT_INFO("GATT Server Service Id is NULL");
 789                 return OAL_STATUS_INVALID_PARAM;
 790         }
 791
 792         ret = gatt_api->server->add_service(gatt_servers[instance_id - 1].server_id, &btgatt_srvc_id, num_handles);
 793
 794         if (ret != BT_STATUS_SUCCESS) {
 795                 BT_ERR("GATT Server add service failed: %s", status2string(ret));
 796                 return convert_to_oal_status(ret);
 797         }
 798         return OAL_STATUS_SUCCESS;
 799 }
 800
 801 oal_status_t gatts_add_included_services(int instance_id, int serv_handle,
 802                 int incl_handle)
 803 {
 804         int ret = OAL_STATUS_SUCCESS;
 805         API_TRACE("Server Add included Service : instance_id = %d, serv_handle = %d, incl_handle = %d",
 806                         instance_id, serv_handle, incl_handle);
 807         CHECK_OAL_GATT_ENABLED();
 808
 809         CHECK_SERVER_INSTANCE(instance_id);
 810
 811         CHECK_SERVER_REGISTRATION(instance_id);
 812
 813         ret = gatt_api->server->add_included_service(gatt_servers[instance_id - 1].server_id, serv_handle, incl_handle);
 814         if (ret != BT_STATUS_SUCCESS) {
 815                 BT_ERR("GATT Server Add included Service failed: %s", status2string(ret));
 816                 return convert_to_oal_status(ret);
 817         }
 818         return OAL_STATUS_SUCCESS;
 819 }
 820
 821 oal_status_t gatts_add_characteristics(int instance_id, int serv_handle,
 822                         oal_uuid_t* charc_uuid, int propts, int permsn)
 823 {
 824         int ret = OAL_STATUS_SUCCESS;
 825         char str[2*BT_UUID_STRING_MAX];
 826         char prop[MAX_PROP_LEN], perm[MAX_PERM_LEN];
 827         char_prop_to_string(propts, prop);
 828         char_perm_to_string(permsn, perm);
 829         API_TRACE("Server Add Characteristic : instance_id = %d, serv_handle = %d, Properties =%s, Permisison = %s",
 830                 instance_id, serv_handle, prop, perm);
 831         CHECK_OAL_GATT_ENABLED();
 832
 833         CHECK_SERVER_INSTANCE(instance_id);
 834
 835         CHECK_SERVER_REGISTRATION(instance_id);
 836
 837         if (charc_uuid != NULL) {
 838                 uuid_to_stringname(charc_uuid, str);
 839                 API_TRACE("uuid: [%s]", str);
 840         }
 841
 842         ret = gatt_api->server->add_characteristic(gatt_servers[instance_id - 1].server_id,
 843                         serv_handle, (bt_uuid_t*)charc_uuid, propts, permsn);
 844         if (ret != BT_STATUS_SUCCESS) {
 845                 BT_ERR("GATT Server Add Characteristic failed: %s", status2string(ret));
 846                 return convert_to_oal_status(ret);
 847         }
 848         return OAL_STATUS_SUCCESS;
 849 }
 850
 851 oal_status_t gatts_add_descriptor(int instance_id, int serv_handle,
 852                 oal_uuid_t* desc_uuid, int permsn)
 853 {
 854         int ret = OAL_STATUS_SUCCESS;
 855         char str[2*BT_UUID_STRING_MAX];
 856         char perm[MAX_PERM_LEN];
 857         char_perm_to_string(permsn, perm);
 858         API_TRACE("Server Add Descriptor : instance_id = %d, serv_handle = %d, Permisison = %s",
 859                         instance_id, serv_handle, perm);
 860         CHECK_OAL_GATT_ENABLED();
 861
 862         CHECK_SERVER_INSTANCE(instance_id);
 863
 864         CHECK_SERVER_REGISTRATION(instance_id);
 865
 866         if (desc_uuid != NULL) {
 867                 uuid_to_stringname(desc_uuid, str);
 868                 API_TRACE("uuid: [%s]", str);
 869         }
 870
 871         ret = gatt_api->server->add_descriptor(gatt_servers[instance_id - 1].server_id,
 872                                 serv_handle, (bt_uuid_t*)desc_uuid, permsn);
 873
 874         if (ret != BT_STATUS_SUCCESS) {
 875                 BT_ERR("GATT Server Add Descriptor failed: %s", status2string(ret));
 876                 return convert_to_oal_status(ret);
 877         }
 878         return OAL_STATUS_SUCCESS;
 879 }
 880
 881 oal_status_t gatts_start_service(int instance_id, int svc_handle, int transport)
 882 {
 883         int ret = OAL_STATUS_SUCCESS;
 884
 885         API_TRACE("Server Start Service : Ins_id = %d, srvHndl = %d, transport = %d",
 886                                 instance_id, svc_handle, transport);
 887         CHECK_OAL_GATT_ENABLED();
 888
 889         CHECK_SERVER_INSTANCE(instance_id);
 890
 891         CHECK_SERVER_REGISTRATION(instance_id);
 892
 893         ret = gatt_api->server->start_service(gatt_servers[instance_id - 1].server_id, svc_handle, transport);
 894
 895         if (ret != BT_STATUS_SUCCESS) {
 896                 BT_ERR("GATT Server Start Service failed: %s", status2string(ret));
 897                 return convert_to_oal_status(ret);
 898         }
 899         return OAL_STATUS_SUCCESS;
 900 }
 901
 902 oal_status_t gatts_stop_service(int ins_id, int srv_hdl)
 903 {
 904         int ret = OAL_STATUS_SUCCESS;
 905
 906         API_TRACE("Server Stop Service : Ins_id = %d, srvHndl = %d, ", ins_id, srv_hdl);
 907         CHECK_OAL_GATT_ENABLED();
 908
 909         CHECK_SERVER_INSTANCE(ins_id);
 910         CHECK_SERVER_REGISTRATION(ins_id);
 911
 912         ret = gatt_api->server->stop_service(gatt_servers[ins_id - 1].server_id, srv_hdl);
 913         if (ret != BT_STATUS_SUCCESS) {
 914                 BT_ERR("GATT Server Stop Service failed: %s", status2string(ret));
 915                 return convert_to_oal_status(ret);
 916         }
 917         return OAL_STATUS_SUCCESS;
 918 }
 919
 920 oal_status_t gatts_delete_service(int ins_id, int srv_hdl)
 921 {
 922         int ret = OAL_STATUS_SUCCESS;
 923
 924         API_TRACE("Server Delete Service : Ins_id = %d, srvHndl = %d, ", ins_id, srv_hdl);
 925         CHECK_OAL_GATT_ENABLED();
 926
 927         CHECK_SERVER_INSTANCE(ins_id);
 928
 929         CHECK_SERVER_REGISTRATION(ins_id);
 930
 931         ret = gatt_api->server->delete_service(gatt_servers[ins_id - 1].server_id, srv_hdl);
 932         if (ret != BT_STATUS_SUCCESS) {
 933                 BT_ERR("GATT Server Delete Service failed: %s", status2string(ret));
 934                 return convert_to_oal_status(ret);
 935         }
 936         return OAL_STATUS_SUCCESS;
 937 }
 938
 939 oal_status_t gatts_send_response(int conn_id, int trans_id, int resp_status, oal_gatt_response_t *response)
 940 {
 941         int ret = OAL_STATUS_SUCCESS;
 942
 943         API_TRACE("Server Send Response : ConnId = %d, TransId = %d, ", conn_id, trans_id);
 944         CHECK_OAL_GATT_ENABLED();
 945
 946         if (response == NULL) {
 947                 BT_ERR("GATT Server attribute value is empty");
 948                 return OAL_STATUS_INVALID_PARAM;
 949         }
 950
 951         ret = gatt_api->server->send_response(conn_id, trans_id, resp_status, (btgatt_response_t *)response);
 952         if (ret != BT_STATUS_SUCCESS) {
 953                 BT_ERR("GATT Server Send Response failed: %s", status2string(ret));
 954                 return convert_to_oal_status(ret);
 955         }
 956         return OAL_STATUS_SUCCESS;
 957 }
 958
 959 oal_status_t gatts_send_indication(int ins_id, int attr_hndl, int conn_id, int len, int confirm, char* value)
 960 {
 961         int ret = OAL_STATUS_SUCCESS;
 962
 963         API_TRACE("Server Send Indication : Ins_id = %d, srvHndl = %d, [%s]",
 964                         ins_id, attr_hndl, confirm == TRUE ? "INDICATION" : "NOTIFICATION");
 965         CHECK_OAL_GATT_ENABLED();
 966
 967         CHECK_SERVER_INSTANCE(ins_id);
 968
 969         CHECK_SERVER_REGISTRATION(ins_id);
 970
 971         if (value == NULL || len == 0) {
 972                 BT_ERR("GATT Server attribute value is empty");
 973                 return OAL_STATUS_INVALID_PARAM;
 974         }
 975
 976         ret = gatt_api->server->send_indication(gatt_servers[ins_id - 1].server_id,
 977                         attr_hndl, conn_id, len, confirm, value);
 978
 979         if (ret != BT_STATUS_SUCCESS) {
 980                 BT_ERR("GATT Server Send Indication failed: %s", status2string(ret));
 981                 return convert_to_oal_status(ret);
 982         }
 983         return OAL_STATUS_SUCCESS;
 984 }
 985
 986 oal_status_t gatts_update_att_value(int ins_id, oal_gatt_value_t *value)
 987 {
 988         int ret = OAL_STATUS_SUCCESS;
 989
 990         API_TRACE("Server Update Value: Ins_id = [%d], att handle = [%d] data len [%d]",
 991                         ins_id, value->handle, value->len);
 992
 993         CHECK_OAL_GATT_ENABLED();
 994
 995         CHECK_SERVER_INSTANCE(ins_id);
 996
 997         CHECK_SERVER_REGISTRATION(ins_id);
 998
 999         if (value == NULL || value->len == 0) {
1000                 BT_ERR("GATT Server attribute value is empty");
1001                 return OAL_STATUS_INVALID_PARAM;
1002         }
1003
1004         ret = gatt_api->server->update_att_value(gatt_servers[ins_id - 1].server_id,
1005                         (int)value->handle, (int)value->len, (char*)value->value);
1006
1007         if (ret != BT_STATUS_SUCCESS) {
1008                 BT_ERR("GATT Server Update Attribute Value failed: [%s]", status2string(ret));
1009                 return convert_to_oal_status(ret);
1010         }
1011         return OAL_STATUS_SUCCESS;
1012 }
1013
1014 /* GATT Server Callbacks:Start */
1015 static void cb_gatts_service_added(int status, int server_if,
1016                 btgatt_srvc_id_t *psrvc_id, int srvc_handle)
1017 {
1018         int instance_id;
1019
1020         BT_INFO("BTGATT SERVER SERVICE ADDED CB, status:%d, handle:%d", status, srvc_handle);
1021         event_gatts_srvc_prm_t* event = g_new0(event_gatts_srvc_prm_t, 1);
1022
1023         CHECK_CORRECT_SERVER_ID(instance_id, server_if, event->gatt_srvc_stat.server_inst);
1024
1025         BT_ERR("Invalid Interface, srv_if: %d", server_if);
1026         event->gatt_srvc_stat.server_inst = -1;
1027 sendevent:
1028         event->gatt_srvc_stat.servic_hndl = srvc_handle;
1029         if (psrvc_id != NULL) {
1030                 event->gatt_srvc_id.id.inst_id = psrvc_id->id.inst_id;
1031                 //event->gatt_srvc_id.id.uuid = psrvc_id->id.uuid;
1032                 memcpy(event->gatt_srvc_id.id.uuid.uuid,  psrvc_id->id.uuid.uu, sizeof(psrvc_id->id.uuid));
1033                 event->gatt_srvc_id.is_prmry = psrvc_id->is_primary;
1034         }
1035
1036         event->gatt_srvc_stat.status = convert_to_oal_status(status);
1037
1038         send_event(OAL_EVENT_GATTS_SERVICE_ADDED, event, sizeof(event_gatts_srvc_prm_t));
1039 }
1040
1041 static void cb_gatts_included_service_added(int status, int server_if,
1042                 int srvc_handle,
1043                 int incl_srvc_handle)
1044 {
1045         int ins_id ;
1046         BT_INFO("BTGATT SERVER INCLUDED SERVICE ADDED CB, status:%d, srvc handle:%d, incl handle:%d",
1047                         status, srvc_handle, incl_srvc_handle);
1048
1049         event_gatts_incld_srvc_t* event = g_new0(event_gatts_incld_srvc_t, 1);
1050
1051         CHECK_CORRECT_SERVER_ID(ins_id, server_if, event->gatt_srvc_stat.server_inst);
1052
1053         BT_ERR("Invalid Interface, srv_if: %d", server_if);
1054         event->gatt_srvc_stat.server_inst = -1;
1055 sendevent:
1056         event->gatt_srvc_stat.servic_hndl = srvc_handle;
1057         event->incl_srvc_hndl = incl_srvc_handle;
1058         event->gatt_srvc_stat.status = convert_to_oal_status(status);
1059         send_event(OAL_EVENT_GATTS_INCLUDED_SERVICE_ADDED, event, sizeof(event_gatts_incld_srvc_t));
1060 }
1061
1062 static void cb_gatts_characteristic_added(int status, int server_if, bt_uuid_t *char_id,
1063                 int srvc_handle, int char_handle)
1064 {
1065         int Ins_id ;
1066
1067         BT_INFO("BTGATT SERVER CHARACTERISTIC ADDED CB, status:%d, srvc handle:%d, char handle:%d",
1068                         status, srvc_handle, char_handle);
1069
1070         event_gatts_srvc_charctr_t* event = g_new0(event_gatts_srvc_charctr_t, 1);
1071
1072         CHECK_CORRECT_SERVER_ID(Ins_id, server_if, event->gatt_srvc_stat.server_inst);
1073
1074         BT_ERR("Invalid Interface, srv_if: %d", server_if);
1075         event->gatt_srvc_stat.server_inst = -1;
1076 sendevent:
1077         event->gatt_srvc_stat.servic_hndl = srvc_handle;
1078         event->charctr_hndl = char_handle;
1079         event->gatt_srvc_stat.status = convert_to_oal_status(status);
1080         memcpy(event->charctr_uuid.uuid, char_id->uu, sizeof(bt_uuid_t));
1081         send_event(OAL_EVENT_GATTS_CHARACTERISTIC_ADDED, event, sizeof(event_gatts_srvc_charctr_t));
1082 }
1083
1084 static void cb_gatts_descriptor_added(int status, int server_if,
1085                 bt_uuid_t *descr_id, int srvc_handle,
1086                 int descr_handle)
1087 {
1088         int Ins_id ;
1089         BT_INFO("BTGATT SERVER DESCRIPTOR ADDED CB, status:%d, srvc handle:%d, desc handle:%d",
1090                         status, srvc_handle, descr_handle);
1091
1092         event_gatts_srvc_descr_t* event = g_new0(event_gatts_srvc_descr_t, 1);
1093
1094         CHECK_CORRECT_SERVER_ID(Ins_id, server_if, event->gatt_srvc_stat.server_inst);
1095
1096         BT_ERR("Invalid Interface, srv_if: %d", server_if);
1097         event->gatt_srvc_stat.server_inst = -1;
1098 sendevent:
1099         event->gatt_srvc_stat.servic_hndl = srvc_handle;
1100         event->descrptr_hndl = descr_handle;
1101         event->gatt_srvc_stat.status = convert_to_oal_status(status);
1102         memcpy(event->descrptr_uuid.uuid, descr_id->uu, sizeof(bt_uuid_t));
1103         send_event(OAL_EVENT_GATTS_DESCRIPTOR_ADDED, event, sizeof(event_gatts_srvc_descr_t));
1104 }
1105
1106 static void cb_gatts_service_started(int status, int server_if, int srvc_handle)
1107 {
1108         int Ins_id ;
1109         BT_INFO("BTGATT SERVER SERVICE STARTED CB, status:%d, srvc_handle:%d", status, srvc_handle);
1110
1111         event_gatts_srvc_t* event = g_new0(event_gatts_srvc_t, 1);
1112
1113         CHECK_CORRECT_SERVER_ID(Ins_id, server_if, event->server_inst);
1114
1115         BT_ERR("Invalid Interface, srv_if: %d", server_if);
1116         event->server_inst = -1;
1117 sendevent:
1118         event->servic_hndl = srvc_handle;
1119         event->status = convert_to_oal_status(status);
1120         send_event(OAL_EVENT_GATTS_SERVICE_STARTED, event, sizeof(event_gatts_srvc_t));
1121 }
1122
1123 static void cb_gatts_service_stopped(int status, int server_if, int srvc_handle)
1124 {
1125         int ins_id ;
1126         BT_INFO("BTGATT SERVER SERVICE STOPPED CB, status:%d, srvc_handle:%d", status, srvc_handle);
1127
1128         event_gatts_srvc_t* event = g_new0(event_gatts_srvc_t, 1);
1129
1130         CHECK_CORRECT_SERVER_ID(ins_id, server_if, event->server_inst);
1131
1132         BT_ERR("Invalid Interface, srv_if: %d", server_if);
1133         event->server_inst = -1;
1134 sendevent:
1135         event->servic_hndl = srvc_handle;
1136         event->status = convert_to_oal_status(status);
1137         send_event(OAL_EVENT_GATTS_SERVICE_STOPED, event, sizeof(event_gatts_srvc_t));
1138 }
1139
1140 static void cb_gatts_service_deleted(int status, int server_if, int srvc_handle)
1141 {
1142         int ins_id;
1143         BT_INFO("BTGATT SERVER SERVICE DELETED CB, status:%d, srvc_handle:%d", status, srvc_handle);
1144
1145         event_gatts_srvc_t* event = g_new0(event_gatts_srvc_t, 1);
1146
1147         CHECK_CORRECT_SERVER_ID(ins_id, server_if, event->server_inst);
1148
1149         BT_ERR("Invalid Interface, srv_if: %d", server_if);
1150         event->server_inst = -1;
1151 sendevent:
1152         event->servic_hndl = srvc_handle;
1153         event->status = convert_to_oal_status(status);
1154         send_event(OAL_EVENT_GATTS_SERVICE_DELETED, event, sizeof(event_gatts_srvc_t));
1155 }
1156
1157 static void cb_gatts_connection(int conn_id, int server_if, int connected, bt_bdaddr_t *bda)
1158 {
1159         int ins_id ;
1160         oal_event_t event_type;
1161
1162         BT_INFO("BTGATT SERVER CONNECTION  connnected:%d, conn_id:%d server_if:%d", connected, conn_id, server_if);
1163         event_gatts_conn_t *event = g_new0(event_gatts_conn_t, 1);
1164
1165         for (ins_id = 1 ; ins_id <= NUM_SERVER_INST ; ins_id++) {
1166                 if ((gatt_servers[ins_id - 1].server_id == server_if) &&
1167                                 (gatt_servers[ins_id - 1].state == GATT_INS_ENABLED)) {
1168                         event->server_inst = ins_id;
1169                         break;
1170                 } else {
1171                         BT_INFO("Server ID:%d recevied server Id:%d\n", gatt_servers[ins_id - 1].server_id, server_if);
1172                 }
1173         }
1174         if (ins_id == NUM_SERVER_INST+1) {
1175                 BT_WARN("Incorrect Server Interface received: %d\n",  server_if);
1176                 g_free(event);
1177                 return;
1178         }
1179         memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1180         event->conn_id = conn_id;
1181         event_type = ((connected == TRUE) ? OAL_EVENT_GATTS_CONNECTION_COMPLETED : OAL_EVENT_GATTS_DISCONNECTION_COMPLETED);
1182
1183         send_event(event_type, event, sizeof(event_gatts_conn_t));
1184 }
1185
1186 static void cb_gatts_request_read(int conn_id, int trans_id, bt_bdaddr_t *bda,
1187                 int attr_handle, int offset, bool is_long)
1188 {
1189         BT_INFO("BTGATT SERVER REQUEST READ CB: conn_id:%d", conn_id);
1190
1191         event_gatts_srvc_read_attr_t* event = g_new0(event_gatts_srvc_read_attr_t, 1);
1192
1193         memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1194
1195         event->attr_trans.attr_handle = attr_handle;
1196         event->attr_trans.conn_id = conn_id;
1197         event->attr_trans.trans_id = trans_id;
1198         event->attr_trans.offset = offset;
1199         event->is_long = is_long;
1200
1201         send_event(OAL_EVENT_GATTS_REQUEST_READ, event, sizeof(event_gatts_srvc_read_attr_t));
1202 }
1203
1204 static void cb_gatts_request_write(int conn_id, int trans_id,
1205                 bt_bdaddr_t *bda, int attr_handle,
1206                 int offset, int length,
1207                 bool need_rsp, bool is_prep, uint8_t* value)
1208 {
1209         BT_INFO("BTGATT SERVER REQUEST WRITE conn_id:%d", conn_id);
1210
1211         event_gatts_srvc_write_attr_t* event = g_new0(event_gatts_srvc_write_attr_t, 1);
1212
1213         memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1214
1215         event->attr_trans.attr_handle = attr_handle;
1216         event->attr_trans.conn_id = conn_id;
1217         event->attr_trans.trans_id = trans_id;
1218         event->attr_trans.offset = offset;
1219         event->need_rsp = need_rsp;
1220         event->is_prep = is_prep;
1221
1222         if (length > 0 && value != NULL) {
1223                 if (length > OAL_GATT_MAX_ATTR_LEN)
1224                         length = OAL_GATT_MAX_ATTR_LEN;
1225                 memcpy(event->value, value, length);
1226                 event->length = length;
1227         }
1228         send_event(OAL_EVENT_GATTS_REQUEST_WRITE, event, sizeof(event_gatts_srvc_write_attr_t));
1229 }
1230
1231 static void cb_gatts_response_confirmation(int status, int handle)
1232 {
1233         BT_INFO("BTGATT SERVER RESPONSE CONFIRMATION CB, status:%d, handle:%d", status, handle);
1234
1235         event_gatts_respons_t* event = g_new0(event_gatts_respons_t, 1);
1236
1237         event->hndl = handle;
1238         event->status = convert_to_oal_status(status);
1239
1240         send_event(OAL_EVENT_GATTS_RESPONSE_CONFIRMED, event, sizeof(event_gatts_respons_t));
1241 }
1242
1243 static void cb_indication_confirmation(int conn_id, int trans_id, int attr_handle, bt_bdaddr_t *bda)
1244 {
1245         BT_INFO("BTGATT SERVER Indication Confirmation CB, conn_id:%d, trans_id:%d attr_handle:%d",
1246                         conn_id, trans_id, attr_handle);
1247
1248         event_gatts_ind_cnfrm_t* event = g_new0(event_gatts_ind_cnfrm_t, 1);
1249
1250         memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1251
1252         event->attr_handle = attr_handle;
1253         event->conn_id = conn_id;
1254         event->trans_id = trans_id;
1255         send_event(OAL_EVENT_GATTS_IND_CONFIRM, event, sizeof(event_gatts_ind_cnfrm_t));
1256 }
1257
1258 static void cb_gatts_mtu_changed(int conn_id, int mtu)
1259 {
1260         BT_INFO("BTGATT SERVER MTU CHANGED CB, conn_id: %d, mtu_size: %d", conn_id, mtu);
1261         event_gatts_mtu_changed_t *event = g_new0(event_gatts_mtu_changed_t, 1);
1262         event->conn_id = conn_id;
1263         event->mtu_size = mtu;
1264         send_event(OAL_EVENT_GATTS_MTU_CHANGED, event, sizeof(event_gatts_mtu_changed_t));
1265 }
1266
1267 #ifdef TIZEN_BT_HAL
1268 static void cb_notifcation_changed(int conn_id, int trans_id, int attr_handle, bool notify,  bt_bdaddr_t *bda)
1269 {
1270         BT_INFO("BTGATT SERVER Notication CB, conn_id:%d, trans_id:%d attr_handle:%d Notify:%d",
1271                         conn_id, trans_id, attr_handle, notify);
1272
1273         event_gatts_notif_t* event = g_new0(event_gatts_notif_t, 1);
1274
1275         memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1276
1277         event->attr_handle = attr_handle;
1278         event->conn_id = conn_id;
1279         event->trans_id = trans_id;
1280         event->notify = notify;
1281         send_event(OAL_EVENT_GATTS_NOTIFICATION, event, sizeof(event_gatts_notif_t));
1282 }
1283 #endif
1284
1285
1286 /* GATT Server Callbacks: End */
1287 /************************************ GATT Client ***********************************/
1288 /* Client Callbacks */
1289 static void cb_gattc_register_app(int status, int clientIf, bt_uuid_t *app_uuid)
1290 {
1291         char uuid_str[BT_UUID_STRING_MAX];
1292         event_gattc_register_t *event;
1293
1294         /* Check if GATT client registered for Default GATT client UUID */
1295         uuid_to_string((service_uuid_t *)app_uuid, uuid_str);
1296         if (!strncasecmp(DEFAULT_GATT_CLIENT_UUID,
1297                                 uuid_str, strlen(DEFAULT_GATT_CLIENT_UUID))) {
1298                 default_client_id = clientIf;
1299                 switch (pending_gattc_req) {
1300                 case OAL_REQ_LE_SCAN:
1301                         if (0 != status) {
1302                                 default_client_id = -1;
1303                                 pending_gattc_req = OAL_REQ_NONE;
1304                                 BT_ERR("Default client app creation failed");
1305                                 send_event(OAL_EVENT_BLE_DISCOVERY_STOPPED, NULL, 0);
1306                                 break;
1307                         }
1308
1309                         if (OAL_STATUS_SUCCESS != gattc_start_le_discovery()) {
1310                                 BT_ERR("Error:Start LE Discovery failed");
1311                                 send_event(OAL_EVENT_BLE_DISCOVERY_STOPPED, NULL, 0);
1312                         }
1313                         break;
1314                 default:
1315                         BT_ERR("Unknown pending request: %d", pending_gattc_req);
1316                 }
1317
1318                 /* Return from here, no need to send GATTC_REGISTRATION event */
1319                 return;
1320         }
1321
1322         BT_INFO("BTGATT CLIENT REGISTER APP CB, status:%d, clientIf:%d", status, clientIf);
1323         event = g_new0(event_gattc_register_t, 1);
1324         event->client_if = clientIf;
1325         event->status = (status == 0 ? OAL_STATUS_SUCCESS : OAL_STATUS_INTERNAL_ERROR);
1326         memcpy(event->client_uuid.uuid, app_uuid->uu, sizeof(oal_uuid_t));
1327         send_event_no_trace(OAL_EVENT_GATTC_REGISTRATION, event, sizeof(event_gattc_register_t));
1328 }
1329
1330 static void cb_gattc_scan_result(bt_bdaddr_t* bdaddress, int rssi, uint8_t *adv_data)
1331 {
1332         event_ble_scan_result_info *event;
1333
1334         event = g_new0(event_ble_scan_result_info, 1);
1335         event->rssi = rssi;
1336         memcpy(event->address.addr, bdaddress->address, BT_ADDRESS_BYTES_NUM);
1337         memcpy(event->adv_data, adv_data, BLE_ADV_DATA_LENGTH);
1338         send_event_bda_trace(OAL_EVENT_BLE_REMOTE_DEVICE_FOUND, event,
1339                         sizeof(event_ble_scan_result_info), (bt_address_t *)bdaddress);
1340 }
1341
1342 /* Register default gatt client to be used in LE scan etc. */
1343 static oal_status_t __register_default_gatt_client(void)
1344 {
1345         bt_uuid_t uuid;
1346         int ret;
1347
1348         API_TRACE("GATT client register");
1349         CHECK_OAL_GATT_ENABLED();
1350
1351         if (default_client_id >= 0) {
1352                 BT_ERR("Client Already registered");
1353                 return OAL_STATUS_ALREADY_DONE;
1354         }
1355
1356         string_to_uuid(DEFAULT_GATT_CLIENT_UUID, (service_uuid_t *)&uuid);
1357         ret = gatt_api->client->register_client(&uuid);
1358         if (ret != BT_STATUS_SUCCESS) {
1359                 BT_ERR("GATT client register failed: %s", status2string(ret));
1360                 return convert_to_oal_status(ret);
1361         }
1362
1363         return OAL_STATUS_SUCCESS;
1364 }
1365
1366 oal_status_t gattc_start_le_discovery(void)
1367 {
1368         int ret;
1369
1370         API_TRACE("BTGATT CLIENT SCAN START");
1371         CHECK_OAL_GATT_ENABLED();
1372
1373         if (default_client_id < 0) {
1374                 if (pending_gattc_req != OAL_REQ_NONE) {
1375                         BT_ERR("Another request: %d already in progress", pending_gattc_req);
1376                         return OAL_STATUS_INTERNAL_ERROR;
1377                 }
1378
1379                 pending_gattc_req = OAL_REQ_LE_SCAN;
1380                 ret = __register_default_gatt_client();
1381                 if (OAL_STATUS_SUCCESS != ret) {
1382                         BT_ERR("__register_default_gatt_client failed");
1383                         pending_gattc_req = OAL_REQ_NONE;
1384                         return OAL_STATUS_INTERNAL_ERROR;
1385                 }
1386
1387                 return OAL_STATUS_SUCCESS;
1388         }
1389
1390         ret = gatt_api->client->scan(default_client_id, true);
1391         if (ret != BT_STATUS_SUCCESS) {
1392                 BT_ERR("Error:Start LE Discovery failed: %s", status2string(ret));
1393                 return convert_to_oal_status(ret);
1394         }
1395
1396         send_event(OAL_EVENT_BLE_DISCOVERY_STARTED, NULL, 0);
1397         return OAL_STATUS_SUCCESS;
1398 }
1399
1400 oal_status_t gattc_stop_le_discovery(void)
1401 {
1402         int ret;
1403
1404         API_TRACE("Scan is stopped");
1405         CHECK_OAL_GATT_ENABLED();
1406
1407         ret = gatt_api->client->scan(default_client_id, false);
1408         if (ret != BT_STATUS_SUCCESS) {
1409                 BT_ERR("Error:Stop LE Discovery failed: %s", status2string(ret));
1410                 return convert_to_oal_status(ret);
1411         }
1412
1413         send_event(OAL_EVENT_BLE_DISCOVERY_STOPPED, NULL, 0);
1414         return OAL_STATUS_SUCCESS;
1415 }
1416
1417 oal_status_t gattc_set_le_scan_param(int scan_type, int itv, int win)
1418 {
1419         int ret;
1420
1421         API_TRACE("Scan is stopped");
1422         CHECK_OAL_GATT_ENABLED();
1423
1424 #ifdef TIZEN_BT_HAL
1425         ret = gatt_api->client->set_scan_parameters(scan_type, itv, win);
1426         if (ret != BT_STATUS_SUCCESS) {
1427                 BT_ERR("Error:Set scan parameters failed: %s", status2string(ret));
1428                 return convert_to_oal_status(ret);
1429         }
1430 #else
1431         ret = gatt_api->client->set_scan_parameters(itv, win);
1432         if (ret != BT_STATUS_SUCCESS) {
1433                 BT_ERR("Error:Set scan parameters failed: %s", status2string(ret));
1434                 return convert_to_oal_status(ret);
1435         }
1436 #endif
1437
1438         return OAL_STATUS_SUCCESS;
1439 }
1440 /************************************ GATT Client ***********************************/