nimble/eatt: Collision mitigation handling

TBD

Author: szymon-czapracki

nimble/host/src/ble_eatt.c

@@ -34,16 +34,17 @@
 
 struct ble_eatt {
     SLIST_ENTRY(ble_eatt) next;
-    uint16_t conn_handle;
     struct ble_l2cap_chan *chan;
-    uint8_t chan_num;
     uint8_t used_channels;
+    uint16_t conn_handle;
+    bool collision_ctrl;
     uint8_t client_op;
+    uint8_t chan_num;
     uint8_t accept_chans;
 
     /* Packet transmit queue */
     STAILQ_HEAD(, os_mbuf_pkthdr) eatt_tx_q;
-
+    struct os_callout collision_co;
     struct ble_npl_event setup_ev;
     struct ble_npl_event wakeup_ev;
 
@@ -147,6 +148,7 @@ ble_eatt_used_channels(uint16_t conn_handle)
     struct ble_eatt *eatt;
     size_t used_channels = 0;
 
+
     SLIST_FOREACH(eatt, &g_ble_eatt_list, next) {
         if (eatt->conn_handle == conn_handle) {
             used_channels += eatt->used_channels;
@@ -199,6 +201,11 @@ ble_eatt_wakeup_cb(struct ble_npl_event *ev)
     }
 }
 
+static void
+ble_eatt_collision_ev(struct os_event *ev)
+{
+    BLE_EATT_LOG_DEBUG("eatt: Collision delay expired\n");
+}
 
 #if (MYNEWT_VAL(BLE_EATT_AUTO_CONNECT))
 void
@@ -232,7 +239,7 @@ ble_eatt_alloc(void)
     eatt->used_channels = 0;
 
     STAILQ_INIT(&eatt->eatt_tx_q);
-
+    os_callout_init(&eatt->collision_co, os_eventq_dflt_get(),
 #if (MYNEWT_VAL(BLE_EATT_AUTO_CONNECT))
     os_callout_init(&eatt->auto_conn_delay, os_eventq_dflt_get(),
                     ble_eatt_auto_conn_cb, NULL);
@@ -262,25 +269,49 @@ ble_eatt_l2cap_event_fn(struct ble_l2cap_event *event, void *arg)
 {
     struct ble_eatt *eatt = arg;
     struct ble_gap_conn_desc desc;
-    uint8_t free_channels;
     uint8_t opcode;
+    uint8_t free_channels;
+    uint8_t coll_delay;
+    uint8_t rand_part;
     int rc;
 
     switch (event->type) {
     case BLE_L2CAP_EVENT_COC_CONNECTED:
         eatt = ble_eatt_find_by_conn_handle(event->connect.conn_handle);
+
         BLE_EATT_LOG_DEBUG("eatt: Connected event | conn_handle: %d | scid: %d | dcid: %d\n",
                             event->connect.conn_handle, event->connect.chan->scid,
                             event->connect.chan->dcid);
 
+        if (event->connect.status == BLE_HS_ENOMEM && eatt->collision_ctrl) {
+            BLE_EATT_LOG_DEBUG("eatt: Connection collision\n");
+
+            rc = ble_gap_conn_find(event->connect.conn_handle, &desc);
+            assert(rc == 0);
+
+            rc = ble_hs_hci_rand(&rand_part, 1);
+            if (rc != 0) {
+                return rc;
+            }
+
+            coll_delay = (rand_part % 5) + 2 * (desc.conn_latency + 1) * desc.conn_itvl;
+
+            os_callout_reset(&eatt->collision_co, OS_TICKS_PER_SEC / 1000 * coll_delay);
+
+            return 0;
+        }
+
         if (event->connect.status) {
-            ble_eatt_free(eatt);
+            eatt->used_channels--;
             return 0;
         }
 
         eatt->chan = event->connect.chan;
         eatt->conn_handle =  event->connect.conn_handle;
 
+        /* Delete collision callout on successfull connection */
+        os_callout_stop(&eatt->collision_co);
+        eatt->collision_ctrl = false;
 
         /* Increase used channel number on connected event */
         eatt->used_channels++;
@@ -320,7 +351,7 @@ ble_eatt_l2cap_event_fn(struct ble_l2cap_event *event, void *arg)
 
             if (free_channels == 0) {
                 BLE_EATT_LOG_ERROR("eatt: Accept event | No free channel slots\n");
-                eatt->no_res_error = BLE_L2CAP_COC_ERR_NO_RESOURCES;
+                eatt->collision_ctrl = true;
                 return BLE_HS_ENOMEM;
             }
         }
@@ -659,9 +690,16 @@ ble_eatt_connect(uint16_t conn_handle, uint8_t chan_num)
     }
 
     /*
-     * Warn about exceeding the number
-     * of maximum per-conn EATT connections.
+     * 5.3 Vol 3, Part G, Sec. 5.4 L2CAP collision mitigation
+     * Peripheral shall wait some time before retrying connection.
+     * Central may reconnect without any delay.
+     * To reconnect user has to call ble_eatt_connect again.
      */
+    if (desc.role == BLE_GAP_ROLE_SLAVE && os_callout_queued(&eatt->collision_co)) {
+            BLE_EATT_LOG_WARN("ble_eatt_connect: Connection collision\n");
+            return;
+    }
+
     if (chan_num == 0 || chan_num > MYNEWT_VAL(BLE_EATT_CHAN_PER_CONN)) {
         BLE_EATT_LOG_WARN("ble_eatt_connect | Invalid channel number\n");
         return;