card10-cross.ini

@@ -6,7 +6,7 @@ strip = 'arm-none-eabi-strip'
 [properties]
 c_args      = ['-mthumb', '-mcpu=cortex-m4', '-mfloat-abi=softfp', '-mfpu=fpv4-sp-d16', '-Wa,-mimplicit-it=thumb', '-ffunction-sections', '-fdata-sections', '-fsingle-precision-constant', '-fno-isolate-erroneous-paths-dereference']
 
-c_link_args = ['-mthumb', '-mcpu=cortex-m4', '-mfloat-abi=softfp', '-mfpu=fpv4-sp-d16', '-Wl,--start-group', '-lc', '-lnosys', '-Wl,--end-group', '--specs=nano.specs']
+c_link_args = ['-mthumb', '-mcpu=cortex-m4', '-mfloat-abi=softfp', '-mfpu=fpv4-sp-d16', '-Wl,--start-group', '-lc', '-lnosys', '-Wl,--end-group', '--specs=nano.specs', '-Wl,-wrap,BbBleDrvRand']
 
 target_defs = ['-DTARGET=32665', '-DTARGET_REV=0x4131', '-DBOARD_CARD10=1']
 

demos/ble-ws2812-card10.py

+import ws2812, gpio, bluetooth, time, display
+from micropython import const
+
+_IRQ_GATTS_WRITE = const(3)
+
+WS2812_SERVICE_UUID = \
+    bluetooth.UUID("23238000-2342-2342-2342-234223422342")
+SET_ALL = (
+    bluetooth.UUID("23238001-2342-2342-2342-234223422342"),
+    bluetooth.FLAG_WRITE
+)
+WS2812_SERVICE = (
+    WS2812_SERVICE_UUID,
+    (SET_ALL,)
+)
+
+def irq(event, data):
+    if event == _IRQ_GATTS_WRITE:
+        conn_handle, value_handle = data
+        value = ble.gatts_read(value_handle)
+        ws2812.set_all(gpio.WRISTBAND_3, [value] * 3)
+
+if __name__ == "__main__":
+    display.open().backlight(0)
+    gpio.set_mode(gpio.WRISTBAND_3, gpio.mode.OUTPUT)
+
+    ble = bluetooth.BLE()
+    ble.active(True)
+    ble.irq(irq)
+    ble.gatts_register_services((WS2812_SERVICE,))
+
+    print("Waiting for connection!")
+
+    while True:
+        time.sleep(1)

demos/ble-ws2812-host.py

+#!/usr/bin/env python3
+import bluepy
+import time
+import colorsys
+
+
+# Change this to the MAC of your card10
+p = bluepy.btle.Peripheral("CA:4D:10:01:ff:64")
+c = p.getCharacteristics(
+    uuid='23238001-2342-2342-2342-234223422342')[0]
+
+hue = 0
+while 1:
+    r,g,b = colorsys.hsv_to_rgb(hue, 1, 0.1)
+    c.write(b"%c%c%c" %
+        (int(r*255), int(g*255), int(b*255)), True)
+    time.sleep(.1)
+    hue += 0.1
+

docker/Dockerfile_fwbuild

+FROM ubuntu
+
+RUN apt-get update && apt-get -y install gcc-arm-none-eabi binutils-arm-none-eabi libnewlib-arm-none-eabi python3 python3-pip ninja-build git
+
+RUN pip3 install meson crc16 pillow
+
+VOLUME /firmware
+WORKDIR /firmware
+
+CMD ./bootstrap.sh && ninja -C build && chown -R --reference=/firmware build

docker/deploy-env/Dockerfile

-FROM ubuntu:bionic
+FROM ubuntu:focal
 
 RUN set -e -x ;\
     export DEBIAN_FRONTEND=noninteractive ;\
@@ -10,7 +10,7 @@ RUN set -e -x ;\
         llvm \
         python3-pip ;\
     pip3 install \
-        clang \
+        clang==10.0.1 \
         sphinx \
         sphinx_rtd_theme ;\
     rm -rf /var/lib/apt/lists

epicardium/api/caller.c

@@ -5,8 +5,17 @@
 #define MXC_ASSERT_ENABLE
 #include "mxc_assert.h"
 
+static uint32_t irq_save = 0;
+
 void *_api_call_start(api_id_t id, uintptr_t size)
 {
+	/*
+	 * Disable all maskable interrupts here, to be turned on again at the
+	 * end of _api_call_transact().
+	 */
+	irq_save = __get_PRIMASK();
+	__set_PRIMASK(1);
+
 	while (SEMA_GetSema(_API_SEMAPHORE) == E_BUSY) {
 	}
 
@@ -51,6 +60,12 @@ void *_api_call_transact(void *buffer)
 	API_CALL_MEM->call_flag = _API_FLAG_IDLE;
 	SEMA_FreeSema(_API_SEMAPHORE);
 
+	/*
+	 * Re-enable interrupts (if previously enabled) after completing the API
+	 * call.
+	 */
+	__set_PRIMASK(irq_save);
+
 	return API_CALL_MEM->buffer;
 }
 

epicardium/api/control.c

 #include "epicardium.h"
 #include "api/dispatcher.h"
-#include "api/interrupt-sender.h"
-#include "modules/log.h"
 
 #include "card10.h"
 
@@ -10,6 +8,7 @@
 #include "tmr.h"
 
 static void __core1_init(void);
