Modified the logic of advertisement slot allocation

Change-Id: I38dadcce61ea91cc83a0e5cac521d7dc0d71720a
Signed-off-by: Amit Purwar <amit.purwar@samsung.com>

diff --git a/bt-oal/bluez_hal/src/bt-hal-adapter-le.c b/bt-oal/bluez_hal/src/bt-hal-adapter-le.c
index 1384adf..152bca5 100644 (file)
--- a/bt-oal/bluez_hal/src/bt-hal-adapter-le.c
+++ b/bt-oal/bluez_hal/src/bt-hal-adapter-le.c
@@ -188,24 +188,34 @@ gboolean _bt_hal_is_advertising_in_slot(int slot)
 
 void _bt_hal_set_advertising_status(int slot_id, gboolean mode)
 {
-
-       DBG("Advertising enabled [%s] slot [%d]",  mode ? "TRUE" : "FALSE", slot_id);
+       DBG("Advertising enabled [%s] server_slot [%d]",  mode ? "TRUE" : "FALSE", slot_id);
        bt_hal_adv_event_data_t *event;
+       int adv_slot_id = -1;
 
        if (le_adv_slot == NULL)
                return;
 
-       le_adv_slot[slot_id].is_advertising = mode;
+       adv_slot_id = bt_hal_gatts_get_adv_slot_id(slot_id);
+       if (adv_slot_id < 0)
+               return;
+
+       le_adv_slot[adv_slot_id].is_advertising = mode;
 
        event = g_malloc0(sizeof(bt_hal_adv_event_data_t));
        event->event = mode ? BT_HAL_MULTI_ADV_ENB_EVT : BT_HAL_MULTI_ADV_DISABLE_EVT;
        event->server_if = slot_id;
        event->status = BT_STATUS_SUCCESS;
        /* To be removed later when we completely descope Legacy Adv concept */
-       DBG("Is multi ? [%d]", le_adv_slot[slot_id].is_multi_adv);
-       if (le_adv_slot[slot_id].is_multi_adv == FALSE)
+
+       DBG("adv_slot_id[%d] Is multi ? [%d]", adv_slot_id, le_adv_slot[adv_slot_id].is_multi_adv);
+       if (le_adv_slot[adv_slot_id].is_multi_adv == FALSE)
                event->event = BT_HAL_LEGACY_ADV_STATUS;
 
+       if (mode == false ) {
+               DBG("release the adv_slot");
+               bt_hal_gatts_release_adv_slot(slot_id);
+       }
+
        __bt_hal_adv_event_cb((gpointer)event);
 }
 
