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 95 /* SVACE WGID: 324403*/
  33 #define MAX_PERM_LEN 80 //Fix for svace wgid:324402
  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_serv_id != NULL) {
 777                 uuid_to_stringname(&(gatt_serv_id->id.uuid), str);
 778                 API_TRACE("Service uuid: [%s]", str);
 779                 memcpy(btgatt_srvc_id.id.uuid.uu,  gatt_serv_id->id.uuid.uuid, sizeof(gatt_serv_id->id.uuid));
 780                 btgatt_srvc_id.id.inst_id  = gatt_serv_id->id.inst_id;
 781                 btgatt_srvc_id.is_primary = gatt_serv_id->is_prmry;
 782         } else {
 783                 BT_INFO("GATT Server Service Id is NULL");
 784                 return OAL_STATUS_INVALID_PARAM;
 785         }
 786
 787         ret = gatt_api->server->add_service(gatt_servers[instance_id - 1].server_id, &btgatt_srvc_id, num_handles);
 788
 789         if (ret != BT_STATUS_SUCCESS) {
 790                 BT_ERR("GATT Server add service failed: %s", status2string(ret));
 791                 return convert_to_oal_status(ret);
 792         }
 793         return OAL_STATUS_SUCCESS;
 794 }
 795
 796 oal_status_t gatts_add_included_services(int instance_id, int serv_handle,
 797                 int incl_handle)
 798 {
 799         int ret = OAL_STATUS_SUCCESS;
 800         API_TRACE("Server Add included Service : instance_id = %d, serv_handle = %d, incl_handle = %d",
 801                         instance_id, serv_handle, incl_handle);
 802         CHECK_OAL_GATT_ENABLED();
 803
 804         CHECK_SERVER_INSTANCE(instance_id);
 805
 806         CHECK_SERVER_REGISTRATION(instance_id);
 807
 808         ret = gatt_api->server->add_included_service(gatt_servers[instance_id - 1].server_id, serv_handle, incl_handle);
 809         if (ret != BT_STATUS_SUCCESS) {
 810                 BT_ERR("GATT Server Add included Service failed: %s", status2string(ret));
 811                 return convert_to_oal_status(ret);
 812         }
 813         return OAL_STATUS_SUCCESS;
 814 }
 815
 816 oal_status_t gatts_add_characteristics(int instance_id, int serv_handle,
 817                         oal_uuid_t* charc_uuid, int propts, int permsn)
 818 {
 819         int ret = OAL_STATUS_SUCCESS;
 820         char str[2*BT_UUID_STRING_MAX];
 821         char prop[MAX_PROP_LEN], perm[MAX_PERM_LEN];
 822         char_prop_to_string(propts, prop);
 823         char_perm_to_string(permsn, perm);
 824         API_TRACE("Server Add Characteristic : instance_id = %d, serv_handle = %d, Properties =%s, Permisison = %s",
 825                 instance_id, serv_handle, prop, perm);
 826         CHECK_OAL_GATT_ENABLED();
 827
 828         CHECK_SERVER_INSTANCE(instance_id);
 829
 830         CHECK_SERVER_REGISTRATION(instance_id);
 831
 832         if (charc_uuid != NULL) {
 833                 uuid_to_stringname(charc_uuid, str);
 834                 API_TRACE("uuid: [%s]", str);
 835         }
 836
 837         ret = gatt_api->server->add_characteristic(gatt_servers[instance_id - 1].server_id,
 838                         serv_handle, (bt_uuid_t*)charc_uuid, propts, permsn);
 839         if (ret != BT_STATUS_SUCCESS) {
 840                 BT_ERR("GATT Server Add Characteristic failed: %s", status2string(ret));
 841                 return convert_to_oal_status(ret);
 842         }
 843         return OAL_STATUS_SUCCESS;
 844 }
 845
 846 oal_status_t gatts_add_descriptor(int instance_id, int serv_handle,
 847                 oal_uuid_t* desc_uuid, int permsn)
 848 {
 849         int ret = OAL_STATUS_SUCCESS;
 850         char str[2*BT_UUID_STRING_MAX];
 851         char perm[MAX_PERM_LEN];
 852         char_perm_to_string(permsn, perm);
 853         API_TRACE("Server Add Descriptor : instance_id = %d, serv_handle = %d, Permisison = %s",
 854                         instance_id, serv_handle, perm);
 855         CHECK_OAL_GATT_ENABLED();
 856
 857         CHECK_SERVER_INSTANCE(instance_id);
 858
 859         CHECK_SERVER_REGISTRATION(instance_id);
 860
 861         if (desc_uuid != NULL) {
 862                 uuid_to_stringname(desc_uuid, str);
 863                 API_TRACE("uuid: [%s]", str);
 864         }
 865
 866         ret = gatt_api->server->add_descriptor(gatt_servers[instance_id - 1].server_id,
 867                                 serv_handle, (bt_uuid_t*)desc_uuid, permsn);
 868
 869         if (ret != BT_STATUS_SUCCESS) {
 870                 BT_ERR("GATT Server Add Descriptor failed: %s", status2string(ret));
 871                 return convert_to_oal_status(ret);
 872         }
 873         return OAL_STATUS_SUCCESS;
 874 }
 875
 876 oal_status_t gatts_start_service(int instance_id, int svc_handle, int transport)
 877 {
 878         int ret = OAL_STATUS_SUCCESS;
 879
 880         API_TRACE("Server Start Service : Ins_id = %d, srvHndl = %d, transport = %d",
 881                                 instance_id, svc_handle, transport);
 882         CHECK_OAL_GATT_ENABLED();
 883
 884         CHECK_SERVER_INSTANCE(instance_id);
 885
 886         CHECK_SERVER_REGISTRATION(instance_id);
 887
 888         ret = gatt_api->server->start_service(gatt_servers[instance_id - 1].server_id, svc_handle, transport);
 889
 890         if (ret != BT_STATUS_SUCCESS) {
 891                 BT_ERR("GATT Server Start Service failed: %s", status2string(ret));
 892                 return convert_to_oal_status(ret);
 893         }
 894         return OAL_STATUS_SUCCESS;
 895 }
 896
 897 oal_status_t gatts_stop_service(int ins_id, int srv_hdl)
 898 {
 899         int ret = OAL_STATUS_SUCCESS;
 900
 901         API_TRACE("Server Stop Service : Ins_id = %d, srvHndl = %d, ", ins_id, srv_hdl);
 902         CHECK_OAL_GATT_ENABLED();
 903
 904         CHECK_SERVER_INSTANCE(ins_id);
 905         CHECK_SERVER_REGISTRATION(ins_id);
 906
 907         ret = gatt_api->server->stop_service(gatt_servers[ins_id - 1].server_id, srv_hdl);
 908         if (ret != BT_STATUS_SUCCESS) {
 909                 BT_ERR("GATT Server Stop Service failed: %s", status2string(ret));
 910                 return convert_to_oal_status(ret);
 911         }
 912         return OAL_STATUS_SUCCESS;
 913 }
 914
 915 oal_status_t gatts_delete_service(int ins_id, int srv_hdl)
 916 {
 917         int ret = OAL_STATUS_SUCCESS;
 918
 919         API_TRACE("Server Delete Service : Ins_id = %d, srvHndl = %d, ", ins_id, srv_hdl);
 920         CHECK_OAL_GATT_ENABLED();
 921
 922         CHECK_SERVER_INSTANCE(ins_id);
 923
 924         CHECK_SERVER_REGISTRATION(ins_id);
 925
 926         ret = gatt_api->server->delete_service(gatt_servers[ins_id - 1].server_id, srv_hdl);
 927         if (ret != BT_STATUS_SUCCESS) {
 928                 BT_ERR("GATT Server Delete Service failed: %s", status2string(ret));
 929                 return convert_to_oal_status(ret);
 930         }
 931         return OAL_STATUS_SUCCESS;
 932 }
 933
 934 oal_status_t gatts_send_response(int conn_id, int trans_id, int resp_status, oal_gatt_response_t *response)
 935 {
 936         int ret = OAL_STATUS_SUCCESS;
 937
 938         API_TRACE("Server Send Response : ConnId = %d, TransId = %d, ", conn_id, trans_id);
 939         CHECK_OAL_GATT_ENABLED();
 940
 941         if (response == NULL) {
 942                 BT_ERR("GATT Server attribute value is empty");
 943                 return OAL_STATUS_INVALID_PARAM;
 944         }
 945
 946         ret = gatt_api->server->send_response(conn_id, trans_id, resp_status, (btgatt_response_t *)response);
 947         if (ret != BT_STATUS_SUCCESS) {
 948                 BT_ERR("GATT Server Send Response failed: %s", status2string(ret));
 949                 return convert_to_oal_status(ret);
 950         }
 951         return OAL_STATUS_SUCCESS;
 952 }
 953
 954 oal_status_t gatts_send_indication(int ins_id, int attr_hndl, int conn_id, int len, int confirm, char* value)
 955 {
 956         int ret = OAL_STATUS_SUCCESS;
 957
 958         API_TRACE("Server Send Indication : Ins_id = %d, srvHndl = %d, [%s]",
 959                         ins_id, attr_hndl, confirm == TRUE ? "INDICATION" : "NOTIFICATION");
 960         CHECK_OAL_GATT_ENABLED();
 961
 962         CHECK_SERVER_INSTANCE(ins_id);
 963
 964         CHECK_SERVER_REGISTRATION(ins_id);
 965
 966         if (value == NULL || len == 0) {
 967                 BT_ERR("GATT Server attribute value is empty");
 968                 return OAL_STATUS_INVALID_PARAM;
 969         }
 970
 971         ret = gatt_api->server->send_indication(gatt_servers[ins_id - 1].server_id,
 972                         attr_hndl, conn_id, len, confirm, value);
 973
 974         if (ret != BT_STATUS_SUCCESS) {
 975                 BT_ERR("GATT Server Send Indication failed: %s", status2string(ret));
 976                 return convert_to_oal_status(ret);
 977         }
 978         return OAL_STATUS_SUCCESS;
 979 }
 980
 981 oal_status_t gatts_update_att_value(int ins_id, oal_gatt_value_t *value)
 982 {
 983         int ret = OAL_STATUS_SUCCESS;
 984
 985         API_TRACE("Server Update Value: Ins_id = [%d], att handle = [%d] data len [%d]",
 986                         ins_id, value->handle, value->len);
 987
 988         CHECK_OAL_GATT_ENABLED();
 989
 990         CHECK_SERVER_INSTANCE(ins_id);
 991
 992         CHECK_SERVER_REGISTRATION(ins_id);
 993
 994         if (value == NULL || value->len == 0) {
 995                 BT_ERR("GATT Server attribute value is empty");
 996                 return OAL_STATUS_INVALID_PARAM;
 997         }
 998
 999         ret = gatt_api->server->update_att_value(gatt_servers[ins_id - 1].server_id,
1000                         (int)value->handle, (int)value->len, (char*)value->value);
1001
1002         if (ret != BT_STATUS_SUCCESS) {
1003                 BT_ERR("GATT Server Update Attribute Value failed: [%s]", status2string(ret));
1004                 return convert_to_oal_status(ret);
1005         }
1006         return OAL_STATUS_SUCCESS;
1007 }
1008
1009 /* GATT Server Callbacks:Start */
1010 static void cb_gatts_service_added(int status, int server_if,
1011                 btgatt_srvc_id_t *psrvc_id, int srvc_handle)
1012 {
1013         int instance_id;
1014
1015         BT_INFO("BTGATT SERVER SERVICE ADDED CB, status:%d, handle:%d", status, srvc_handle);
1016         event_gatts_srvc_prm_t* event = g_new0(event_gatts_srvc_prm_t, 1);
1017
1018         CHECK_CORRECT_SERVER_ID(instance_id, server_if, event->gatt_srvc_stat.server_inst);
1019
1020         BT_ERR("Invalid Interface, srv_if: %d", server_if);
1021         event->gatt_srvc_stat.server_inst = -1;
1022 sendevent:
1023         event->gatt_srvc_stat.servic_hndl = srvc_handle;
1024         if (psrvc_id != NULL) {
1025                 event->gatt_srvc_id.id.inst_id = psrvc_id->id.inst_id;
1026                 //event->gatt_srvc_id.id.uuid = psrvc_id->id.uuid;
1027                 memcpy(event->gatt_srvc_id.id.uuid.uuid,  psrvc_id->id.uuid.uu, sizeof(psrvc_id->id.uuid));
1028                 event->gatt_srvc_id.is_prmry = psrvc_id->is_primary;
1029         }
1030
1031         event->gatt_srvc_stat.status = convert_to_oal_status(status);
1032
1033         send_event(OAL_EVENT_GATTS_SERVICE_ADDED, event, sizeof(event_gatts_srvc_prm_t));
1034 }
1035
1036 static void cb_gatts_included_service_added(int status, int server_if,
1037                 int srvc_handle,
1038                 int incl_srvc_handle)
1039 {
1040         int ins_id ;
1041         BT_INFO("BTGATT SERVER INCLUDED SERVICE ADDED CB, status:%d, srvc handle:%d, incl handle:%d",
1042                         status, srvc_handle, incl_srvc_handle);
1043
1044         event_gatts_incld_srvc_t* event = g_new0(event_gatts_incld_srvc_t, 1);
1045
1046         CHECK_CORRECT_SERVER_ID(ins_id, server_if, event->gatt_srvc_stat.server_inst);
1047
1048         BT_ERR("Invalid Interface, srv_if: %d", server_if);
1049         event->gatt_srvc_stat.server_inst = -1;
1050 sendevent:
1051         event->gatt_srvc_stat.servic_hndl = srvc_handle;
1052         event->incl_srvc_hndl = incl_srvc_handle;
1053         event->gatt_srvc_stat.status = convert_to_oal_status(status);
1054         send_event(OAL_EVENT_GATTS_INCLUDED_SERVICE_ADDED, event, sizeof(event_gatts_incld_srvc_t));
1055 }
1056
1057 static void cb_gatts_characteristic_added(int status, int server_if, bt_uuid_t *char_id,
1058                 int srvc_handle, int char_handle)
1059 {
1060         int Ins_id ;
1061
1062         BT_INFO("BTGATT SERVER CHARACTERISTIC ADDED CB, status:%d, srvc handle:%d, char handle:%d",
1063                         status, srvc_handle, char_handle);
1064
1065         event_gatts_srvc_charctr_t* event = g_new0(event_gatts_srvc_charctr_t, 1);
1066
1067         CHECK_CORRECT_SERVER_ID(Ins_id, server_if, event->gatt_srvc_stat.server_inst);
1068
1069         BT_ERR("Invalid Interface, srv_if: %d", server_if);
1070         event->gatt_srvc_stat.server_inst = -1;
1071 sendevent:
1072         event->gatt_srvc_stat.servic_hndl = srvc_handle;
1073         event->charctr_hndl = char_handle;
1074         event->gatt_srvc_stat.status = convert_to_oal_status(status);
1075         memcpy(event->charctr_uuid.uuid, char_id->uu, sizeof(bt_uuid_t));
1076         send_event(OAL_EVENT_GATTS_CHARACTERISTIC_ADDED, event, sizeof(event_gatts_srvc_charctr_t));
1077 }
1078
1079 static void cb_gatts_descriptor_added(int status, int server_if,
1080                 bt_uuid_t *descr_id, int srvc_handle,
1081                 int descr_handle)
1082 {
1083         int Ins_id ;
1084         BT_INFO("BTGATT SERVER DESCRIPTOR ADDED CB, status:%d, srvc handle:%d, desc handle:%d",
1085                         status, srvc_handle, descr_handle);
1086
1087         event_gatts_srvc_descr_t* event = g_new0(event_gatts_srvc_descr_t, 1);
1088
1089         CHECK_CORRECT_SERVER_ID(Ins_id, server_if, event->gatt_srvc_stat.server_inst);
1090
1091         BT_ERR("Invalid Interface, srv_if: %d", server_if);
1092         event->gatt_srvc_stat.server_inst = -1;
1093 sendevent:
1094         event->gatt_srvc_stat.servic_hndl = srvc_handle;
1095         event->descrptr_hndl = descr_handle;
1096         event->gatt_srvc_stat.status = convert_to_oal_status(status);
1097         memcpy(event->descrptr_uuid.uuid, descr_id->uu, sizeof(bt_uuid_t));
1098         send_event(OAL_EVENT_GATTS_DESCRIPTOR_ADDED, event, sizeof(event_gatts_srvc_descr_t));
1099 }
1100
1101 static void cb_gatts_service_started(int status, int server_if, int srvc_handle)
1102 {
1103         int Ins_id ;
1104         BT_INFO("BTGATT SERVER SERVICE STARTED CB, status:%d, srvc_handle:%d", status, srvc_handle);
1105
1106         event_gatts_srvc_t* event = g_new0(event_gatts_srvc_t, 1);
1107
1108         CHECK_CORRECT_SERVER_ID(Ins_id, server_if, event->server_inst);
1109
1110         BT_ERR("Invalid Interface, srv_if: %d", server_if);
1111         event->server_inst = -1;
1112 sendevent:
1113         event->servic_hndl = srvc_handle;
1114         event->status = convert_to_oal_status(status);
1115         send_event(OAL_EVENT_GATTS_SERVICE_STARTED, event, sizeof(event_gatts_srvc_t));
1116 }
1117
1118 static void cb_gatts_service_stopped(int status, int server_if, int srvc_handle)
1119 {
1120         int ins_id ;
1121         BT_INFO("BTGATT SERVER SERVICE STOPPED CB, status:%d, srvc_handle:%d", status, srvc_handle);
1122
1123         event_gatts_srvc_t* event = g_new0(event_gatts_srvc_t, 1);
1124
1125         CHECK_CORRECT_SERVER_ID(ins_id, server_if, event->server_inst);
1126
1127         BT_ERR("Invalid Interface, srv_if: %d", server_if);
1128         event->server_inst = -1;
1129 sendevent:
1130         event->servic_hndl = srvc_handle;
1131         event->status = convert_to_oal_status(status);
1132         send_event(OAL_EVENT_GATTS_SERVICE_STOPED, event, sizeof(event_gatts_srvc_t));
1133 }
1134
1135 static void cb_gatts_service_deleted(int status, int server_if, int srvc_handle)
1136 {
1137         int ins_id;
1138         BT_INFO("BTGATT SERVER SERVICE DELETED CB, status:%d, srvc_handle:%d", status, srvc_handle);
1139
1140         event_gatts_srvc_t* event = g_new0(event_gatts_srvc_t, 1);
1141
1142         CHECK_CORRECT_SERVER_ID(ins_id, server_if, event->server_inst);
1143
1144         BT_ERR("Invalid Interface, srv_if: %d", server_if);
1145         event->server_inst = -1;
1146 sendevent:
1147         event->servic_hndl = srvc_handle;
1148         event->status = convert_to_oal_status(status);
1149         send_event(OAL_EVENT_GATTS_SERVICE_DELETED, event, sizeof(event_gatts_srvc_t));
1150 }
1151
1152 static void cb_gatts_connection(int conn_id, int server_if, int connected, bt_bdaddr_t *bda)
1153 {
1154         int ins_id ;
1155         oal_event_t event_type;
1156
1157         BT_INFO("BTGATT SERVER CONNECTION  connnected:%d, conn_id:%d server_if:%d", connected, conn_id, server_if);
1158         event_gatts_conn_t *event = g_new0(event_gatts_conn_t, 1);
1159
1160         for (ins_id = 1 ; ins_id <= NUM_SERVER_INST ; ins_id++) {
1161                 if ((gatt_servers[ins_id - 1].server_id == server_if) &&
1162                                 (gatt_servers[ins_id - 1].state == GATT_INS_ENABLED)) {
1163                         event->server_inst = ins_id;
1164                         break;
1165                 } else {
1166                         BT_INFO("Server ID:%d recevied server Id:%d\n", gatt_servers[ins_id - 1].server_id, server_if);
1167                 }
1168         }
1169         if (ins_id == NUM_SERVER_INST+1) {
1170                 BT_WARN("Incorrect Server Interface received: %d\n",  server_if);
1171                 g_free(event);
1172                 return;
1173         }
1174         memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1175         event->conn_id = conn_id;
1176         event_type = ((connected == TRUE) ? OAL_EVENT_GATTS_CONNECTION_COMPLETED : OAL_EVENT_GATTS_DISCONNECTION_COMPLETED);
1177
1178         send_event(event_type, event, sizeof(event_gatts_conn_t));
1179 }
1180
1181 static void cb_gatts_request_read(int conn_id, int trans_id, bt_bdaddr_t *bda,
1182                 int attr_handle, int offset, bool is_long)
1183 {
1184         BT_INFO("BTGATT SERVER REQUEST READ CB: conn_id:%d", conn_id);
1185
1186         event_gatts_srvc_read_attr_t* event = g_new0(event_gatts_srvc_read_attr_t, 1);
1187
1188         memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1189
1190         event->attr_trans.attr_handle = attr_handle;
1191         event->attr_trans.conn_id = conn_id;
1192         event->attr_trans.trans_id = trans_id;
1193         event->attr_trans.offset = offset;
1194         event->is_long = is_long;
1195
1196         send_event(OAL_EVENT_GATTS_REQUEST_READ, event, sizeof(event_gatts_srvc_read_attr_t));
1197 }
1198
1199 static void cb_gatts_request_write(int conn_id, int trans_id,
1200                 bt_bdaddr_t *bda, int attr_handle,
1201                 int offset, int length,
1202                 bool need_rsp, bool is_prep, uint8_t* value)
1203 {
1204         BT_INFO("BTGATT SERVER REQUEST WRITE conn_id:%d", conn_id);
1205
1206         event_gatts_srvc_write_attr_t* event = g_new0(event_gatts_srvc_write_attr_t, 1);
1207
1208         memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1209
1210         event->attr_trans.attr_handle = attr_handle;
1211         event->attr_trans.conn_id = conn_id;
1212         event->attr_trans.trans_id = trans_id;
1213         event->attr_trans.offset = offset;
1214         event->need_rsp = need_rsp;
1215         event->is_prep = is_prep;
1216
1217         if (length > 0 && value != NULL) {
1218                 if (length > OAL_GATT_MAX_ATTR_LEN)
1219                         length = OAL_GATT_MAX_ATTR_LEN;
1220                 memcpy(event->value, value, length);
1221                 event->length = length;
1222         }
1223         send_event(OAL_EVENT_GATTS_REQUEST_WRITE, event, sizeof(event_gatts_srvc_write_attr_t));
1224 }
1225
1226 static void cb_gatts_response_confirmation(int status, int handle)
1227 {
1228         BT_INFO("BTGATT SERVER RESPONSE CONFIRMATION CB, status:%d, handle:%d", status, handle);
1229
1230         event_gatts_respons_t* event = g_new0(event_gatts_respons_t, 1);
1231
1232         event->hndl = handle;
1233         event->status = convert_to_oal_status(status);
1234
1235         send_event(OAL_EVENT_GATTS_RESPONSE_CONFIRMED, event, sizeof(event_gatts_respons_t));
1236 }
1237
1238 static void cb_indication_confirmation(int conn_id, int trans_id, int attr_handle, bt_bdaddr_t *bda)
1239 {
1240         BT_INFO("BTGATT SERVER Indication Confirmation CB, conn_id:%d, trans_id:%d attr_handle:%d",
1241                         conn_id, trans_id, attr_handle);
1242
1243         event_gatts_ind_cnfrm_t* event = g_new0(event_gatts_ind_cnfrm_t, 1);
1244
1245         memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1246
1247         event->attr_handle = attr_handle;
1248         event->conn_id = conn_id;
1249         event->trans_id = trans_id;
1250         send_event(OAL_EVENT_GATTS_IND_CONFIRM, event, sizeof(event_gatts_ind_cnfrm_t));
1251 }
1252
1253 static void cb_gatts_mtu_changed(int conn_id, int mtu)
1254 {
1255         BT_INFO("BTGATT SERVER MTU CHANGED CB, conn_id: %d, mtu_size: %d", conn_id, mtu);
1256         event_gatts_mtu_changed_t *event = g_new0(event_gatts_mtu_changed_t, 1);
1257         event->conn_id = conn_id;
1258         event->mtu_size = mtu;
1259         send_event(OAL_EVENT_GATTS_MTU_CHANGED, event, sizeof(event_gatts_mtu_changed_t));
1260 }
1261
1262 #ifdef TIZEN_BT_HAL
1263 static void cb_notifcation_changed(int conn_id, int trans_id, int attr_handle, bool notify,  bt_bdaddr_t *bda)
1264 {
1265         BT_INFO("BTGATT SERVER Notication CB, conn_id:%d, trans_id:%d attr_handle:%d Notify:%d",
1266                         conn_id, trans_id, attr_handle, notify);
1267
1268         event_gatts_notif_t* event = g_new0(event_gatts_notif_t, 1);
1269
1270         memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1271
1272         event->attr_handle = attr_handle;
1273         event->conn_id = conn_id;
1274         event->trans_id = trans_id;
1275         event->notify = notify;
1276         send_event(OAL_EVENT_GATTS_NOTIFICATION, event, sizeof(event_gatts_notif_t));
1277 }
1278 #endif
1279
1280
1281 /* GATT Server Callbacks: End */
1282 /************************************ GATT Client ***********************************/
1283 /* Client Callbacks */
1284 static void cb_gattc_register_app(int status, int clientIf, bt_uuid_t *app_uuid)
1285 {
1286         char uuid_str[BT_UUID_STRING_MAX];
1287         event_gattc_register_t *event;
1288
1289         /* Check if GATT client registered for Default GATT client UUID */
1290         uuid_to_string((service_uuid_t *)app_uuid, uuid_str);
1291         if (!strncasecmp(DEFAULT_GATT_CLIENT_UUID,
1292                                 uuid_str, strlen(DEFAULT_GATT_CLIENT_UUID))) {
1293                 default_client_id = clientIf;
1294                 switch (pending_gattc_req) {
1295                 case OAL_REQ_LE_SCAN:
1296                         if (0 != status) {
1297                                 default_client_id = -1;
1298                                 pending_gattc_req = OAL_REQ_NONE;
1299                                 BT_ERR("Default client app creation failed");
1300                                 send_event(OAL_EVENT_BLE_DISCOVERY_STOPPED, NULL, 0);
1301                                 break;
1302                         }
1303
1304                         if (OAL_STATUS_SUCCESS != gattc_start_le_discovery()) {
1305                                 BT_ERR("Error:Start LE Discovery failed");
1306                                 send_event(OAL_EVENT_BLE_DISCOVERY_STOPPED, NULL, 0);
1307                         }
1308                         break;
1309                 default:
1310                         BT_ERR("Unknown pending request: %d", pending_gattc_req);
1311                 }
1312
1313                 /* Return from here, no need to send GATTC_REGISTRATION event */
1314                 return;
1315         }
1316
1317         BT_INFO("BTGATT CLIENT REGISTER APP CB, status:%d, clientIf:%d", status, clientIf);
1318         event = g_new0(event_gattc_register_t, 1);
1319         event->client_if = clientIf;
1320         event->status = (status == 0 ? OAL_STATUS_SUCCESS : OAL_STATUS_INTERNAL_ERROR);
1321         memcpy(event->client_uuid.uuid, app_uuid->uu, sizeof(oal_uuid_t));
1322         send_event_no_trace(OAL_EVENT_GATTC_REGISTRATION, event, sizeof(event_gattc_register_t));
1323 }
1324
1325 static void cb_gattc_scan_result(bt_bdaddr_t* bdaddress, int rssi, uint8_t *adv_data)
1326 {
1327         event_ble_scan_result_info *event;
1328
1329         event = g_new0(event_ble_scan_result_info, 1);
1330         event->rssi = rssi;
1331         memcpy(event->address.addr, bdaddress->address, BT_ADDRESS_BYTES_NUM);
1332         memcpy(event->adv_data, adv_data, BLE_ADV_DATA_LENGTH);
1333         send_event_bda_trace(OAL_EVENT_BLE_REMOTE_DEVICE_FOUND, event,
1334                         sizeof(event_ble_scan_result_info), (bt_address_t *)bdaddress);
1335 }
1336
1337 /* Register default gatt client to be used in LE scan etc. */
1338 static oal_status_t __register_default_gatt_client(void)
1339 {
1340         bt_uuid_t uuid;
1341         int ret;
1342
1343         API_TRACE("GATT client register");
1344         CHECK_OAL_GATT_ENABLED();
1345
1346         if (default_client_id >= 0) {
1347                 BT_ERR("Client Already registered");
1348                 return OAL_STATUS_ALREADY_DONE;
1349         }
1350
1351         string_to_uuid(DEFAULT_GATT_CLIENT_UUID, (service_uuid_t *)&uuid);
1352         ret = gatt_api->client->register_client(&uuid);
1353         if (ret != BT_STATUS_SUCCESS) {
1354                 BT_ERR("GATT client register failed: %s", status2string(ret));
1355                 return convert_to_oal_status(ret);
1356         }
1357
1358         return OAL_STATUS_SUCCESS;
1359 }
1360
1361 oal_status_t gattc_start_le_discovery(void)
1362 {
1363         int ret;
1364
1365         API_TRACE("BTGATT CLIENT SCAN START");
1366         CHECK_OAL_GATT_ENABLED();
1367
1368         if (default_client_id < 0) {
1369                 if (pending_gattc_req != OAL_REQ_NONE) {
1370                         BT_ERR("Another request: %d already in progress", pending_gattc_req);
1371                         return OAL_STATUS_INTERNAL_ERROR;
1372                 }
1373
1374                 pending_gattc_req = OAL_REQ_LE_SCAN;
1375                 ret = __register_default_gatt_client();
1376                 if (OAL_STATUS_SUCCESS != ret) {
1377                         BT_ERR("__register_default_gatt_client failed");
1378                         pending_gattc_req = OAL_REQ_NONE;
1379                         return OAL_STATUS_INTERNAL_ERROR;
1380                 }
1381
1382                 return OAL_STATUS_SUCCESS;
1383         }
1384
1385         ret = gatt_api->client->scan(default_client_id, true);
1386         if (ret != BT_STATUS_SUCCESS) {
1387                 BT_ERR("Error:Start LE Discovery failed: %s", status2string(ret));
1388                 return convert_to_oal_status(ret);
1389         }
1390
1391         send_event(OAL_EVENT_BLE_DISCOVERY_STARTED, NULL, 0);
1392         return OAL_STATUS_SUCCESS;
1393 }
1394
1395 oal_status_t gattc_stop_le_discovery(void)
1396 {
1397         int ret;
1398
1399         API_TRACE("Scan is stopped");
1400         CHECK_OAL_GATT_ENABLED();
1401
1402         ret = gatt_api->client->scan(default_client_id, false);
1403         if (ret != BT_STATUS_SUCCESS) {
1404                 BT_ERR("Error:Stop LE Discovery failed: %s", status2string(ret));
1405                 return convert_to_oal_status(ret);
1406         }
1407
1408         send_event(OAL_EVENT_BLE_DISCOVERY_STOPPED, NULL, 0);
1409         return OAL_STATUS_SUCCESS;
1410 }
1411
1412 oal_status_t gattc_set_le_scan_param(int scan_type, int itv, int win)
1413 {
1414         int ret;
1415
1416         API_TRACE("Scan is stopped");
1417         CHECK_OAL_GATT_ENABLED();
1418
1419 #ifdef TIZEN_BT_HAL
1420         ret = gatt_api->client->set_scan_parameters(scan_type, itv, win);
1421         if (ret != BT_STATUS_SUCCESS) {
1422                 BT_ERR("Error:Set scan parameters failed: %s", status2string(ret));
1423                 return convert_to_oal_status(ret);
1424         }
1425 #else
1426         ret = gatt_api->client->set_scan_parameters(itv, win);
1427         if (ret != BT_STATUS_SUCCESS) {
1428                 BT_ERR("Error:Set scan parameters failed: %s", status2string(ret));
1429                 return convert_to_oal_status(ret);
1430         }
1431 #endif
1432
1433         return OAL_STATUS_SUCCESS;
1434 }
1435 /************************************ GATT Client ***********************************/