+extern void interrupt_trigger_sync(api_int_id_t id);
 
 struct core1_info {
 	/* Location of core1's interrupt vector table */
@@ -206,27 +205,41 @@ void core1_boot(void)
 
 void core1_trigger_reset(void)
 {
-	/* Signal core 1 that we intend to load a new payload. */
-	api_interrupt_trigger(EPIC_INT_RESET);
+	/*
+	 * Signal core 1 that we intend to load a new payload.
+	 *
+	 * This needs to be synchroneous because otherwise we will deadlock
+	 * (Lifecycle task busy-spins and interrupt can never get dispatched).
+	 */
+	interrupt_trigger_sync(EPIC_INT_RESET);
+}
+
+bool core1_is_ready(void)
+{
+	bool ready;
+
+	while (SEMA_GetSema(_CONTROL_SEMAPHORE) == E_BUSY) {
+	}
+
+	/*
+	 * core 1 will set the ready flag once it is spinning in the
+	 * above loop, waiting for a new IVT.
+	 */
+	ready = core1_info.ready;
+
+	SEMA_FreeSema(_CONTROL_SEMAPHORE);
+
+	return ready;
 }
 
 void core1_wait_ready(void)
 {
 	/* Wait for the core to accept */
 	while (1) {
-		while (SEMA_GetSema(_CONTROL_SEMAPHORE) == E_BUSY) {
-		}
-
-		/*
-		 * core 1 will set the ready flag once it is spinning in the
-		 * above loop, waiting for a new IVT.
-		 */
-		if (core1_info.ready) {
+		if (core1_is_ready()) {
 			break;
 		}
 
-		SEMA_FreeSema(_CONTROL_SEMAPHORE);
-
 		for (int i = 0; i < 10000; i++) {
 		}
 	}
@@ -240,6 +253,9 @@ void core1_wait_ready(void)
 
 void core1_load(void *ivt, char *args)
 {
+	while (SEMA_GetSema(_CONTROL_SEMAPHORE) == E_BUSY) {
+	}
+
 	/* If the core is currently in an API call, reset it. */
 	API_CALL_MEM->call_flag = _API_FLAG_IDLE;
 	API_CALL_MEM->id        = 0;

epicardium/api/dispatcher.c

@@ -9,7 +9,7 @@
 /* This function is defined by the generated dispatcher code */
 void __api_dispatch_call(api_id_t id, void *buffer);
 
-static volatile bool event_ready = false;
+static volatile bool call_pending = false;
 
 int api_dispatcher_init()
 {
@@ -34,7 +34,7 @@ int api_dispatcher_init()
 
 bool api_dispatcher_poll_once()
 {
-	if (event_ready) {
+	if (call_pending) {
 		return false;
 	}
 
@@ -46,22 +46,27 @@ bool api_dispatcher_poll_once()
 		return false;
 	}
 
-	event_ready = true;
+	call_pending = true;
 	return true;
 }
 
 bool api_dispatcher_poll()
 {
-	if (event_ready) {
+	if (call_pending) {
 		return true;
 	}
 
 	return api_dispatcher_poll_once();
 }
 
+bool api_dispatcher_call_pending()
+{
+	return call_pending;
+}
+
 api_id_t api_dispatcher_exec()
 {
-	if (!event_ready) {
+	if (!call_pending) {
 		return 0;
 	}
 
@@ -69,7 +74,7 @@ api_id_t api_dispatcher_exec()
 	__api_dispatch_call(id, API_CALL_MEM->buffer);
 	API_CALL_MEM->call_flag = _API_FLAG_RETURNED;
 
-	event_ready = false;
+	call_pending = false;
 	SEMA_FreeSema(_API_SEMAPHORE);
 
 	/* Notify the caller that we returned */

epicardium/api/dispatcher.h

@@ -15,6 +15,12 @@ int api_dispatcher_init();
 bool api_dispatcher_poll_once();
 bool api_dispatcher_poll();
 
+/*
+ * Check if the other core requested a call or if we are already excuting it.
+ * Only returns a cached version, without acquiring any locks.
+ */
+bool api_dispatcher_call_pending();
+
 /*
  * Attempt to dispatch a call, if one had been polled using
  * api_dispatcher_poll().  Will return 0 if no call was dispatched or the ID of
@@ -39,6 +45,9 @@ void core1_boot(void);
 /* Reset core 1 into a state where it can accept a new payload */
 void core1_trigger_reset(void);
 
+/* Check if core 1 is ready for a new payload */
+bool core1_is_ready(void);
+
 /* Wait for core 1 to respond that it is ready for a new payload */
 void core1_wait_ready(void);
 

epicardium/api/genapi.py

@@ -246,7 +246,7 @@ void __dispatch_isr(api_int_id_t id)
     # Generate Dispatcher {{{
     with open(args.server, "w") as f_dispatcher:
         tmp = """\
-#include "modules/log.h"
+#include "os/core.h"
 #include "{header}"
 
 void __api_dispatch_call(uint32_t id, void*epc__apistub_buffer)

epicardium/api/interrupt-sender.c

 #include "api/interrupt-sender.h"
 #include "api/common.h"
 #include "tmr_utils.h"
-
-static bool int_enabled[EPIC_INT_NUM];
-
-int api_interrupt_trigger(api_int_id_t id)
-{
-	if (id >= EPIC_INT_NUM) {
-		return -EINVAL;
-	}
-
-	if (int_enabled[id]) {
-		while (API_CALL_MEM->int_id != (api_int_id_t)(-1))
-			;
-
-		API_CALL_MEM->int_id = id;
-		TMR_TO_Start(MXC_TMR5, 1, 0);
-	}
-	return 0;
-}
+#include <assert.h>
 
 void api_interrupt_init(void)
 {
 	API_CALL_MEM->int_id = (-1);
-
-	for (int i = 0; i < EPIC_INT_NUM; i++) {
-		int_enabled[i] = false;
-	}
-
-	/* Reset interrupt is always enabled */
-	int_enabled[EPIC_INT_RESET] = true;
 }
 
-int epic_interrupt_enable(api_int_id_t int_id)
+bool api_interrupt_is_ready(void)
 {
-	if (int_id >= EPIC_INT_NUM) {
-		return -EINVAL;
-	}
-
-	int_enabled[int_id] = true;
-	return 0;
+	return API_CALL_MEM->int_id == (api_int_id_t)(-1);
 }
 
-int epic_interrupt_disable(api_int_id_t int_id)
+void api_interrupt_trigger(api_int_id_t id)
 {
-	if (int_id >= EPIC_INT_NUM || int_id == EPIC_INT_RESET) {
-		return -EINVAL;
-	}
+	assert(API_CALL_MEM->int_id == (api_int_id_t)(-1));
 
-	int_enabled[int_id] = false;
-	return 0;
+	API_CALL_MEM->int_id = id;
+	TMR_TO_Start(MXC_TMR5, 1, 0);
 }

epicardium/api/interrupt-sender.h

@@ -2,4 +2,5 @@
 #include "api/common.h"
 
 void api_interrupt_init(void);
-int api_interrupt_trigger(api_int_id_t id);
+bool api_interrupt_is_ready(void);
+void api_interrupt_trigger(api_int_id_t id);

epicardium/ble/app/app_main.c

-/*************************************************************************************************/
-/*!
- *  \file
- *
- *  \brief  Application framework main module.
- *
- *  Copyright (c) 2011-2018 Arm Ltd. All Rights Reserved.
- *  ARM Ltd. confidential and proprietary.
- *
- *  IMPORTANT.  Your use of this file is governed by a Software License Agreement
- *  ("Agreement") that must be accepted in order to download or otherwise receive a
- *  copy of this file.  You may not use or copy this file for any purpose other than
- *  as described in the Agreement.  If you do not agree to all of the terms of the
- *  Agreement do not use this file and delete all copies in your possession or control;
- *  if you do not have a copy of the Agreement, you must contact ARM Ltd. prior
- *  to any use, copying or further distribution of this software.
- */
-/*************************************************************************************************/
-
-/* card10:
- * copied from: lib/sdk/Libraries/BTLE/stack/ble-profiles/sources/apps/app/app_main.c
- *
- * Reason: we need to correctly implement AppHandleNumericComparison
- */
-/* clang-format off */
-/* clang-formet turned off for easier diffing against orginal file */
-#include <string.h>
-#include "wsf_types.h"
-#include "wsf_msg.h"
-#include "sec_api.h"
-#include "wsf_trace.h"
-#include "wsf_timer.h"
-#include "wsf_assert.h"
-#include "util/bstream.h"
-#include "dm_api.h"
-#include "app_api.h"
-#include "app_main.h"
-#include "app_ui.h"
-
-#include "modules/log.h"
-
-/**************************************************************************************************
-  Global Variables
-**************************************************************************************************/
-
-/*! Configuration pointer for advertising */
-appAdvCfg_t *pAppAdvCfg;
-
-/*! Configuration pointer for extended and periodic advertising */
-appExtAdvCfg_t *pAppExtAdvCfg;
-
-/*! Configuration pointer for slave */
-appSlaveCfg_t *pAppSlaveCfg;
-
-/*! Configuration pointer for master */
-appMasterCfg_t *pAppMasterCfg;
-
-/*! Configuration pointer for extended master */
-appExtMasterCfg_t *pAppExtMasterCfg;
-
-/*! Configuration pointer for security */
-appSecCfg_t *pAppSecCfg;
-
-/*! Configuration pointer for connection parameter update */
-appUpdateCfg_t *pAppUpdateCfg;
-
-/*! Configuration pointer for discovery */
-appDiscCfg_t *pAppDiscCfg;
-
-/*! Configuration pointer for application */
-appCfg_t *pAppCfg;
-
-/*! Connection control block array */
-appConnCb_t appConnCb[DM_CONN_MAX];
-
-/*! WSF handler ID */
-wsfHandlerId_t appHandlerId;
-
-/*! Main control block */
-appCb_t appCb;
-
-/*! Configuration structure for incoming request actions */
-const appReqActCfg_t appReqActCfg =
-{
-  APP_ACT_ACCEPT        /*! Action for the remote connection parameter request */
-};
-
-/*! Configuration pointer for incoming request actions on master */
-appReqActCfg_t *pAppMasterReqActCfg = (appReqActCfg_t *) &appReqActCfg;
-
-/*! Configurable pointer for incoming request actions on slave */
-appReqActCfg_t *pAppSlaveReqActCfg = (appReqActCfg_t *) &appReqActCfg;
-
-/*************************************************************************************************/
-/*!
- *  \brief  Process messages from the event handler.
- *
- *  \param  pMsg    Pointer to message.
- *
- *  \return None.
- */
-/*************************************************************************************************/
-static void appProcMsg(wsfMsgHdr_t *pMsg)
-{
-  switch(pMsg->event)
-  {
-    case APP_BTN_POLL_IND:
-      appUiBtnPoll();
-      break;
-
-    case APP_UI_TIMER_IND:
-      appUiTimerExpired(pMsg);
-      break;
-
-    default:
-      break;
-  }
-}
-
-/*************************************************************************************************/
-/*!
- *  \brief  Check the bonded state of a connection.
- *
- *  \param  connId      DM connection ID.
- *
- *  \return Bonded state.
- */
-/*************************************************************************************************/
-bool_t appCheckBonded(dmConnId_t connId)
-{
-  WSF_ASSERT((connId > 0) && (connId <= DM_CONN_MAX));
-
-  return appConnCb[connId - 1].bonded;
-}
-
-/*************************************************************************************************/
-/*!
- *  \brief  Check the bond-by-LTK state of a connection.
- *
- *  \param  connId      DM connection ID.
- *
- *  \return Bond-by-LTK state.
- */
-/*************************************************************************************************/
-bool_t appCheckBondByLtk(dmConnId_t connId)
-{
-  WSF_ASSERT((connId > 0) && (connId <= DM_CONN_MAX));
-
-  return appConnCb[connId - 1].bondByLtk;
-}
-
-/*************************************************************************************************/
-/*!
- *  \brief  Return the number of existing connections of the given role.
- *
- *  \param  role      Connection role
- *
- *  \return Number of connections.
- */
-/*************************************************************************************************/
-uint8_t appNumConns(uint8_t role)
-{
-  appConnCb_t   *pCcb = appConnCb;
-  uint8_t       i, j;
-
-  for (i = DM_CONN_MAX, j = 0; i > 0; i--, pCcb++)
-  {
-    if ((pCcb->connId != DM_CONN_ID_NONE) && (DmConnRole(pCcb->connId) == role))
-    {
-      j++;
-    }
-  }
-
-  return j;
-}
-
-/*************************************************************************************************/
-/*!
- *  \brief  App framework handler init function called during system initialization.
- *
- *  \param  handlerID  WSF handler ID for App.
- *
- *  \return None.
- */
-/*************************************************************************************************/
-void AppInit(void)
-{
-  appHandlerId = WsfOsSetNextHandler(AppHandler);
-
-  AppDbInit();
-}
-
-/*************************************************************************************************/
-/*!
- *  \brief  WSF event handler for app framework.
- *
- *  \param  event   WSF event mask.
- *  \param  pMsg    WSF message.
- *
- *  \return None.
- */
-/*************************************************************************************************/
-void AppHandler(wsfEventMask_t event, wsfMsgHdr_t *pMsg)
-{
-  if (pMsg != NULL)
-  {
-    APP_TRACE_INFO1("App got evt %d", pMsg->event);
-
-    if (pMsg->event >= APP_MASTER_MSG_START)
-    {
-      /* pass event to master handler */
-      (*appCb.masterCback)(pMsg);
-    }
-    else if (pMsg->event >= APP_SLAVE_MSG_START)
-    {
-      /* pass event to slave handler */
-      (*appCb.slaveCback)(pMsg);
-    }
-    else
-    {
-      appProcMsg(pMsg);
-    }
-  }
-  else
-  {
-    if (event & APP_BTN_DOWN_EVT)
-    {
-      AppUiBtnPressed();
-    }
-  }
-}
-
-/*************************************************************************************************/
-/*!
- *  \brief  Handle a passkey request during pairing.  If the passkey is to displayed, a
- *          random passkey is generated and displayed.  If the passkey is to be entered
- *          the user is prompted to enter the passkey.
- *
- *  \param  pAuthReq  DM authentication requested event structure.
- *
- *  \return None.
- */
-/*************************************************************************************************/
-void AppHandlePasskey(dmSecAuthReqIndEvt_t *pAuthReq)
-{
-  uint32_t passkey;
-  uint8_t  buf[SMP_PIN_LEN];
-
-  if (pAuthReq->display)
-  {
-    /* generate random passkey, limit to 6 digit max */
-    SecRand((uint8_t *) &passkey, sizeof(uint32_t));
-    passkey %= 1000000;
-
-    /* convert to byte buffer */
-    buf[0] = UINT32_TO_BYTE0(passkey);
-    buf[1] = UINT32_TO_BYTE1(passkey);
-    buf[2] = UINT32_TO_BYTE2(passkey);
-
-    /* send authentication response to DM */
-    DmSecAuthRsp((dmConnId_t) pAuthReq->hdr.param, SMP_PIN_LEN, buf);
-
-    /* display passkey */
-    AppUiDisplayPasskey(passkey);
-  }
-  else
-  {
-    /* prompt user to enter passkey */
-    AppUiAction(APP_UI_PASSKEY_PROMPT);
-  }
-}
-
-/*************************************************************************************************/
-/*!
-*  \brief  Handle a numeric comparison indication during pairing.  The confirmation value is
-*          displayed and the user is prompted to verify that the local and peer confirmation
-*          values match.
-*
-*  \param  pCnfInd  DM confirmation indication event structure.
-*
-*  \return None.
-*/
-/*************************************************************************************************/
-void AppHandleNumericComparison(dmSecCnfIndEvt_t *pCnfInd)
-{
-  uint32_t confirm = DmSecGetCompareValue(pCnfInd->confirm);
-
-  LOG_INFO("ble", "Confirm Value: %ld", confirm);
-
-  /* display confirmation value */
-  AppUiDisplayConfirmValue(confirm);
-
-  /* TODO: Verify that local and peer confirmation values match */
-  DmSecCompareRsp((dmConnId_t)pCnfInd->hdr.param, TRUE);
-}
-
-/*************************************************************************************************/
-/*!
- *  \brief  Close the connection with the give connection identifier.
- *
- *  \param  connId    Connection identifier.
- *
- *  \return None.
- */
-/*************************************************************************************************/
-void AppConnClose(dmConnId_t connId)
-{
-  DmConnClose(DM_CLIENT_ID_APP, connId, HCI_ERR_REMOTE_TERMINATED);
-}
-
-/*************************************************************************************************/
-/*!
- *  \brief  Get a list of connection identifiers of open connections.
- *
- *  \param  pConnIdList    Buffer to hold connection IDs (must be DM_CONN_MAX bytes).
- *
- *  \return Number of open connections.
- *
- */
-/*************************************************************************************************/
-uint8_t AppConnOpenList(dmConnId_t *pConnIdList)
-{
-  appConnCb_t   *pCcb = appConnCb;
-  uint8_t       i;
-  uint8_t       pos = 0;
-
-  memset(pConnIdList, DM_CONN_ID_NONE, DM_CONN_MAX);
-
-  for (i = DM_CONN_MAX; i > 0; i--, pCcb++)
-  {
-    if (pCcb->connId != DM_CONN_ID_NONE)
-    {
-      pConnIdList[pos++] = pCcb->connId;
-    }
-  }
-
-  return pos;
-}
-
-/*************************************************************************************************/
-/*!
- *  \brief  Check if a connection is open.
- *
- *  \return Connection ID of open connection or DM_CONN_ID_NONE if no open connections.
- */
-/*************************************************************************************************/
-dmConnId_t AppConnIsOpen(void)
-{
-  appConnCb_t   *pCcb = appConnCb;
-  uint8_t       i;
-
-  for (i = DM_CONN_MAX; i > 0; i--, pCcb++)
-  {
-    if (pCcb->connId != DM_CONN_ID_NONE)
-    {
-      return pCcb->connId;
-    }
-  }
-
-  return DM_CONN_ID_NONE;
-}
-
-/*************************************************************************************************/
-/*!
- *  \brief  Get the device database record handle associated with an open connection.
- *
- *  \param  connId    Connection identifier.
- *
- *  \return Database record handle or APP_DB_HDL_NONE.
- */
-/*************************************************************************************************/
-appDbHdl_t AppDbGetHdl(dmConnId_t connId)
-{
-  return appConnCb[connId-1].dbHdl;
-}
-
-/*************************************************************************************************/
-/*!
- *  \brief  Add device to resolving list.
- *
- *  \param  pMsg    Pointer to DM callback event message.
- *  \param  connId  Connection identifier.
- *
- *  \return None.
- */
-/*************************************************************************************************/
-void AppAddDevToResList(dmEvt_t *pMsg, dmConnId_t connId)
-{
-  dmSecKey_t *pPeerKey;
-  appDbHdl_t hdl = appConnCb[connId - 1].dbHdl;
-
-  /* if LL Privacy is supported and the peer device has distributed its IRK */
-  if (HciLlPrivacySupported() && ((pPeerKey = AppDbGetKey(hdl, DM_KEY_IRK, NULL))!= NULL))
-  {
-    /* add peer device to resolving list. If all-zero local or peer IRK is used then
-       LL will only use or accept local or peer identity address respectively. */
-    DmPrivAddDevToResList(pPeerKey->irk.addrType, pPeerKey->irk.bdAddr, pPeerKey->irk.key,
-                          DmSecGetLocalIrk(), TRUE, pMsg->hdr.param);
-  }
-}
-
-/*************************************************************************************************/
-/*!
- *  \brief  Update privacy mode for a given peer device.
- *
- *  \param  hdl     Database record handle.
- *
- *  \return None.
- */
-/*************************************************************************************************/
-void AppUpdatePrivacyMode(appDbHdl_t hdl)
-{
-  /* if peer device's been added to resolving list but RPA Only attribute not found on peer device */
-  if ((hdl != APP_DB_HDL_NONE) && AppDbGetPeerAddedToRl(hdl) && !AppDbGetPeerRpao(hdl))
-  {
-    dmSecKey_t *pPeerKey = AppDbGetKey(hdl, DM_KEY_IRK, NULL);
-    if (pPeerKey != NULL)
-    {
-      /* set device privacy mode for this peer device */
-      DmPrivSetPrivacyMode(pPeerKey->irk.addrType, pPeerKey->irk.bdAddr, DM_PRIV_MODE_DEVICE);
-
-      /* make sure resolving list flag cleared */
-      AppDbSetPeerAddedToRl(hdl, FALSE);
-    }
-  }
-}
-/* clang-format on */

epicardium/ble/app/common/app_ui.c

-/*************************************************************************************************/
-/*!
- *  \file
- *
- *  \brief  Application framework user interface.
- *
- *  Copyright (c) 2011-2018 Arm Ltd. All Rights Reserved.
- *  ARM Ltd. confidential and proprietary.
- *
- *  IMPORTANT.  Your use of this file is governed by a Software License Agreement
- *  ("Agreement") that must be accepted in order to download or otherwise receive a
- *  copy of this file.  You may not use or copy this file for any purpose other than
- *  as described in the Agreement.  If you do not agree to all of the terms of the
- *  Agreement do not use this file and delete all copies in your possession or control;
- *  if you do not have a copy of the Agreement, you must contact ARM Ltd. prior
- *  to any use, copying or further distribution of this software.
- */
-/*************************************************************************************************/
-
-#include "wsf_types.h"
-#include "wsf_os.h"
-#include "wsf_trace.h"
-#include "app_ui.h"
-
-/* card10:
- * copied from: lib/sdk/Libraries/BTLE/stack/ble-profiles/sources/apps/app/common/app_ui.c
- *
- * Reason: has several user interactions which we likley have to implement
- */
-
-/* clang-format off */
-/* clang-formet turned off for easier diffing against orginal file */
-/**************************************************************************************************
-  Global Variables
-**************************************************************************************************/
-
-/*! \brief Callback struct */
-appUiCback_t appUiCbackTbl;
-
-
-/*************************************************************************************************/
-/*!
- *  \brief  card10 - Should disable encryption. MAXIM bug reported to us in current static library. Requires 
- *                   this to be called before the BTLE app starts making advertisements. Avoids encryption
- *                   rendering the frame unreadable.
- *
- *  \return None.
- */
-/*************************************************************************************************/
-void llc_api_crypto_disable_tx();
-
-
-/*************************************************************************************************/
-/*!
- *  \brief  Perform a user interface action based on the event value passed to the function.
- *
- *  \param  event   User interface event value.
- *
- *  \return None.
- */
-/*************************************************************************************************/
-void AppUiAction(uint8_t event)
-{
-  switch (event)
-  {
-    case APP_UI_NONE:
-      /* no action */
-      break;
-
-    case APP_UI_RESET_CMPL:
-      APP_TRACE_INFO0(">>> Reset complete <<<");
-      break;
-
-    case APP_UI_ADV_START:
-      llc_api_crypto_disable_tx();
-      APP_TRACE_INFO0(">>> Advertising started <<<");
-      break;
-
-    case APP_UI_ADV_STOP:
-      APP_TRACE_INFO0(">>> Advertising stopped <<<");
-      break;
-
-    case APP_UI_SCAN_START:
-      APP_TRACE_INFO0(">>> Scanning started <<<");
-      break;
-
-    case APP_UI_SCAN_STOP:
-      APP_TRACE_INFO0(">>> Scanning stopped <<<");
-      break;
-
-    case APP_UI_SCAN_REPORT:
-      APP_TRACE_INFO0(">>> Scan data received from peer <<<");
-      break;
-
-    case APP_UI_CONN_OPEN:
-      APP_TRACE_INFO0(">>> Connection opened <<<");
-      break;
-
-    case APP_UI_CONN_CLOSE:
-      APP_TRACE_INFO0(">>> Connection closed <<<");
-      break;
-
-    case APP_UI_SEC_PAIR_CMPL:
-      APP_TRACE_INFO0(">>> Pairing completed successfully <<<");
-      break;
-
-    case APP_UI_SEC_PAIR_FAIL:
-      APP_TRACE_INFO0(">>> Pairing failed <<<");
-      break;
-
-    case APP_UI_SEC_ENCRYPT:
-      APP_TRACE_INFO0(">>> Connection encrypted <<<");
-      break;
-
-    case APP_UI_SEC_ENCRYPT_FAIL:
-      APP_TRACE_INFO0(">>> Encryption failed <<<");
-      break;
-
-    case APP_UI_PASSKEY_PROMPT:
-      APP_TRACE_INFO0(">>> Prompt user to enter passkey <<<");
-      break;
-
-    case APP_UI_ALERT_CANCEL:
-      APP_TRACE_INFO0(">>> Cancel a low or high alert <<<");
-      break;
-
-    case APP_UI_ALERT_LOW:
-      APP_TRACE_INFO0(">>> Low alert <<<");
-      break;
-
-    case APP_UI_ALERT_HIGH:
-      APP_TRACE_INFO0(">>> High alert <<<");
-      break;
-
-    case APP_UI_ADV_SET_START_IND:
-      APP_TRACE_INFO0(">>> Advertising set(s) started <<<");
-      break;
-
-    case APP_UI_ADV_SET_STOP_IND:
-      APP_TRACE_INFO0(">>> Advertising set(s) stopped <<<");
-      break;
-
-    case APP_UI_SCAN_REQ_RCVD_IND:
-      APP_TRACE_INFO0(">>> Scan request received <<<");
-      break;
-
-    case APP_UI_EXT_SCAN_START_IND:
-      APP_TRACE_INFO0(">>> Extended scanning started <<<");
-      break;
-
-    case APP_UI_EXT_SCAN_STOP_IND:
-      APP_TRACE_INFO0(">>> Extended scanning stopped <<<");
-      break;
-
-    case APP_UI_PER_ADV_SET_START_IND:
-      APP_TRACE_INFO0(">>> Periodic advertising set started <<<");
-      break;
-
-    case APP_UI_PER_ADV_SET_STOP_IND:
-      APP_TRACE_INFO0(">>> Periodic advertising set stopped <<<");
-      break;
-
-    case APP_UI_PER_ADV_SYNC_EST_IND:
-      APP_TRACE_INFO0(">>> Periodic advertising sync established <<<");
-      break;
-
-    case APP_UI_PER_ADV_SYNC_LOST_IND:
-      APP_TRACE_INFO0(">>> Periodic advertising sync lost <<<");
-      break;
-
-    default:
-      break;
-  }
-
-  if (appUiCbackTbl.actionCback)
-  {
-    (*appUiCbackTbl.actionCback)(event);
-  }
-}
-
-/*************************************************************************************************/
-/*!
- *  \brief  Display a passkey.
- *
- *  \param  passkey   Passkey to display.
- *
- *  \return None.
- */
-/*************************************************************************************************/
-void AppUiDisplayPasskey(uint32_t passkey)
-{
-  APP_TRACE_INFO1(">>> Passkey: %d <<<", passkey);
-}
-
-/*************************************************************************************************/
-/*!
-*  \brief  Display a confirmation value.
-*
-*  \param  confirm    Confirm value to display.
-*
-*  \return None.
-*/
-/*************************************************************************************************/
-void AppUiDisplayConfirmValue(uint32_t confirm)
-{
-  APP_TRACE_INFO1(">>> Confirm Value: %d <<<", confirm);
-}
-
-/*************************************************************************************************/
-/*!
- *  \brief  Display an RSSI value.
- *
- *  \param  rssi   Rssi value to display.
- *
- *  \return None.
- */
-/*************************************************************************************************/
-void AppUiDisplayRssi(int8_t rssi)
-{
-  APP_TRACE_INFO1(">>> RSSI: %d dBm<<<", rssi);
-}
-
-/*************************************************************************************************/
-/*!
- *  \brief  Handle a UI timer expiration event.
- *
- *  \param  pMsg    Pointer to message.
- *
- *  \return None.
- */
-/*************************************************************************************************/
-void appUiTimerExpired(wsfMsgHdr_t *pMsg)
-{
-
-}
-
-/*************************************************************************************************/
-/*!
- *  \brief  Perform button press polling.  This function is called to handle WSF
- *          message APP_BTN_POLL_IND.
- *
- *  \return None.
- */
-/*************************************************************************************************/
-void appUiBtnPoll(void)
-{
-  if (appUiCbackTbl.btnPollCback)
-  {
-    (*appUiCbackTbl.btnPollCback)();
-  }
-}
-
-/*************************************************************************************************/
-/*!
- *  \brief  Handle a hardware button press.  This function is called to handle WSF
- *          event APP_BTN_DOWN_EVT.
- *
- *  \return None.
- */
-/*************************************************************************************************/
-void AppUiBtnPressed(void)
-{
-
-}
-
-/*************************************************************************************************/
-/*!
- *  \brief  Register a callback function to receive application button press events.
- *
- *  \return None.
- *
- *  \note   Registered by application to receive button events
- */
-/*************************************************************************************************/
-void AppUiBtnRegister(appUiBtnCback_t btnCback)
-{
-  appUiCbackTbl.btnCback = btnCback;
-}
-
-/*************************************************************************************************/
-/*!
- *  \brief  Register a callback function to receive action events.
- *
- *  \return None.
- *
- *  \note   Registered by platform
- */
-/*************************************************************************************************/
-void AppUiActionRegister(appUiActionCback_t actionCback)
-{
-  appUiCbackTbl.actionCback = actionCback;
-}
-
-/*************************************************************************************************/
-/*!
- *  \brief  Register a callback function to receive APP_BTN_POLL_IND events.
- *
- *  \return None.
- *
- *  \note   Registered by platform
- */
-/*************************************************************************************************/
-void AppUiBtnPollRegister(appUiBtnPollCback_t btnPollCback)
-{
-  appUiCbackTbl.btnPollCback = btnPollCback;
-}
-
-/*************************************************************************************************/
-/*!
- *  \brief  Play a sound.
- *
- *  \param  pSound   Pointer to sound tone/duration array.
- *
- *  \return None.
- */
-/*************************************************************************************************/
-void AppUiSoundPlay(const appUiSound_t *pSound)
-{
-
-}
-
-/*************************************************************************************************/
-/*!
- *  \brief  Stop the sound that is currently playing.
- *
- *  \return None.
- */
-/*************************************************************************************************/
-void AppUiSoundStop(void)
-{
-
-}
-
-/*************************************************************************************************/
-/*!
- *  \brief  Button test function-- for test purposes only.
- *
- *  \return None.
- */
-/*************************************************************************************************/
-void AppUiBtnTest(uint8_t btn)
-{
-  if (appUiCbackTbl.btnCback)
-  {
-    (*appUiCbackTbl.btnCback)(btn);
-  }
-}
-
-/* clang-format on */

epicardium/ble/ble.c

 #include "epicardium.h"
-#include "modules/log.h"
+#include "os/core.h"
+#include "os/config.h"
 
 #include "fs/fs_util.h"
 #include "wsf_types.h"
@@ -12,6 +13,7 @@
 #include "FreeRTOS.h"
 #include "timers.h"
 
+#include <machine/endian.h>
 #include <stdio.h>
 #include <string.h>
 #include <stdbool.h>
@@ -20,6 +22,21 @@
 #define WSF_BUF_POOLS 6
 #define WSF_BUF_SIZE (0x1048 * FACTOR)
 
+struct log_packet_header {
+	uint32_t original_length;
+	uint32_t included_length;
+	uint32_t packet_flags;
+	uint32_t cumulative_drops;
+	uint32_t timestamp_us_h;
+	uint32_t timestamp_us_l;
+};
+
+static uint8_t bdAddr[6] = { 0xCA, 0x4D, 0x10, 0x00, 0x00, 0x00 };
+
+static const uint8_t log_header[] = {
+	'b', 't', 's', 'n', 'o', 'o', 'p', 0, 0, 0, 0, 1, 0, 0, 0x03, 0xea
+};
+
 uint32_t SystemHeapSize = WSF_BUF_SIZE;
 uint32_t SystemHeap[WSF_BUF_SIZE / 4];
 uint32_t SystemHeapStart;
@@ -44,20 +61,20 @@ static StaticTimer_t x;
 static TimerHandle_t timerWakeup = NULL;
 static int lasttick              = 0;
 
+static int log_fd;
+static bool log_dirty        = false;
+static bool log_enabled      = false;
+static int log_lastflushtick = 0;
+
 /*! \brief  Stack initialization for app. */
+extern void LlStackInit(void);
 extern void StackInit(void);
-extern void AppInit(void);
 extern void bleuart_init(void);
 extern void bleFileTransfer_init(void);
 extern void bleCard10_init(void);
+extern void bleESS_init(void);
 extern void BbBleDrvSetTxPower(int8_t power);
 
-/*************************************************************************************************/
-void PalSysAssertTrap(void)
-{
-	while (1) {
-	}
-}
 /*************************************************************************************************/
 static bool_t myTrace(const uint8_t *pBuf, uint32_t len)
 {
@@ -70,6 +87,79 @@ static bool_t myTrace(const uint8_t *pBuf, uint32_t len)
 
 	return FALSE;
 }
+
+/*************************************************************************************************/
+void WsfPDump(wsfPDumpType_t pdType, uint16_t length, uint8_t *pBuffer)
+{
+	uint32_t direction;
+	uint8_t type;
+	int ret;
+
+	if (log_enabled) {
+		switch (pdType) {
+		case WSF_PDUMP_TYPE_HCI_CMD:
+			direction = 0;
+			type      = 0x01;
+			break;
+		case WSF_PDUMP_TYPE_HCI_EVT:
+			direction = 1;
+			type      = 0x04;
+			break;
+		case WSF_PDUMP_TYPE_HCI_TX_ACL:
+			direction = 0;
+			type      = 0x02;
+			break;
+		case WSF_PDUMP_TYPE_HCI_RX_ACL:
+			direction = 1;
+			type      = 0x02;
+			break;
+		default:
+			LOG_WARN("ble", "Unknown packet type to be logged");
+			return;
+		}
+
+		uint64_t tick         = xTaskGetTickCount();
+		uint64_t timestamp_us = tick * 1000;
+
+		struct log_packet_header header = {
+			.original_length  = __htonl(length + 1),
+			.included_length  = __htonl(length + 1),
+			.packet_flags     = __htonl(direction),
+			.cumulative_drops = __htonl(0),
+			.timestamp_us_h   = __htonl(timestamp_us >> 32),
+			.timestamp_us_l   = __htonl(timestamp_us & 0xFFFFFFFF)
+		};
+
+		ret = epic_file_write(log_fd, &header, sizeof(header));
+		if (ret != sizeof(header)) {
+			goto out_err;
+		}
+
+		ret = epic_file_write(log_fd, &type, sizeof(type));
+		if (ret != sizeof(type)) {
+			goto out_err;
+		}
+
+		ret = epic_file_write(log_fd, pBuffer, length);
+		if (ret != length) {
+			goto out_err;
+		}
+
+		log_dirty = true;
+	}
+
+	return;
+
+out_err:
+	LOG_WARN("ble", "Log file write failed. Logging diabled");
+	log_enabled = false;
+}
+/*************************************************************************************************/
+void __wrap_BbBleDrvRand(uint8_t *pBuf, uint8_t len)
+{
+	epic_csprng_read(pBuf, len);
+	//printf("BbBleDrvRand(%d) = %02x %02x ...\n", len, pBuf[0], pBuf[1]);
+}
 /*************************************************************************************************/
 static void WsfInit(void)
 {
@@ -91,14 +181,13 @@ static void WsfInit(void)
 /* TODO: We need a source of MACs */
 static void setAddress(void)
 {
-	uint8_t bdAddr[6] = { 0xCA, 0x4D, 0x10, 0x00, 0x00, 0x00 };
 	char buf[32];
 
-	int result = fs_read_text_file("mac.txt", buf, sizeof(buf));
+	int result = epic_config_get_string("ble_mac", buf, sizeof(buf));
 
 	if (result < 0) {
-		APP_TRACE_INFO0("mac.txt not found, generating random MAC");
-		epic_trng_read(bdAddr + 3, 3);
+		APP_TRACE_INFO0("ble_mac not set. Generating random MAC");
+		epic_csprng_read(bdAddr + 3, 3);
 		sprintf(buf,
 			"%02x:%02x:%02x:%02x:%02x:%02x\n",
 			bdAddr[0],
@@ -107,9 +196,9 @@ static void setAddress(void)
 			bdAddr[3],
 			bdAddr[4],
 			bdAddr[5]);
-		fs_write_file("mac.txt", buf, strlen(buf));
+		epic_config_set_string("ble_mac", buf);
 	} else {
-		APP_TRACE_INFO1("mac file contents: %s", buf);
+		APP_TRACE_INFO1("ble_mac: %s", buf);
 	}
 
 	int a, b, c, d, e, f;
@@ -135,6 +224,11 @@ static void setAddress(void)
 	HciVsSetBdAddr(bdAddr);
 }
 /*************************************************************************************************/
+void epic_ble_get_address(uint8_t *addr)
+{
+	memcpy(addr, bdAddr, sizeof(bdAddr));
+}
+/*************************************************************************************************/
 static void vTimerCallback(xTimerHandle pxTimer)
 {
 	//printf("wake\n");
@@ -175,35 +269,26 @@ void RSV11_IRQHandler(void)
 	notify();
 }
 /*************************************************************************************************/
-#define BLEMAXCFGBYTES 100
-bool ble_shall_start(void)
+bool ble_is_enabled(void)
 {
-	int bleConfigFile = epic_file_open("ble.txt", "r");
-	if (bleConfigFile < 0) {
-		LOG_INFO("ble", "can not open ble.txt -> BLE is not started");
-		epic_file_close(bleConfigFile);
-		return false;
-	}
+	/*
+	 * 0 = unknown, check config
+	 * 1 = disabled
+	 * 2 = enabled
+	 */
+	static int ble_state = 0;
 
-	char cfgBuf[BLEMAXCFGBYTES + 1];
-	int readNum = epic_file_read(bleConfigFile, cfgBuf, BLEMAXCFGBYTES);
-	epic_file_close(bleConfigFile);
-	if (readNum < 0) {
-		LOG_WARN("ble", "can not read ble.txt -> BLE is not started");
-		return false;
+	if (ble_state == 0) {
+		if (config_get_boolean_with_default("ble_enable", false)) {
+			ble_state = 2;
+			LOG_INFO("ble", "BLE is enabled.");
+		} else {
+			ble_state = 1;
+			LOG_INFO("ble", "BLE is disabled.");
+		}
 	}
-	cfgBuf[readNum] = '\0';
-
-	char bleActiveStr[]              = "active=true";
-	cfgBuf[sizeof(bleActiveStr) - 1] = '\0';
 
-	if (strcmp(cfgBuf, "active=true") != 0) {
-		LOG_INFO("ble", "BLE is disabled.");
-		return false;
-	} else {
-		LOG_INFO("ble", "BLE is enabled.");
-		return true;
-	}
+	return ble_state == 2;
 }
 /*************************************************************************************************/
 static void scheduleTimer(void)
@@ -239,6 +324,95 @@ static void scheduleTimer(void)
 	}
 }
 /*************************************************************************************************/
+static void log_flush(void)
+{
+	int tick = xTaskGetTickCount();
+	if (tick - log_lastflushtick > 5000) {
+		log_lastflushtick = tick;
+		if (log_dirty) {
+			log_dirty = false;
+			LOG_INFO("ble", "Flushing log");
+			epic_file_flush(log_fd);
+		}
+	}
+}
+/*************************************************************************************************/
+static int log_rotate(void)
+{
+	int i;
+	char filename_old[16];
+	char filename_new[16];
+	struct epic_stat stat;
+	int ret;
+
+	epic_file_stat("logs", &stat);
+
+	if (stat.type == EPICSTAT_FILE) {
+		return -1;
+	}
+
+	if (stat.type == EPICSTAT_NONE) {
+		ret = epic_file_mkdir("logs");
+		if (ret < 0) {
+			return ret;
+		}
+	}
+
+	if (epic_file_stat("logs/ble9.log", &stat) == 0) {
+		epic_file_unlink("logs/ble9.log");
+	}
+
+	for (i = 8; i > 0; i--) {
+		sprintf(filename_old, "logs/ble%d.log", i);
+		sprintf(filename_new, "logs/ble%d.log", i + 1);
+
+		if (epic_file_stat(filename_old, &stat) == 0) {
+			epic_file_rename(filename_old, filename_new);
+		}
+	}
+
+	if (epic_file_stat("logs/ble.log", &stat) == 0) {
+		epic_file_rename("logs/ble.log", "logs/ble1.log");
+	}
+
+	return 0;
+}
+/*************************************************************************************************/
+static void log_init(void)
+{
+	int ret;
+	log_enabled = config_get_boolean_with_default("ble_log_enable", false);
+
+	if (!log_enabled) {
+		return;
+	}
+
+	LOG_INFO("ble", "Log is enabled");
+
+	if (log_rotate() < 0) {
+		log_enabled = false;
+		LOG_WARN("ble", "Can not rotate logs. Logging disabled.");
+		return;
+	}
+
+	log_fd = epic_file_open("logs/ble.log", "w");
+	if (log_fd < 0) {
+		log_enabled = false;
+		LOG_WARN("ble", "Can not create log file. Logging disabled.");
+		return;
+	}
+
+	ret = epic_file_write(log_fd, log_header, sizeof(log_header));
+	if (ret != sizeof(log_header)) {
+		log_enabled = false;
+		LOG_WARN(
+			"ble",
+			"Can not create log file header. Logging disabled."
+		);
+		return;
+	}
+}
+/*************************************************************************************************/
 void vBleTask(void *pvParameters)
 {
 	ble_task_id = xTaskGetCurrentTaskHandle();
@@ -248,6 +422,8 @@ void vBleTask(void *pvParameters)
 	 */
 	vTaskDelay(pdMS_TO_TICKS(500));
 
+	log_init();
+
 	/* We are going to execute FreeRTOS functions from callbacks
 	 * coming from this interrupt. Its priority needs to be
 	 * reduced to allow this. */
@@ -255,22 +431,24 @@ void vBleTask(void *pvParameters)
 	NVIC_EnableIRQ(RSV11_IRQn);
 
 	WsfInit();
+
 	taskENTER_CRITICAL();
 	/* Critical section to prevent a loop in iq_capture2 / meas_freq in
 	 * /home/maxim/Documents/src/BLE/mcbusw/Hardware/Micro/ME14/Firmware/trunk/NDALibraries/BTLE/phy/dbb/prot/ble/pan2g5/afe/max32665/board_config.c:275
-	 * if BHI160 and -Ddebug_prints=true is enabled*/
-	StackInit();
+	 * if BHI160 and -Ddebug_prints=true is enabled. See #115. */
+	LlStackInit();
 	taskEXIT_CRITICAL();
+
+	StackInit();
 	BbBleDrvSetTxPower(0);
 	setAddress();
 
-	AppInit();
 	BleStart();
-	AttsDynInit();
 
 	bleuart_init();
 	bleFileTransfer_init();
 	bleCard10_init();
+	bleESS_init();
 
 	lasttick = xTaskGetTickCount();
 
@@ -286,5 +464,8 @@ void vBleTask(void *pvParameters)
 		ulTaskNotifyTake(pdTRUE, portTICK_PERIOD_MS * 1000);
 		wsfOsDispatcher();
 		scheduleTimer();
+		if (log_enabled) {
+			log_flush();
+		}
 	}
 }

epicardium/ble/ble_adv.c

+#include "ble_api.h"
+#include "epicardium.h"
+#include "os/core.h"
+#include "os/config.h"
+
+#include "wsf_types.h"
+#include "util/bstream.h"
+#include "wsf_msg.h"
+#include "wsf_trace.h"
+#include "app_api.h"
+#include "app_db.h"
+#include "svc_ch.h"
+#include "profiles/gap_api.h"
+
+#include <stdio.h>
+#include <string.h>
+
+#define DEFAULT_ADV_INTERVAL_US 500000
+
+/*! configurable parameters for advertising */
+static appAdvCfg_t bleAdvCfg = {
+	{ 0, 0 }, /*! Advertising durations in ms */
+	{ DEFAULT_ADV_INTERVAL_US / 625,
+	  0 } /*! Advertising intervals in 0.625 ms units */
+};
+
+static bool tainted;
+
+/**************************************************************************************************
+  Advertising Data
+**************************************************************************************************/
+
+/* clang-format off */
+/*! advertising data, discoverable mode */
+static const uint8_t bleAdvDataDisc[] = {
+	/*! flags */
+	2,                        /*! length */
+	DM_ADV_TYPE_FLAGS,        /*! AD type */
+	DM_FLAG_LE_LIMITED_DISC | /*! flags */
+	DM_FLAG_LE_BREDR_NOT_SUP,
+
+	3,
+	DM_ADV_TYPE_APPEARANCE,
+	UINT16_TO_BYTES(CH_APPEAR_WATCH),
+
+	/*! service UUID list */
+	17,
+	DM_ADV_TYPE_128_UUID_PART,
+	CARD10_UUID_SUFFIX,
+	0x0,
+	CARD10_UUID_PREFIX,
+
+	2,                    /*! length */
+	DM_ADV_TYPE_TX_POWER, /*! AD type */
+	0,                    /*! tx power */
+};
+
+/*! advertising data, discoverable mode with HID service*/
+static const uint8_t bleAdvDataDiscHID[] = {
+	/*! flags */
+	2,                        /*! length */
+	DM_ADV_TYPE_FLAGS,        /*! AD type */
+	DM_FLAG_LE_LIMITED_DISC | /*! flags */
+	DM_FLAG_LE_BREDR_NOT_SUP,
+
+	3,
+	DM_ADV_TYPE_APPEARANCE,
+	UINT16_TO_BYTES(CH_APPEAR_WATCH),
+
+	/*! service UUID list */
+	17,
+	DM_ADV_TYPE_128_UUID_PART,
+	CARD10_UUID_SUFFIX,
+	0x0,
+	CARD10_UUID_PREFIX,
+
+	3,                        /*! length */
+	DM_ADV_TYPE_16_UUID_PART, /*! AD type */
+	UINT16_TO_BYTES(ATT_UUID_HID_SERVICE)
+};
+
+/*! scan data, discoverable mode */
+uint8_t bleScanDataDisc[] = {
+	/*! device name */
+	14,                     /*! length */
+	DM_ADV_TYPE_LOCAL_NAME, /*! AD type */
+	'c','a','r','d','1','0','-','0','0','0','0','0','0',
+
+	3,                      /*! length */
+	DM_ADV_TYPE_16_SOLICIT, /*! AD type */
+	UINT16_TO_BYTES(ATT_UUID_CURRENT_TIME_SERVICE),
+};
+/* clang-format on */
+
+/*! advertising data, connectable mode */
+static const uint8_t bleAdvDataConn[] = {
+	/*! flags */
+	2,                 /*! length */
+	DM_ADV_TYPE_FLAGS, /*! AD type */
+	DM_FLAG_LE_BREDR_NOT_SUP,
+};
+
+static uint8_t advertising_mode        = APP_MODE_NONE;
+static uint8_t advertising_mode_target = APP_MODE_NONE;
+
+void ble_adv_proc_msg(bleMsg_t *pMsg)
+{
+	switch (pMsg->hdr.event) {
+	case DM_ADV_START_IND:
+		LOG_INFO(
+			"ble",
+			"Advertisement started %u %u",
+			advertising_mode,
+			advertising_mode_target
+		);
+		if (advertising_mode != advertising_mode_target ||
+		    advertising_mode_target == APP_MODE_NONE) {
+			AppAdvStop();
+		}
+		break;
+
+	case DM_ADV_STOP_IND:
+		LOG_INFO(
+			"ble",
+			"Advertisement stopped %u %u",
+			advertising_mode,
+			advertising_mode_target
+		);
+		if (advertising_mode != advertising_mode_target) {
+			advertising_mode = advertising_mode_target;
+			AppAdvStart(advertising_mode);
+		}
+		break;
+	case DM_CONN_CLOSE_IND:
+		/* Stack overwrites advertising mode after connection close.
+		 * Force our desired mode.
+		 */
+		advertising_mode = APP_MODE_NONE;
+		AppAdvStop();
+		break;
+	};
+}
+
+void ble_adv_init(void)
+{
+	char buf[32];
+	char a, b, c, d, e, f, K;
+
+	/* clang-format off */
+	int result = epic_config_get_string("ble_mac", buf, sizeof(buf));
+	if (result == 0) {
+		if (sscanf(buf,
+			   "%c%c:%c%c:%c%c:%c%c:%c%c:%c%c",
+			   &K, &K, &K, &K, &K, &K,
+			   &a, &b, &c, &d, &e, &f) == 12) {
+			bleScanDataDisc[9]  = a;
+			bleScanDataDisc[10] = b;
+			bleScanDataDisc[11] = c;
+			bleScanDataDisc[12] = d;
+			bleScanDataDisc[13] = e;
+			bleScanDataDisc[14] = f;
+		}
+	}
+	/* clang-format on */
+
+	pAppAdvCfg = (appAdvCfg_t *)&bleAdvCfg;
+}
+
+void ble_adv_setup(void)
+{
+	/* set advertising and scan response data for discoverable mode */
+	if (config_get_boolean_with_default("ble_hid_enable", false)) {
+		AppAdvSetData(
+			APP_ADV_DATA_DISCOVERABLE,
+			sizeof(bleAdvDataDiscHID),
+			(uint8_t *)bleAdvDataDiscHID
+		);
+	} else {
+		AppAdvSetData(
+			APP_ADV_DATA_DISCOVERABLE,
+			sizeof(bleAdvDataDisc),
+			(uint8_t *)bleAdvDataDisc
+		);
+	}
+
+	AppAdvSetData(
+		APP_SCAN_DATA_DISCOVERABLE,
+		sizeof(bleScanDataDisc),
+		(uint8_t *)bleScanDataDisc
+	);
+
+	/* set advertising and scan response data for connectable mode */
+	AppAdvSetData(
+		APP_ADV_DATA_CONNECTABLE,
+		sizeof(bleAdvDataConn),
+		(uint8_t *)bleAdvDataConn
+	);
+	AppAdvSetData(APP_SCAN_DATA_CONNECTABLE, 0, NULL);
+
+	bleAdvCfg.advInterval[0] = DEFAULT_ADV_INTERVAL_US / 625;
+}
+
+void ble_adv_set_interval(uint32_t interval_us)
+{
+	bleAdvCfg.advInterval[0] = interval_us / 625;
+	tainted                  = true;
+}
+
+void ble_adv_stop(void)
+{
+	if (advertising_mode != APP_MODE_NONE) {
+		advertising_mode_target = APP_MODE_NONE;
+		advertising_mode        = APP_MODE_NONE;
+		AppAdvStop();
+	}
+}
+
+static void adv_start(uint8_t mode)
+{
+	if (advertising_mode != APP_MODE_NONE) {
+		/* We need to stop advertising in between or the
+		* adv set will not be changed.
+		* Also need to wait for the stop operation to finish
+		* before we can start again
+		* Also need to set the variables first as we don't
+		* have a lock on the stack.*/
+		advertising_mode_target = mode;
+		advertising_mode        = APP_MODE_NONE;
+		AppAdvStop();
+	} else {
+		advertising_mode        = mode;
+		advertising_mode_target = mode;
+		AppAdvStart(advertising_mode);
+	}
+	tainted = false;
+}
+
+void ble_adv_start(uint8_t mode)
+{
+	adv_start(mode);
+	tainted = true;
+}
+
+void ble_adv_discoverable(bool discoverable)
+{
+	if (discoverable) {
+		if (advertising_mode != APP_MODE_DISCOVERABLE || tainted) {
+			LOG_INFO("ble", "Making bondable and discoverable");
+			adv_start(APP_MODE_DISCOVERABLE);
+		}
+	} else {
+		/* TODO: This does way more than the function name indicates */
+		if (AppDbCheckBonded()) {
+			if (advertising_mode != APP_MODE_CONNECTABLE ||
+			    tainted) {
+				LOG_INFO("ble", "Bonded. Making connectable");
+				adv_start(APP_MODE_CONNECTABLE);
+			}
+		} else {
+			LOG_INFO("ble", "Not bonded. Stop advertising");
+			ble_adv_stop();
+		}
+	}
+}

epicardium/ble/ble_api.h

 #pragma once
+
+#include "epicardium.h"
+
+#include <stdint.h>
+#include "wsf_types.h"
+
+#include "att_api.h"
+#include "dm_api.h"
+
+#define CARD10_UUID_SUFFIX                                                     \
+	0x42, 0x23, 0x42, 0x23, 0x42, 0x23, 0x42, 0x23, 0x42, 0x23, 0x42, 0x23
+#define CARD10_UUID_PREFIX 0x02, 0x23, 0x42
+
+/**************************************************************************************************
+  Data Types
+**************************************************************************************************/
+
+/*! Application message type */
+typedef union
+{
+  wsfMsgHdr_t     hdr;
+  dmEvt_t         dm;
+  attsCccEvt_t    ccc;
+  attEvt_t        att;
+} bleMsg_t;
+
 /**************************************************************************************************
   Function Declarations
 **************************************************************************************************/
@@ -11,3 +37,23 @@
 /*************************************************************************************************/
 void BleStart(void);
 
+/* ATT client module interface. Used by main BLE module */
+void bleValueUpdate(attEvt_t *pMsg);
+void bleDiscCback(dmConnId_t connId, uint8_t status);
+
+void ble_epic_att_api_init(void);
+void ble_epic_att_api_event(attEvt_t *att_event);
+void ble_epic_att_api_free_att_write_data(struct epic_att_write *w);
+
+void ble_epic_ble_api_trigger_event(enum epic_ble_event_type type, void *data);
+void ble_epic_ble_api_init(void);
+void ble_epic_dm_api_event(dmEvt_t *dm_event);
+void ble_epic_disc_cfg_complete(void);
+
+void ble_adv_init(void);
+void ble_adv_setup(void);
+void ble_adv_set_interval(uint32_t interval_ms);
+void ble_adv_stop(void);
+void ble_adv_start(uint8_t mode);
+void ble_adv_discoverable(bool discoverable);
+void ble_adv_proc_msg(bleMsg_t *pMsg);

epicardium/ble/ble_attc.c

+#include <stdint.h>
+#include <stdbool.h>
+
+#include "ble_api.h"
+#include "wsf_types.h"
+#include "util/bstream.h"
+#include "app_api.h"
+#include "app_cfg.h"
+#include "att_api.h"
+#include "dm_api.h"
+#include "gatt/gatt_api.h"
+#include "profiles/gap_api.h"
+#include "tipc/tipc_api.h"
+
+#include "os/core.h"
+/* card10:
+ * copied from lib/sdk/Libraries/BTLE/stack/ble-profiles/sources/apps/tag/tag_main.c
+ * and lib/sdk/Libraries/BTLE/stack/ble-profiles/sources/apps/watch/watch_main.c
+ */
+/* clang-format off */
+/* clang-formet turned off for easier diffing against orginal file */
+
+/**************************************************************************************************
+  ATT Client Discovery Data
+**************************************************************************************************/
+
+static uint16_t s_hdlList[APP_DB_HDL_LIST_LEN];
+
+/*! the Client handle list, s_hdlList[], is set as follows:
+ *
+ *  ------------------------------- <- BLE_DISC_GATT_START
+ *  | GATT svc changed handle     |
+ *  -------------------------------
+ *  | GATT svc changed ccc handle |
+ *  ------------------------------- <- BLE_DISC_GAP_START
+ *  | GAP central addr res handle |
+ *  -------------------------------
+ *  | GAP RPA Only handle         |
+ *  ------------------------------- <- BLE_DISC_CTS_START
+ *  | TIPC_CTS_CT_HDL_IDX         |
+ *  -------------------------------
+ *  | TIPC_CTS_CT_CCC_HDL_IDX     |
+ *  -------------------------------
+ *  | TIPC_CTS_LTI_HDL_IDX        |
+ *  -------------------------------
+ *  | TIPC_CTS_RTI_HDL_IDX        |
+ *  -------------------------------
+ */
+
+/*! Start of each service's handles in the the handle list */
+#define BLE_DISC_GATT_START       0
+#define BLE_DISC_GAP_START        (BLE_DISC_GATT_START + GATT_HDL_LIST_LEN)
+#define BLE_DISC_CTS_START        (BLE_DISC_GAP_START + GAP_HDL_LIST_LEN)
+#define BLE_DISC_HDL_LIST_LEN     (BLE_DISC_CTS_START + TIPC_CTS_HDL_LIST_LEN)
+
+/*! Pointers into handle list for each service's handles */
+static uint16_t *pBleGattHdlList = &s_hdlList[BLE_DISC_GATT_START];
+static uint16_t *pBleGapHdlList  = &s_hdlList[BLE_DISC_GAP_START];
+static uint16_t *pBleCtsHdlList  = &s_hdlList[BLE_DISC_CTS_START];
+
+/* sanity check:  make sure handle list length is <= app db handle list length */
+extern char wsf_ct_assert[(BLE_DISC_HDL_LIST_LEN <= APP_DB_HDL_LIST_LEN) ? 1 : -1];
+
+/**************************************************************************************************
+  ATT Client Data
+**************************************************************************************************/
+
+/* Default value for GATT service changed ccc descriptor */
+static const uint8_t bleGattScCccVal[] = {UINT16_TO_BYTES(ATT_CLIENT_CFG_INDICATE)};
+
+/* List of characteristics to configure */
+static const attcDiscCfg_t bleDiscCfgList[] =
+{
+  /* Write:  GATT service changed ccc descriptor */
+  {bleGattScCccVal, sizeof(bleGattScCccVal), (GATT_SC_CCC_HDL_IDX + BLE_DISC_GATT_START)},
+
+  {NULL, 0, (GAP_DN_HDL_IDX + BLE_DISC_GAP_START)},
+
+  /* Read: GAP central address resolution attribute */
+  {NULL, 0, (GAP_CAR_HDL_IDX + BLE_DISC_GAP_START)},
+
+  /* Read:  CTS Current time */
+  {NULL, 0, (TIPC_CTS_CT_HDL_IDX + BLE_DISC_CTS_START)},
+
+  /* Read:  CTS Local time information */
+  {NULL, 0, (TIPC_CTS_LTI_HDL_IDX + BLE_DISC_CTS_START)},
+
+  /* Read:  CTS Reference time information */
+  {NULL, 0, (TIPC_CTS_RTI_HDL_IDX + BLE_DISC_CTS_START)},
+};
+
+/* Characteristic configuration list length */
+#define BLE_DISC_CFG_LIST_LEN   (sizeof(bleDiscCfgList) / sizeof(attcDiscCfg_t))
+
+/* sanity check:  make sure configuration list length is <= handle list length */
+extern char wsf_ct_assert[(BLE_DISC_CFG_LIST_LEN <= BLE_DISC_HDL_LIST_LEN) ? 1 : -1];
+
+
+/**************************************************************************************************
+  ATT Client Discovery Data
+**************************************************************************************************/
+
+/*! Discovery states:  enumeration of services to be discovered */
+enum
+{
+  BLE_DISC_GATT_SVC,      /* GATT service */
+  BLE_DISC_GAP_SVC,       /* GAP service */
+  BLE_DISC_SLAVE_CTS_SVC,
+  BLE_DISC_SVC_MAX        /* Discovery complete */
+};
+
+/*************************************************************************************************/
+/*!
+ *  \brief  Process a received ATT indication.
+ *
+ *  \param  pMsg    Pointer to ATT callback event message.
+ *
+ *  \return None.
+ */
+/*************************************************************************************************/
+void bleValueUpdate(attEvt_t *pMsg)
+{
+  if (pMsg->hdr.status == ATT_SUCCESS)
+  {
+    /* determine which profile the handle belongs to */
+
+    /* GATT */
+    if (GattValueUpdate(pBleGattHdlList, pMsg) == ATT_SUCCESS)
+    {
+      return;
+    }
+
+    /* GAP */
+    if (GapValueUpdate(pBleGapHdlList, pMsg) == ATT_SUCCESS)
+    {
+      return;
+    }
+
+    /* current time */
+    if (TipcCtsValueUpdate(pBleCtsHdlList, pMsg) == ATT_SUCCESS)
+    {
+      return;
+    }
+
+  }
+}
+
+/*************************************************************************************************/
+/*!
+ *  \brief  GAP service discovery has completed.
+ *
+ *  \param  connId    Connection identifier.
+ *
+ *  \return None.
+ */
+/*************************************************************************************************/
+static void bleDiscGapCmpl(dmConnId_t connId)
+{
+  appDbHdl_t dbHdl;
+
+  /* if RPA Only attribute found on peer device */
+  if ((pBleGapHdlList[GAP_RPAO_HDL_IDX] != ATT_HANDLE_NONE) &&
+      ((dbHdl = AppDbGetHdl(connId)) != APP_DB_HDL_NONE))
+  {
+    /* update DB */
+    AppDbSetPeerRpao(dbHdl, TRUE);
+  }
+}
+
+/*************************************************************************************************/
+/*!
+ *  \brief  Discovery callback.
+ *
+ *  \param  connId    Connection identifier.
+ *  \param  status    Service or configuration status.
+ *
+ *  \return None.
+ */
+/*************************************************************************************************/
+void bleDiscCback(dmConnId_t connId, uint8_t status)
+{
+  static uint8_t discState;
+
+  static const char * const disc_status[] = {
+    "APP_DISC_INIT",                               /*!< \brief No discovery or configuration complete */
+    "APP_DISC_SEC_REQUIRED",                       /*!< \brief Security required to complete configuration */
+    "APP_DISC_START",                              /*!< \brief Service discovery started */
+    "APP_DISC_CMPL",                               /*!< \brief Service discovery complete */
+    "APP_DISC_FAILED",                             /*!< \brief Service discovery failed */
+    "APP_DISC_CFG_START",                          /*!< \brief Service configuration started */
+    "APP_DISC_CFG_CONN_START",                     /*!< \brief Configuration for connection setup started */
+    "APP_DISC_CFG_CMPL"                            /*!< \brief Service configuration complete */
+  };
+  LOG_INFO("ble", "bleDiscCback: %s (%d)", disc_status[status], status);
+
+  switch(status)
+  {
+    case APP_DISC_INIT:
+      /* set handle list when initialization requested */
+      AppDiscSetHdlList(connId, BLE_DISC_HDL_LIST_LEN, s_hdlList);
+      break;
+
+    case APP_DISC_SEC_REQUIRED:
+      /* request security */
+      AppSlaveSecurityReq(connId);
+      break;
+
+    case APP_DISC_START:
+      /* initialize discovery state */
+      discState = BLE_DISC_GATT_SVC;
+
+      GattDiscover(connId, pBleGattHdlList);
+      break;
+
+    case APP_DISC_FAILED:
+    case APP_DISC_CMPL:
+      if (status == APP_DISC_FAILED && pAppCfg->abortDisc)
+      {
+        if (discState == BLE_DISC_GATT_SVC)
+        {
+          /* discovery failed */
+          AppDiscComplete(connId, APP_DISC_FAILED);
+          break;
+        }
+      }
+
+      /* next discovery state */
+      discState++;
+
+      if (discState == BLE_DISC_GAP_SVC)
+      {
+        /* discover GAP service */
+        GapDiscover(connId, pBleGapHdlList);
+      }
+      else if (discState == BLE_DISC_SLAVE_CTS_SVC)
+      {
+        /* discover current time service */
+        TipcCtsDiscover(connId, pBleCtsHdlList);
+      }
+      else
+      {
+        /* discovery complete */
+        AppDiscComplete(connId, APP_DISC_CMPL);
+
+        /* GAP service discovery completed */
+        bleDiscGapCmpl(connId);
+
+        /* start configuration */
+        AppDiscConfigure(connId, APP_DISC_CFG_START, BLE_DISC_CFG_LIST_LEN,
+                         (attcDiscCfg_t *) bleDiscCfgList, BLE_DISC_HDL_LIST_LEN, s_hdlList);
+      }
+      break;
+
+    case APP_DISC_CFG_START:
+      /* start configuration */
+      AppDiscConfigure(connId, APP_DISC_CFG_START, BLE_DISC_CFG_LIST_LEN,
+                       (attcDiscCfg_t *) bleDiscCfgList, BLE_DISC_HDL_LIST_LEN, s_hdlList);
+      break;
+
+    case APP_DISC_CFG_CMPL:
+      AppDiscComplete(connId, APP_DISC_CFG_CMPL);
+      ble_epic_disc_cfg_complete();
+      break;
+
+    case APP_DISC_CFG_CONN_START:
+      /* no connection setup configuration for this application */
+      ble_epic_disc_cfg_complete();
+      break;
+
+    default:
+      break;
+  }
+}
+
+/* clang-format on */