@@ -243,6 +253,7 @@ gboolean _bt_hal_update_le_feature_support(const char *item, const char *value,
                int slot_num;
 
                slot_num = atoi(value);
+               INFO("slot_num:[%d]", slot_num);
                if (slot_num < 0) {
                        ERR("ERR:Advertising MAX instance [%d]", slot_num);
                        return FALSE;
@@ -254,6 +265,8 @@ gboolean _bt_hal_update_le_feature_support(const char *item, const char *value,
                        INFO("Advertising instance max : %d", le_feature_info.adv_inst_max);
                        le_adv_slot = g_malloc0(sizeof(bt_adapter_le_adv_slot_t) * le_feature_info.adv_inst_max);
                }
+
+               INFO("Advertising instance max: [%d]", le_feature_info.adv_inst_max);
                /* Fill LE feature bytes */
                le_features->max_adv_instance = atoi(value);
 
@@ -586,7 +599,7 @@ static gboolean __bt_hal_adv_event_cb(gpointer param)
        return FALSE;
 }
 
-int _bt_hal_enable_advertising(int server_if, bool enable, bool is_multi_adv)
+int _bt_hal_enable_advertising(int server_if, int adv_slot_id, bool enable, bool is_multi_adv)
 {
        DBG("+");
        GError *error = NULL;
@@ -597,17 +610,17 @@ int _bt_hal_enable_advertising(int server_if, bool enable, bool is_multi_adv)
        if (proxy == NULL)
                return BT_STATUS_FAIL;
 
-       if (le_adv_slot[server_if].is_advertising == TRUE && enable == TRUE)
+       if (le_adv_slot[adv_slot_id].is_advertising == TRUE && enable == TRUE)
                return BT_STATUS_BUSY;
 
-       if (le_adv_slot[server_if].initialized == TRUE &&
-                       le_adv_slot[server_if].is_advertising == FALSE &&
+       if (le_adv_slot[adv_slot_id].initialized == TRUE &&
+                       le_adv_slot[adv_slot_id].is_advertising == FALSE &&
                        enable == FALSE)
                return BT_STATUS_DONE;
 
-       if (le_adv_slot[server_if].hold_timer_id > 0) {
-               g_source_remove(le_adv_slot[server_if].hold_timer_id);
-               le_adv_slot[server_if].hold_timer_id = 0;
+       if (le_adv_slot[adv_slot_id].hold_timer_id > 0) {
+               g_source_remove(le_adv_slot[adv_slot_id].hold_timer_id);
+               le_adv_slot[adv_slot_id].hold_timer_id = 0;
        }
 
        ret = g_dbus_proxy_call_sync(proxy, "SetAdvertising",
@@ -623,12 +636,13 @@ int _bt_hal_enable_advertising(int server_if, bool enable, bool is_multi_adv)
                return BT_STATUS_FAIL;
        }
 
-       INFO("Enable advertising [%d] SLot Id [%d] Is Multi? [%d]", enable, server_if, is_multi_adv);
+       INFO("Enable advertising [%d] SLot Id [%d] gatt_server [%d] Is Multi? [%d]",
+                               enable, adv_slot_id, server_if, is_multi_adv);
        if (ret)
                g_variant_unref(ret);
 
-       le_adv_slot[server_if].is_multi_adv = is_multi_adv;
-       le_adv_slot[server_if].is_advertising = enable;
+       le_adv_slot[adv_slot_id].is_multi_adv = is_multi_adv;
+       le_adv_slot[adv_slot_id].is_advertising = enable;
        return BT_STATUS_SUCCESS;
 }
 

diff --git a/bt-oal/bluez_hal/src/bt-hal-adapter-le.h b/bt-oal/bluez_hal/src/bt-hal-adapter-le.h
index d8123cc..d20e475 100644 (file)
--- a/bt-oal/bluez_hal/src/bt-hal-adapter-le.h
+++ b/bt-oal/bluez_hal/src/bt-hal-adapter-le.h
@@ -68,7 +68,7 @@ int _bt_hal_set_advertising_params(int server_if, int min_interval,
                int max_interval, int adv_type,
                int chnl_map, int tx_power, int timeout_s);
 
-int _bt_hal_enable_advertising(int server_if, bool enable, bool is_multi_adv);
+int _bt_hal_enable_advertising(int server_if, int adv_slot_id, bool enable, bool is_multi_adv);
 
 int _bt_hal_adapter_le_start_scan(void);
 

diff --git a/bt-oal/bluez_hal/src/bt-hal-event-receiver.c b/bt-oal/bluez_hal/src/bt-hal-event-receiver.c
index 49b4ed4..9247eb8 100644 (file)
--- a/bt-oal/bluez_hal/src/bt-hal-event-receiver.c
+++ b/bt-oal/bluez_hal/src/bt-hal-event-receiver.c
@@ -539,7 +539,7 @@ void _bt_hal_handle_adapter_event(GVariant *msg, const char *member)
                int slot_id;
                gboolean status = FALSE;
                g_variant_get(msg, "(ib)", &slot_id, &status);
-               DBG("Advertising Enabled : slot_id [%d]  status [%d]", slot_id, status);
+               DBG("Advertising Enabled : server_slot_id [%d]  status [%d]", slot_id, status);
                /* Send event to application */
                _bt_hal_set_advertising_status(slot_id, status);
        } else if (strcasecmp(member, "RssiEnabled") == 0) {

diff --git a/bt-oal/bluez_hal/src/bt-hal-gatt-client.c b/bt-oal/bluez_hal/src/bt-hal-gatt-client.c
index 6895eb0..ed4442d 100644 (file)
--- a/bt-oal/bluez_hal/src/bt-hal-gatt-client.c
+++ b/bt-oal/bluez_hal/src/bt-hal-gatt-client.c
@@ -2997,7 +2997,7 @@ static bt_status_t _bt_hold_current_advertising()
        if (is_advertising) {
                DBG("+ Stop current advertising");
 
-               ret = _bt_hal_enable_advertising(0, FALSE, FALSE);
+               ret = _bt_hal_enable_advertising(0, 0, FALSE, FALSE);
                g_timeout_add(2000, __bt_hold_current_advertising_timeout_cb, NULL);
        }
 
@@ -3008,7 +3008,7 @@ static gboolean __bt_hold_current_advertising_timeout_cb(gpointer user_data)
 {
        DBG("+ start current advertising");
 
-       _bt_hal_enable_advertising(0, TRUE, FALSE);
+       _bt_hal_enable_advertising(0, 0, TRUE, FALSE);
 
        return FALSE;
 }

diff --git a/bt-oal/bluez_hal/src/bt-hal-gatt-server.c b/bt-oal/bluez_hal/src/bt-hal-gatt-server.c
index 4f10851..4b9e2cc 100644 (file)
--- a/bt-oal/bluez_hal/src/bt-hal-gatt-server.c
+++ b/bt-oal/bluez_hal/src/bt-hal-gatt-server.c
@@ -186,6 +186,17 @@ typedef struct {
        bt_uuid_t uuid;
 } hal_gatt_desc_added;
 
+
+struct hal_gatts_server_register_info_t {
+       int server_if;
+       int adv_slot_id;
+       bt_uuid_t app_uuid;
+};
+
+static GSList * hal_gatts_server_register_list;
+
+static int g_server_inst_id = 0;
+
 #define CHECK_BTGATT_INIT() if (bt_gatt_callbacks == NULL)\
 {\
        ERR("%s: BTGATT not initialized", __FUNCTION__);\
@@ -207,6 +218,8 @@ static void __bt_hal_unregister_application_cb(GObject *object, GAsyncResult *re
 static GDBusProxy *__bt_gatt_gdbus_get_gatt_manager_proxy(const gchar *service,
                const gchar *path, const gchar *interface);
 
+static int bt_hal_gatts_get_gatt_server_instance();
+
 /* Introspection data for the service we are exporting */
 static const gchar service_introspection_xml[] =
 "<node name='/'>"
@@ -467,12 +480,14 @@ void _bt_hal_gatt_connected_state_event(gboolean is_connected, char *address)
        memset(&ev, 0, sizeof(ev));
 
        /* Find Server Instance */
-       _bt_hal_get_gatt_server_instance_initialized(&instance);
+       instance = bt_hal_gatts_get_gatt_server_instance();
        if (instance == -1) {
                ERR("Not even a single GATT server is registered");
                return;
        }
 
+       DBG("server instance [%d]", instance);
+
        /* Convert address to hex */
        _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
 
@@ -1735,25 +1750,111 @@ static gboolean __bt_hal_register_slot_id_cb(gpointer user_data)
        return FALSE;
 }
 
+
+static int bt_hal_gatts_get_gatt_server_instance()
+{
+       DBG("+");
+
+       GSList *l;
+       struct hal_gatts_server_register_info_t *info = NULL;
+
+       for (l = hal_gatts_server_register_list; l != NULL; l = g_slist_next(l)) {
+               info = (struct hal_gatts_server_register_info_t *)l->data;
+               if (info == NULL) {
+                       continue;
+               }
+
+               return info->server_if;
+       }
+
+       return -1;
+}
+
+int bt_hal_gatts_generate_server_id()
+{
+       return ++g_server_inst_id;
+}
+
+static struct hal_gatts_server_register_info_t * bt_hal_gatts_find_server_register_info_from_uuid(bt_uuid_t *app_uuid)
+{
+       DBG("+");
+
+       GSList *l;
+       struct hal_gatts_server_register_info_t *info = NULL;
+
+       for (l = hal_gatts_server_register_list; l != NULL; l = g_slist_next(l)) {
+               info = (struct hal_gatts_server_register_info_t *)l->data;
+               if (info == NULL) {
+                       continue;
+               }
+
+               if (memcmp(&info->app_uuid, app_uuid, sizeof(bt_uuid_t)) == 0) {
+                       DBG("gatt server register found");
+                       return info;
+               }
+       }
+
+       return NULL;
+}
+
+static struct hal_gatts_server_register_info_t * bt_hal_gatts_find_server_register_info(int server_if)
+{
+       DBG("+");
+
+       GSList *l;
+       struct hal_gatts_server_register_info_t *info = NULL;
+
+       for (l = hal_gatts_server_register_list; l != NULL; l = g_slist_next(l)) {
+               info = (struct hal_gatts_server_register_info_t *)l->data;
+               if (info == NULL) {
+                       continue;
+               }
+
+               if (info->server_if == server_if) {
+                       DBG("gatt server register found");
+                       return info;
+               }
+       }
+
+       return NULL;
+}
+
+static struct hal_gatts_server_register_info_t * bt_hal_gatts_add_server_app(bt_uuid_t *app_uuid)
+{
+       DBG("+");
+
+       struct hal_gatts_server_register_info_t * server_register_info = NULL;
+
+       server_register_info = bt_hal_gatts_find_server_register_info_from_uuid(app_uuid);
+       if (server_register_info != NULL) {
+               DBG("gatt server is already registered");
+               return server_register_info;
+       }
+
+       DBG("adding the gatt server app");
+
+       server_register_info = g_malloc0(sizeof(struct hal_gatts_server_register_info_t));
+       server_register_info->server_if = bt_hal_gatts_generate_server_id();
+
+       DBG("amit server_if:[%d]", server_register_info->server_if);
+
+       server_register_info->adv_slot_id = -1;
+       memcpy(&server_register_info->app_uuid, app_uuid, sizeof(bt_uuid_t));
+       hal_gatts_server_register_list = g_slist_append(hal_gatts_server_register_list, server_register_info);
+
+       return server_register_info;
+}
+
 static bt_status_t gatt_server_register_app(bt_uuid_t *uuid)
 {
        CHECK_BTGATT_INIT();
-       int status = BT_STATUS_FAIL;
-       int server_if;
+       struct hal_gatts_server_register_info_t *server_register_info = NULL;
+
        DBG("Register server instance request");
        hal_register_server_data *user_data = g_malloc0(sizeof(hal_register_server_data));
 
-       /* Check if slot available */
-       server_if = _bt_hal_get_available_adv_slot_id(uuid, FALSE);
-
-       if (server_if == -1) {
-               ERR("Allocation of server instance failed");
-               g_free(user_data);
-               return status;
-       } else {
-               user_data->instance_data = server_if;
-               DBG("Allocated new Advertising slot with Stack [%d]", user_data->instance_data);
-       }
+       server_register_info = bt_hal_gatts_add_server_app(uuid);
+       user_data->instance_data = server_register_info->server_if;
 
        /*
         * As we need to provide async callback to user from HAL, simply schedule a
@@ -1807,9 +1908,18 @@ static bt_status_t gatt_server_unregister_app(int server_if)
 {
        CHECK_BTGATT_INIT();
        DBG("Un-Register server instance request [%d]", server_if);
+       struct hal_gatts_server_register_info_t *server_register_info = NULL;
+
 
-       if (_bt_hal_is_advertising_in_slot(server_if) == FALSE)
-               _bt_hal_free_server_slot(server_if);
+       server_register_info =  bt_hal_gatts_find_server_register_info(server_if);
+       if (server_register_info == NULL) {
+               DBG("gatt server is not registered");
+               return BT_STATUS_SUCCESS;
+       }
+
+       /* remove the gatt server register info from the register list */
+       hal_gatts_server_register_list = g_slist_remove(hal_gatts_server_register_list, server_register_info);
+       g_free(server_register_info);
 
        /* If server_if belongs to a GATT Server, then delete the GATT server from List */
        _bt_hal_remove_gatt_server_from_list(server_if);
@@ -3264,8 +3374,26 @@ static bt_status_t gatt_server_update_att_value(int server_if, int attribute_han
 static bt_status_t gatt_server_listen(int server_if, bool start)
 {
        CHECK_BTGATT_INIT();
+
+       struct hal_gatts_server_register_info_t *server_register_info = NULL;
+
+       DBG("server_if: [%d]", server_if);
+
+       server_register_info =  bt_hal_gatts_find_server_register_info(server_if);
+       if (server_register_info == NULL) {
+               DBG("gatt server is not registered");
+               return BT_STATUS_FAIL;
+       }
+
+       DBG("gatt server:[%d], adv_slot:[%d]", server_register_info->server_if, server_register_info->adv_slot_id);
+
+       if (server_register_info->adv_slot_id < 0 ) {
+               DBG("adv_slot is not assigned to server:[%d] \n", server_if);
+               return BT_STATUS_FAIL;
+       }
+
        /* Send Data to LE Module */
-       return _bt_hal_enable_advertising(server_if, start, FALSE);
+       return _bt_hal_enable_advertising(server_if, server_register_info->adv_slot_id, start, FALSE);
 }
 
 static bt_status_t gatt_server_set_adv_data(int server_if, bool set_scan_rsp, bool include_name,
@@ -3278,11 +3406,95 @@ static bt_status_t gatt_server_set_adv_data(int server_if, bool set_scan_rsp, bo
        return BT_STATUS_SUCCESS;
 }
 
+static int bt_hal_gatts_allocate_adv_slot(struct hal_gatts_server_register_info_t *server_register_info)
+{
+       int adv_slot_id = -1;
+
+       DBG("gatt server:[%d], adv_slot:[%d]", server_register_info->server_if, server_register_info->adv_slot_id);
+
+       /* allocate adv slot for gatt server if not assigned */
+       if (server_register_info->adv_slot_id < 0 ) {
+               adv_slot_id = _bt_hal_get_available_adv_slot_id(&server_register_info->app_uuid, FALSE);
+               if (adv_slot_id < 0) {
+                       DBG("failed to get the adv_slot \n");
+                       return -1;
+               }
+
+               server_register_info->adv_slot_id = adv_slot_id;
+       }
+
+       DBG("gatt server is assigned with adv_slot [%d]", server_register_info->adv_slot_id);
+
+       return 0;
+}
+
+void bt_hal_gatts_release_adv_slot(int server_if)
+{
+       struct hal_gatts_server_register_info_t *server_register_info = NULL;
+
+       server_register_info =  bt_hal_gatts_find_server_register_info(server_if);
+       if (server_register_info == NULL) {
+               DBG("failed to get server_register_info");
+               return;
+       }
+
+       DBG("gatt server:[%d], adv_slot:[%d]", server_register_info->server_if, server_register_info->adv_slot_id);
+
+       if (server_register_info->adv_slot_id < 0) {
+               DBG("adv_slot is not allocated");
+               return;
+       }
+
+       if(_bt_hal_is_advertising_in_slot(server_register_info->adv_slot_id) == FALSE) {
+               DBG("advertising is disabled");
+               _bt_hal_free_server_slot(server_register_info->adv_slot_id);
+               server_register_info->adv_slot_id = -1;
+       }
+}
+
+int bt_hal_gatts_get_adv_slot_id(int server_if)
+{
+       struct hal_gatts_server_register_info_t *server_register_info = NULL;
+
+       server_register_info =  bt_hal_gatts_find_server_register_info(server_if);
+       if (server_register_info == NULL) {
+               DBG("failed to get server_register_info");
+               return -1;
+       }
+
+       return server_register_info->adv_slot_id;
+}
+
 static bt_status_t gatt_server_multi_adv_enable(int server_if)
 {
        CHECK_BTGATT_INIT();
+
+       int ret = -1;
+
+       struct hal_gatts_server_register_info_t *server_register_info = NULL;
+
+       DBG("server_if: [%d]", server_if);
+
+       server_register_info =  bt_hal_gatts_find_server_register_info(server_if);
+       if (server_register_info == NULL) {
+               DBG("gatt server is not registered");
+               return BT_STATUS_FAIL;
+       }
+
+       DBG("gatt server:[%d], adv_slot:[%d]", server_register_info->server_if, server_register_info->adv_slot_id);
+
+       if (server_register_info->adv_slot_id < 0 ) {
+               DBG("adv_slot is not assigned to server:[%d] \n", server_if);
+
+               ret = bt_hal_gatts_allocate_adv_slot(server_register_info);
+               if (ret < 0) {
+                       DBG("failed to get adv_slot");
+                       return BT_STATUS_FAIL;
+               }
+       }
+
        /* Send Enable Advertising request to LE Module */
-       return _bt_hal_enable_advertising(server_if, TRUE, TRUE);
+       return _bt_hal_enable_advertising(server_if, server_register_info->adv_slot_id, TRUE, TRUE);
 }
 
 static bt_status_t gatt_server_multi_adv_update(int server_if, int min_interval, int max_interval, int adv_type,
@@ -3295,6 +3507,7 @@ static bt_status_t gatt_server_multi_adv_update(int server_if, int min_interval,
                        chnl_map, tx_power, timeout_s);
 }
 
+
 static bt_status_t gatt_server_multi_adv_set_inst_data(btgatt_adv_param_setup_t adv_param_setup)
 {
        CHECK_BTGATT_INIT();
@@ -3306,8 +3519,26 @@ static bt_status_t gatt_server_multi_adv_set_inst_data(btgatt_adv_param_setup_t
 static bt_status_t gatt_server_multi_adv_disable(int server_if)
 {
        CHECK_BTGATT_INIT();
+
+       struct hal_gatts_server_register_info_t *server_register_info = NULL;
+
+       DBG("server_if: [%d]", server_if);
+
+       server_register_info =  bt_hal_gatts_find_server_register_info(server_if);
+       if (server_register_info == NULL) {
+               DBG("gatt server is not registered");
+               return BT_STATUS_FAIL;
+       }
+
+       DBG("gatt server:[%d], adv_slot:[%d]", server_register_info->server_if, server_register_info->adv_slot_id);
+
+       if (server_register_info->adv_slot_id < 0 ) {
+               DBG("adv_slot is not assigned to server:[%d] \n", server_if);
+               return BT_STATUS_FAIL;
+       }
+
        /* Send Data to LE Module */
-       return _bt_hal_enable_advertising(server_if, FALSE, TRUE);
+       return _bt_hal_enable_advertising(server_if, server_register_info->adv_slot_id, FALSE, TRUE);
 }
 
 static bt_status_t gatt_server_get_mtu_size(int conn_id, int *mtu_size)

diff --git a/bt-oal/bluez_hal/src/bt-hal-gatt-server.h b/bt-oal/bluez_hal/src/bt-hal-gatt-server.h
index 2422b78..c340fdc 100644 (file)
--- a/bt-oal/bluez_hal/src/bt-hal-gatt-server.h
+++ b/bt-oal/bluez_hal/src/bt-hal-gatt-server.h
@@ -43,6 +43,10 @@ void _bt_hal_gatt_connected_state_event(gboolean is_connected, char *address);
 
 handle_stack_msg _bt_hal_get_gatt_event(void);
 
+int bt_hal_gatts_get_adv_slot_id(int server_if);
+
+void bt_hal_gatts_release_adv_slot(int server_if);
+
 int _bt_get_remote_gatt_client_conn_id(char *address);
 
 #ifdef __cplusplus

diff --git a/bt-oal/oal-gatt.c b/bt-oal/oal-gatt.c
index 6d5d203..61c9e09 100644 (file)
--- a/bt-oal/oal-gatt.c
+++ b/bt-oal/oal-gatt.c
@@ -192,7 +192,7 @@ static const btgatt_server_callbacks_t btgatt_server_callbacks = {
        .notif_enabled_cb = cb_notifcation_changed,
 #endif
        .request_acquire_write_cb = cb_gatts_acquire_write,
-       .request_acquire_notify_cb = cb_gatts_acquire_notify,
+       .request_acquire_notify_cb = cb_gatts_acquire_notify
 };
 
 /* Forward declaration for GATT client callbacks */
@@ -1230,8 +1230,7 @@ static void cb_gatts_connection(int conn_id, int server_if, int connected, bt_bd
        event_gatts_conn_t *event = g_new0(event_gatts_conn_t, 1);
 
        for (ins_id = 1 ; ins_id <= NUM_SERVER_INST ; ins_id++) {
-               if ((gatt_servers[ins_id - 1].server_id == server_if) &&
-                               (gatt_servers[ins_id - 1].state == GATT_INS_ENABLED)) {
+               if ((gatt_servers[ins_id - 1].server_id == server_if)) {
                        event->server_inst = ins_id;
                        break;
                } else {