diff options
| author | Anson Bridges <bridges.anson@gmail.com> | 2026-02-17 11:37:50 -0800 |
|---|---|---|
| committer | Anson Bridges <bridges.anson@gmail.com> | 2026-02-17 11:37:50 -0800 |
| commit | fb1611c0ca99d9e609057c46507be2af8389bb7b (patch) | |
| tree | 646ac568fdad1e6cf9e1f5767295b183bc5c5441 /firmware/memory_chip_gone/STM32_WPAN | |
| parent | 6e952fe110c2a48204c8cb0a836309ab97e5979a (diff) | |
Diffstat (limited to 'firmware/memory_chip_gone/STM32_WPAN')
| -rw-r--r-- | firmware/memory_chip_gone/STM32_WPAN/App/app_ble.c | 1432 | ||||
| -rw-r--r-- | firmware/memory_chip_gone/STM32_WPAN/App/app_ble.h | 81 | ||||
| -rw-r--r-- | firmware/memory_chip_gone/STM32_WPAN/App/ble_conf.h | 70 | ||||
| -rw-r--r-- | firmware/memory_chip_gone/STM32_WPAN/App/ble_dbg_conf.h | 198 | ||||
| -rw-r--r-- | firmware/memory_chip_gone/STM32_WPAN/App/p2p_server_app.c | 154 | ||||
| -rw-r--r-- | firmware/memory_chip_gone/STM32_WPAN/App/p2p_server_app.h | 78 | ||||
| -rw-r--r-- | firmware/memory_chip_gone/STM32_WPAN/App/tl_dbg_conf.h | 133 | ||||
| -rw-r--r-- | firmware/memory_chip_gone/STM32_WPAN/Target/hw_ipcc.c | 747 |
8 files changed, 2893 insertions, 0 deletions
diff --git a/firmware/memory_chip_gone/STM32_WPAN/App/app_ble.c b/firmware/memory_chip_gone/STM32_WPAN/App/app_ble.c new file mode 100644 index 0000000..2142009 --- /dev/null +++ b/firmware/memory_chip_gone/STM32_WPAN/App/app_ble.c @@ -0,0 +1,1432 @@ +/* USER CODE BEGIN Header */
+/**
+ ******************************************************************************
+ * @file App/app_ble.c
+ * @author MCD Application Team
+ * @brief BLE Application
+ *****************************************************************************
+ * @attention
+ *
+ * Copyright (c) 2026 STMicroelectronics.
+ * All rights reserved.
+ *
+ * This software is licensed under terms that can be found in the LICENSE file
+ * in the root directory of this software component.
+ * If no LICENSE file comes with this software, it is provided AS-IS.
+ *
+ ******************************************************************************
+ */
+/* USER CODE END Header */
+
+/* Includes ------------------------------------------------------------------*/
+#include "main.h"
+
+#include "app_common.h"
+
+#include "dbg_trace.h"
+#include "ble.h"
+#include "tl.h"
+#include "app_ble.h"
+
+#include "stm32_seq.h"
+#include "shci.h"
+#include "stm32_lpm.h"
+#include "otp.h"
+
+#include "p2p_server_app.h"
+
+/* Private includes ----------------------------------------------------------*/
+/* USER CODE BEGIN Includes */
+
+/* USER CODE END Includes */
+
+/* Private typedef -----------------------------------------------------------*/
+
+/**
+ * security parameters structure
+ */
+typedef struct _tSecurityParams
+{
+ /**
+ * IO capability of the device
+ */
+ uint8_t ioCapability;
+
+ /**
+ * Authentication requirement of the device
+ * Man In the Middle protection required?
+ */
+ uint8_t mitm_mode;
+
+ /**
+ * bonding mode of the device
+ */
+ uint8_t bonding_mode;
+
+ /**
+ * this variable indicates whether to use a fixed pin
+ * during the pairing process or a passkey has to be
+ * requested to the application during the pairing process
+ * 0 implies use fixed pin and 1 implies request for passkey
+ */
+ uint8_t Use_Fixed_Pin;
+
+ /**
+ * minimum encryption key size requirement
+ */
+ uint8_t encryptionKeySizeMin;
+
+ /**
+ * maximum encryption key size requirement
+ */
+ uint8_t encryptionKeySizeMax;
+
+ /**
+ * fixed pin to be used in the pairing process if
+ * Use_Fixed_Pin is set to 1
+ */
+ uint32_t Fixed_Pin;
+
+ /**
+ * this flag indicates whether the host has to initiate
+ * the security, wait for pairing or does not have any security
+ * requirements.
+ * 0x00 : no security required
+ * 0x01 : host should initiate security by sending the slave security
+ * request command
+ * 0x02 : host need not send the clave security request but it
+ * has to wait for paiirng to complete before doing any other
+ * processing
+ */
+ uint8_t initiateSecurity;
+ /* USER CODE BEGIN tSecurityParams*/
+
+ /* USER CODE END tSecurityParams */
+}tSecurityParams;
+
+/**
+ * global context
+ * contains the variables common to all
+ * services
+ */
+typedef struct _tBLEProfileGlobalContext
+{
+ /**
+ * security requirements of the host
+ */
+ tSecurityParams bleSecurityParam;
+
+ /**
+ * gap service handle
+ */
+ uint16_t gapServiceHandle;
+
+ /**
+ * device name characteristic handle
+ */
+ uint16_t devNameCharHandle;
+
+ /**
+ * appearance characteristic handle
+ */
+ uint16_t appearanceCharHandle;
+
+ /**
+ * connection handle of the current active connection
+ * When not in connection, the handle is set to 0xFFFF
+ */
+ uint16_t connectionHandle;
+
+ /**
+ * length of the UUID list to be used while advertising
+ */
+ uint8_t advtServUUIDlen;
+
+ /**
+ * the UUID list to be used while advertising
+ */
+ uint8_t advtServUUID[100];
+ /* USER CODE BEGIN BleGlobalContext_t*/
+
+ /* USER CODE END BleGlobalContext_t */
+}BleGlobalContext_t;
+
+typedef struct
+{
+ BleGlobalContext_t BleApplicationContext_legacy;
+ APP_BLE_ConnStatus_t Device_Connection_Status;
+
+ /**
+ * ID of the Advertising Timeout
+ */
+ uint8_t Advertising_mgr_timer_Id;
+
+ uint8_t SwitchOffGPIO_timer_Id;
+ /* USER CODE BEGIN PTD_1*/
+
+ /* USER CODE END PTD_1 */
+}BleApplicationContext_t;
+
+/* USER CODE BEGIN PTD */
+
+/* USER CODE END PTD */
+
+/* Private defines -----------------------------------------------------------*/
+#define APPBLE_GAP_DEVICE_NAME_LENGTH 7
+#define FAST_ADV_TIMEOUT (30*1000*1000/CFG_TS_TICK_VAL) /**< 30s */
+#define INITIAL_ADV_TIMEOUT (60*1000*1000/CFG_TS_TICK_VAL) /**< 60s */
+
+#define BD_ADDR_SIZE_LOCAL 6
+
+/* USER CODE BEGIN PD */
+
+/* USER CODE END PD */
+
+/* Private macro -------------------------------------------------------------*/
+/* USER CODE BEGIN PM */
+
+/* USER CODE END PM */
+
+/* Private variables ---------------------------------------------------------*/
+PLACE_IN_SECTION("MB_MEM1") ALIGN(4) static TL_CmdPacket_t BleCmdBuffer;
+
+static const uint8_t a_MBdAddr[BD_ADDR_SIZE_LOCAL] =
+{
+ (uint8_t)((CFG_ADV_BD_ADDRESS & 0x0000000000FF)),
+ (uint8_t)((CFG_ADV_BD_ADDRESS & 0x00000000FF00) >> 8),
+ (uint8_t)((CFG_ADV_BD_ADDRESS & 0x000000FF0000) >> 16),
+ (uint8_t)((CFG_ADV_BD_ADDRESS & 0x0000FF000000) >> 24),
+ (uint8_t)((CFG_ADV_BD_ADDRESS & 0x00FF00000000) >> 32),
+ (uint8_t)((CFG_ADV_BD_ADDRESS & 0xFF0000000000) >> 40)
+};
+
+static uint8_t a_BdAddrUdn[BD_ADDR_SIZE_LOCAL];
+
+/**
+ * Identity root key used to derive IRK and DHK(Legacy)
+ */
+static const uint8_t a_BLE_CfgIrValue[16] = CFG_BLE_IR;
+
+/**
+ * Encryption root key used to derive LTK(Legacy) and CSRK
+ */
+static const uint8_t a_BLE_CfgErValue[16] = CFG_BLE_ER;
+
+/**
+ * These are the two tags used to manage a power failure during OTA
+ * The MagicKeywordAdress shall be mapped @0x140 from start of the binary image
+ * The MagicKeywordvalue is checked in the ble_ota application
+ */
+PLACE_IN_SECTION("TAG_OTA_END") const uint32_t MagicKeywordValue = 0x94448A29 ;
+PLACE_IN_SECTION("TAG_OTA_START") const uint32_t MagicKeywordAddress = (uint32_t)&MagicKeywordValue;
+
+static BleApplicationContext_t BleApplicationContext;
+static uint16_t AdvIntervalMin, AdvIntervalMax;
+
+P2PS_APP_ConnHandle_Not_evt_t HandleNotification;
+
+#if (L2CAP_REQUEST_NEW_CONN_PARAM != 0)
+#define SIZE_TAB_CONN_INT 2
+float a_ConnInterval[SIZE_TAB_CONN_INT] = {50, 1000}; /* ms */
+uint8_t index_con_int, mutex;
+#endif /* L2CAP_REQUEST_NEW_CONN_PARAM != 0 */
+
+/**
+ * Advertising Data
+ */
+#if (P2P_SERVER1 != 0)
+static const char a_LocalName[] = {AD_TYPE_COMPLETE_LOCAL_NAME , 'P', '2', 'P', 'S', 'R', 'V', '1'};
+uint8_t a_ManufData[14] = {sizeof(a_ManufData)-1,
+ AD_TYPE_MANUFACTURER_SPECIFIC_DATA,
+ 0x01, /*SKD version */
+ CFG_DEV_ID_P2P_SERVER1, /* STM32WB - P2P Server 1*/
+ 0x00, /* GROUP A Feature */
+ 0x00, /* GROUP A Feature */
+ 0x00, /* GROUP B Feature */
+ 0x00, /* GROUP B Feature */
+ 0x00, /* BLE MAC start -MSB */
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00, /* BLE MAC stop */
+ };
+#endif /* P2P_SERVER1 != 0 */
+/**
+ * Advertising Data
+ */
+#if (P2P_SERVER2 != 0)
+static const char a_LocalName[] = {AD_TYPE_COMPLETE_LOCAL_NAME, 'P', '2', 'P', 'S', 'R', 'V', '2'};
+uint8_t a_ManufData[14] = {sizeof(a_ManufData)-1,
+ AD_TYPE_MANUFACTURER_SPECIFIC_DATA,
+ 0x01, /*SKD version */
+ CFG_DEV_ID_P2P_SERVER2, /* STM32WB - P2P Server 2*/
+ 0x00, /* GROUP A Feature */
+ 0x00, /* GROUP A Feature */
+ 0x00, /* GROUP B Feature */
+ 0x00, /* GROUP B Feature */
+ 0x00, /* BLE MAC start -MSB */
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00, /* BLE MAC stop */
+ };
+
+#endif /* P2P_SERVER2 != 0 */
+
+#if (P2P_SERVER3 != 0)
+static const char a_LocalName[] = {AD_TYPE_COMPLETE_LOCAL_NAME, 'P', '2', 'P', 'S', 'R', 'V', '3'};
+uint8_t a_ManufData[14] = {sizeof(a_ManufData)-1,
+ AD_TYPE_MANUFACTURER_SPECIFIC_DATA,
+ 0x01, /*SKD version */
+ CFG_DEV_ID_P2P_SERVER3, /* STM32WB - P2P Server 3*/
+ 0x00, /* GROUP A Feature */
+ 0x00, /* GROUP A Feature */
+ 0x00, /* GROUP B Feature */
+ 0x00, /* GROUP B Feature */
+ 0x00, /* BLE MAC start -MSB */
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00, /* BLE MAC stop */
+ };
+#endif /* P2P_SERVER3 != 0 */
+
+#if (P2P_SERVER4 != 0)
+static const char a_LocalName[] = {AD_TYPE_COMPLETE_LOCAL_NAME, 'P', '2', 'P', 'S', 'R', 'V', '4'};
+uint8_t a_ManufData[14] = {sizeof(a_ManufData)-1,
+ AD_TYPE_MANUFACTURER_SPECIFIC_DATA,
+ 0x01, /*SKD version */
+ CFG_DEV_ID_P2P_SERVER4, /* STM32WB - P2P Server 4*/
+ 0x00, /* GROUP A Feature */
+ 0x00, /* GROUP A Feature */
+ 0x00, /* GROUP B Feature */
+ 0x00, /* GROUP B Feature */
+ 0x00, /* BLE MAC start -MSB */
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00, /* BLE MAC stop */
+ };
+#endif /* P2P_SERVER4 != 0 */
+
+#if (P2P_SERVER5 != 0)
+static const char a_LocalName[] = {AD_TYPE_COMPLETE_LOCAL_NAME, 'P', '2', 'P', 'S', 'R', 'V', '5'};
+uint8_t a_ManufData[14] = {sizeof(a_ManufData)-1,
+ AD_TYPE_MANUFACTURER_SPECIFIC_DATA,
+ 0x01, /*SKD version */
+ CFG_DEV_ID_P2P_SERVER5, /* STM32WB - P2P Server 5*/
+ 0x00, /* GROUP A Feature */
+ 0x00, /* GROUP A Feature */
+ 0x00, /* GROUP B Feature */
+ 0x00, /* GROUP B Feature */
+ 0x00, /* BLE MAC start -MSB */
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00, /* BLE MAC stop */
+ };
+#endif /* P2P_SERVER5 != 0 */
+
+#if (P2P_SERVER6 != 0)
+static const char a_LocalName[] = {AD_TYPE_COMPLETE_LOCAL_NAME, 'P', '2', 'P', 'S', 'R', 'V', '6'};
+uint8_t a_ManufData[14] = {sizeof(a_ManufData)-1,
+ AD_TYPE_MANUFACTURER_SPECIFIC_DATA,
+ 0x01, /*SKD version */
+ CFG_DEV_ID_P2P_SERVER6, /* STM32WB - P2P Server 6*/
+ 0x00, /* GROUP A Feature */
+ 0x00, /* GROUP A Feature */
+ 0x00, /* GROUP B Feature */
+ 0x00, /* GROUP B Feature */
+ 0x00, /* BLE MAC start -MSB */
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x00, /* BLE MAC stop */
+ };
+#endif /* P2P_SERVER6 != 0 */
+
+/* USER CODE BEGIN PV */
+
+/* USER CODE END PV */
+
+/* Private function prototypes -----------------------------------------------*/
+static void BLE_UserEvtRx(void *p_Payload);
+static void BLE_StatusNot(HCI_TL_CmdStatus_t Status);
+static void Ble_Tl_Init(void);
+static void Ble_Hci_Gap_Gatt_Init(void);
+static const uint8_t* BleGetBdAddress(void);
+static void Adv_Request(APP_BLE_ConnStatus_t NewStatus);
+static void Adv_Cancel(void);
+static void Adv_Cancel_Req(void);
+static void Switch_OFF_GPIO(void);
+#if (L2CAP_REQUEST_NEW_CONN_PARAM != 0)
+static void BLE_SVC_L2CAP_Conn_Update(uint16_t ConnectionHandle);
+static void Connection_Interval_Update_Req(void);
+#endif /* L2CAP_REQUEST_NEW_CONN_PARAM != 0 */
+
+/* USER CODE BEGIN PFP */
+
+/* USER CODE END PFP */
+
+/* External variables --------------------------------------------------------*/
+
+/* USER CODE BEGIN EV */
+
+/* USER CODE END EV */
+
+/* Functions Definition ------------------------------------------------------*/
+void APP_BLE_Init(void)
+{
+ SHCI_CmdStatus_t status;
+#if (RADIO_ACTIVITY_EVENT != 0)
+ tBleStatus ret = BLE_STATUS_INVALID_PARAMS;
+#endif /* RADIO_ACTIVITY_EVENT != 0 */
+ /* USER CODE BEGIN APP_BLE_Init_1 */
+
+ /* USER CODE END APP_BLE_Init_1 */
+ SHCI_C2_Ble_Init_Cmd_Packet_t ble_init_cmd_packet =
+ {
+ {{0,0,0}}, /**< Header unused */
+ {0, /** pBleBufferAddress not used */
+ 0, /** BleBufferSize not used */
+ CFG_BLE_NUM_GATT_ATTRIBUTES,
+ CFG_BLE_NUM_GATT_SERVICES,
+ CFG_BLE_ATT_VALUE_ARRAY_SIZE,
+ CFG_BLE_NUM_LINK,
+ CFG_BLE_DATA_LENGTH_EXTENSION,
+ CFG_BLE_PREPARE_WRITE_LIST_SIZE,
+ CFG_BLE_MBLOCK_COUNT,
+ CFG_BLE_MAX_ATT_MTU,
+ CFG_BLE_PERIPHERAL_SCA,
+ CFG_BLE_CENTRAL_SCA,
+ CFG_BLE_LS_SOURCE,
+ CFG_BLE_MAX_CONN_EVENT_LENGTH,
+ CFG_BLE_HSE_STARTUP_TIME,
+ CFG_BLE_VITERBI_MODE,
+ CFG_BLE_OPTIONS,
+ 0,
+ CFG_BLE_MAX_COC_INITIATOR_NBR,
+ CFG_BLE_MIN_TX_POWER,
+ CFG_BLE_MAX_TX_POWER,
+ CFG_BLE_RX_MODEL_CONFIG,
+ CFG_BLE_MAX_ADV_SET_NBR,
+ CFG_BLE_MAX_ADV_DATA_LEN,
+ CFG_BLE_TX_PATH_COMPENS,
+ CFG_BLE_RX_PATH_COMPENS,
+ CFG_BLE_CORE_VERSION,
+ CFG_BLE_OPTIONS_EXT,
+ CFG_BLE_MAX_ADD_EATT_BEARERS
+ }
+ };
+
+ /**
+ * Initialize Ble Transport Layer
+ */
+ Ble_Tl_Init();
+
+ /**
+ * Do not allow standby in the application
+ */
+ UTIL_LPM_SetOffMode(1 << CFG_LPM_APP_BLE, UTIL_LPM_DISABLE);
+
+ /**
+ * Register the hci transport layer to handle BLE User Asynchronous Events
+ */
+ UTIL_SEQ_RegTask(1<<CFG_TASK_HCI_ASYNCH_EVT_ID, UTIL_SEQ_RFU, hci_user_evt_proc);
+
+ /**
+ * Starts the BLE Stack on CPU2
+ */
+ status = SHCI_C2_BLE_Init(&ble_init_cmd_packet);
+ if (status != SHCI_Success)
+ {
+ APP_DBG_MSG(" Fail : SHCI_C2_BLE_Init command, result: 0x%02x\n\r", status);
+ /* if you are here, maybe CPU2 doesn't contain STM32WB_Copro_Wireless_Binaries, see Release_Notes.html */
+ Error_Handler();
+ }
+ else
+ {
+ APP_DBG_MSG(" Success: SHCI_C2_BLE_Init command\n\r");
+ }
+
+ /**
+ * Initialization of HCI & GATT & GAP layer
+ */
+ Ble_Hci_Gap_Gatt_Init();
+
+ /**
+ * Initialization of the BLE Services
+ */
+ SVCCTL_Init();
+
+ /**
+ * Initialization of the BLE App Context
+ */
+ BleApplicationContext.Device_Connection_Status = APP_BLE_IDLE;
+ BleApplicationContext.BleApplicationContext_legacy.connectionHandle = 0xFFFF;
+
+ /**
+ * From here, all initialization are BLE application specific
+ */
+ UTIL_SEQ_RegTask(1<<CFG_TASK_ADV_CANCEL_ID, UTIL_SEQ_RFU, Adv_Cancel);
+#if (L2CAP_REQUEST_NEW_CONN_PARAM != 0)
+ UTIL_SEQ_RegTask(1<<CFG_TASK_CONN_UPDATE_REG_ID, UTIL_SEQ_RFU, Connection_Interval_Update_Req);
+#endif /* L2CAP_REQUEST_NEW_CONN_PARAM != 0 */
+
+ /**
+ * Initialization of ADV - Ad Manufacturer Element - Support OTA Bit Mask
+ */
+#if (BLE_CFG_OTA_REBOOT_CHAR != 0)
+ a_ManufData[sizeof(a_ManufData)-8] = CFG_FEATURE_OTA_REBOOT;
+#endif /* BLE_CFG_OTA_REBOOT_CHAR != 0 */
+
+#if (RADIO_ACTIVITY_EVENT != 0)
+ ret = aci_hal_set_radio_activity_mask(0x0006);
+ if (ret != BLE_STATUS_SUCCESS)
+ {
+ APP_DBG_MSG(" Fail : aci_hal_set_radio_activity_mask command, result: 0x%x \n\r", ret);
+ }
+ else
+ {
+ APP_DBG_MSG(" Success: aci_hal_set_radio_activity_mask command\n\r");
+ }
+#endif /* RADIO_ACTIVITY_EVENT != 0 */
+
+#if (L2CAP_REQUEST_NEW_CONN_PARAM != 0)
+ index_con_int = 0;
+ mutex = 1;
+#endif /* L2CAP_REQUEST_NEW_CONN_PARAM != 0 */
+
+ /**
+ * Initialize P2P Server Application
+ */
+ P2PS_APP_Init();
+
+ /* USER CODE BEGIN APP_BLE_Init_3 */
+
+ /* USER CODE END APP_BLE_Init_3 */
+
+ /**
+ * Create timer to handle the Advertising Stop
+ */
+ HW_TS_Create(CFG_TIM_PROC_ID_ISR, &(BleApplicationContext.Advertising_mgr_timer_Id), hw_ts_SingleShot, Adv_Cancel_Req);
+ /**
+ * Create timer to handle the Led Switch OFF
+ */
+ HW_TS_Create(CFG_TIM_PROC_ID_ISR, &(BleApplicationContext.SwitchOffGPIO_timer_Id), hw_ts_SingleShot, Switch_OFF_GPIO);
+
+ /**
+ * Make device discoverable
+ */
+ BleApplicationContext.BleApplicationContext_legacy.advtServUUID[0] = NULL;
+ BleApplicationContext.BleApplicationContext_legacy.advtServUUIDlen = 0;
+
+ /* Initialize intervals for reconnexion without intervals update */
+ AdvIntervalMin = CFG_FAST_CONN_ADV_INTERVAL_MIN;
+ AdvIntervalMax = CFG_FAST_CONN_ADV_INTERVAL_MAX;
+
+ /**
+ * Start to Advertise to be connected by P2P Client
+ */
+ Adv_Request(APP_BLE_FAST_ADV);
+
+ /* USER CODE BEGIN APP_BLE_Init_2 */
+
+ /* USER CODE END APP_BLE_Init_2 */
+
+ return;
+}
+
+SVCCTL_UserEvtFlowStatus_t SVCCTL_App_Notification(void *p_Pckt)
+{
+ hci_event_pckt *p_event_pckt;
+ evt_le_meta_event *p_meta_evt;
+ evt_blecore_aci *p_blecore_evt;
+ uint8_t Tx_phy, Rx_phy;
+ tBleStatus ret = BLE_STATUS_INVALID_PARAMS;
+ hci_le_connection_complete_event_rp0 *p_connection_complete_event;
+ hci_disconnection_complete_event_rp0 *p_disconnection_complete_event;
+ hci_le_phy_update_complete_event_rp0 *p_evt_le_phy_update_complete;
+#if (CFG_DEBUG_APP_TRACE != 0)
+ hci_le_connection_update_complete_event_rp0 *p_connection_update_complete_event;
+#endif /* CFG_DEBUG_APP_TRACE != 0 */
+
+ /* USER CODE BEGIN SVCCTL_App_Notification */
+
+ /* USER CODE END SVCCTL_App_Notification */
+
+ p_event_pckt = (hci_event_pckt*) ((hci_uart_pckt *) p_Pckt)->data;
+
+ switch (p_event_pckt->evt)
+ {
+ case HCI_DISCONNECTION_COMPLETE_EVT_CODE:
+ {
+ p_disconnection_complete_event = (hci_disconnection_complete_event_rp0 *) p_event_pckt->data;
+
+ if (p_disconnection_complete_event->Connection_Handle == BleApplicationContext.BleApplicationContext_legacy.connectionHandle)
+ {
+ BleApplicationContext.BleApplicationContext_legacy.connectionHandle = 0;
+ BleApplicationContext.Device_Connection_Status = APP_BLE_IDLE;
+ APP_DBG_MSG(">>== HCI_DISCONNECTION_COMPLETE_EVT_CODE\n");
+ APP_DBG_MSG(" - Connection Handle: 0x%x\n - Reason: 0x%x\n\r",
+ p_disconnection_complete_event->Connection_Handle,
+ p_disconnection_complete_event->Reason);
+
+ /* USER CODE BEGIN EVT_DISCONN_COMPLETE_2 */
+
+ /* USER CODE END EVT_DISCONN_COMPLETE_2 */
+ }
+
+ /* USER CODE BEGIN EVT_DISCONN_COMPLETE_1 */
+
+ /* USER CODE END EVT_DISCONN_COMPLETE_1 */
+
+ /* restart advertising */
+ Adv_Request(APP_BLE_FAST_ADV);
+
+ /**
+ * SPECIFIC to P2P Server APP
+ */
+ HandleNotification.P2P_Evt_Opcode = PEER_DISCON_HANDLE_EVT;
+ HandleNotification.ConnectionHandle = BleApplicationContext.BleApplicationContext_legacy.connectionHandle;
+ P2PS_APP_Notification(&HandleNotification);
+ /* USER CODE BEGIN EVT_DISCONN_COMPLETE */
+
+ /* USER CODE END EVT_DISCONN_COMPLETE */
+ break; /* HCI_DISCONNECTION_COMPLETE_EVT_CODE */
+ }
+
+ case HCI_LE_META_EVT_CODE:
+ {
+ p_meta_evt = (evt_le_meta_event*) p_event_pckt->data;
+ /* USER CODE BEGIN EVT_LE_META_EVENT */
+
+ /* USER CODE END EVT_LE_META_EVENT */
+ switch (p_meta_evt->subevent)
+ {
+ case HCI_LE_CONNECTION_UPDATE_COMPLETE_SUBEVT_CODE:
+#if (CFG_DEBUG_APP_TRACE != 0)
+ p_connection_update_complete_event = (hci_le_connection_update_complete_event_rp0 *) p_meta_evt->data;
+ APP_DBG_MSG(">>== HCI_LE_CONNECTION_UPDATE_COMPLETE_SUBEVT_CODE\n");
+ APP_DBG_MSG(" - Connection Interval: %.2f ms\n - Connection latency: %d\n - Supervision Timeout: %d ms\n\r",
+ p_connection_update_complete_event->Conn_Interval*1.25,
+ p_connection_update_complete_event->Conn_Latency,
+ p_connection_update_complete_event->Supervision_Timeout*10);
+#endif /* CFG_DEBUG_APP_TRACE != 0 */
+
+ /* USER CODE BEGIN EVT_LE_CONN_UPDATE_COMPLETE */
+
+ /* USER CODE END EVT_LE_CONN_UPDATE_COMPLETE */
+ break;
+
+ case HCI_LE_PHY_UPDATE_COMPLETE_SUBEVT_CODE:
+ p_evt_le_phy_update_complete = (hci_le_phy_update_complete_event_rp0*)p_meta_evt->data;
+ APP_DBG_MSG("==>> HCI_LE_PHY_UPDATE_COMPLETE_SUBEVT_CODE - ");
+ if (p_evt_le_phy_update_complete->Status == 0)
+ {
+ APP_DBG_MSG("status ok \n");
+ }
+ else
+ {
+ APP_DBG_MSG("status nok \n");
+ }
+
+ ret = hci_le_read_phy(BleApplicationContext.BleApplicationContext_legacy.connectionHandle, &Tx_phy, &Rx_phy);
+ if (ret != BLE_STATUS_SUCCESS)
+ {
+ APP_DBG_MSG("==>> hci_le_read_phy : fail\n\r");
+ }
+ else
+ {
+ APP_DBG_MSG("==>> hci_le_read_phy - Success \n");
+
+ if ((Tx_phy == TX_2M) && (Rx_phy == RX_2M))
+ {
+ APP_DBG_MSG("==>> PHY Param TX= %d, RX= %d \n\r", Tx_phy, Rx_phy);
+ }
+ else
+ {
+ APP_DBG_MSG("==>> PHY Param TX= %d, RX= %d \n\r", Tx_phy, Rx_phy);
+ }
+ }
+ /* USER CODE BEGIN EVT_LE_PHY_UPDATE_COMPLETE */
+
+ /* USER CODE END EVT_LE_PHY_UPDATE_COMPLETE */
+ break;
+
+ case HCI_LE_CONNECTION_COMPLETE_SUBEVT_CODE:
+ {
+ p_connection_complete_event = (hci_le_connection_complete_event_rp0 *) p_meta_evt->data;
+ /**
+ * The connection is done, there is no need anymore to schedule the LP ADV
+ */
+
+ HW_TS_Stop(BleApplicationContext.Advertising_mgr_timer_Id);
+
+ APP_DBG_MSG(">>== HCI_LE_CONNECTION_COMPLETE_SUBEVT_CODE - Connection handle: 0x%x\n", p_connection_complete_event->Connection_Handle);
+ APP_DBG_MSG(" - Connection established with Central: @:%02x:%02x:%02x:%02x:%02x:%02x\n",
+ p_connection_complete_event->Peer_Address[5],
+ p_connection_complete_event->Peer_Address[4],
+ p_connection_complete_event->Peer_Address[3],
+ p_connection_complete_event->Peer_Address[2],
+ p_connection_complete_event->Peer_Address[1],
+ p_connection_complete_event->Peer_Address[0]);
+ APP_DBG_MSG(" - Connection Interval: %.2f ms\n - Connection latency: %d\n - Supervision Timeout: %d ms\n\r",
+ p_connection_complete_event->Conn_Interval*1.25,
+ p_connection_complete_event->Conn_Latency,
+ p_connection_complete_event->Supervision_Timeout*10
+ );
+
+ if (BleApplicationContext.Device_Connection_Status == APP_BLE_LP_CONNECTING)
+ {
+ /* Connection as client */
+ BleApplicationContext.Device_Connection_Status = APP_BLE_CONNECTED_CLIENT;
+ }
+ else
+ {
+ /* Connection as server */
+ BleApplicationContext.Device_Connection_Status = APP_BLE_CONNECTED_SERVER;
+ }
+ BleApplicationContext.BleApplicationContext_legacy.connectionHandle = p_connection_complete_event->Connection_Handle;
+ /**
+ * SPECIFIC to P2P Server APP
+ */
+ HandleNotification.P2P_Evt_Opcode = PEER_CONN_HANDLE_EVT;
+ HandleNotification.ConnectionHandle = BleApplicationContext.BleApplicationContext_legacy.connectionHandle;
+ P2PS_APP_Notification(&HandleNotification);
+ /* USER CODE BEGIN HCI_EVT_LE_CONN_COMPLETE */
+
+ /* USER CODE END HCI_EVT_LE_CONN_COMPLETE */
+ break; /* HCI_LE_CONNECTION_COMPLETE_SUBEVT_CODE */
+ }
+
+ default:
+ /* USER CODE BEGIN SUBEVENT_DEFAULT */
+
+ /* USER CODE END SUBEVENT_DEFAULT */
+ break;
+ }
+
+ /* USER CODE BEGIN META_EVT */
+
+ /* USER CODE END META_EVT */
+ break; /* HCI_LE_META_EVT_CODE */
+ }
+
+ case HCI_VENDOR_SPECIFIC_DEBUG_EVT_CODE:
+ p_blecore_evt = (evt_blecore_aci*) p_event_pckt->data;
+ /* USER CODE BEGIN EVT_VENDOR */
+
+ /* USER CODE END EVT_VENDOR */
+ switch (p_blecore_evt->ecode)
+ {
+ /* USER CODE BEGIN ecode */
+
+ /* USER CODE END ecode */
+
+ /**
+ * SPECIFIC to P2P Server APP
+ */
+ case ACI_L2CAP_CONNECTION_UPDATE_RESP_VSEVT_CODE:
+#if (L2CAP_REQUEST_NEW_CONN_PARAM != 0)
+ mutex = 1;
+#endif /* L2CAP_REQUEST_NEW_CONN_PARAM != 0 */
+ /* USER CODE BEGIN EVT_BLUE_L2CAP_CONNECTION_UPDATE_RESP */
+
+ /* USER CODE END EVT_BLUE_L2CAP_CONNECTION_UPDATE_RESP */
+ break;
+
+ case ACI_GAP_PROC_COMPLETE_VSEVT_CODE:
+ APP_DBG_MSG(">>== ACI_GAP_PROC_COMPLETE_VSEVT_CODE \r");
+ /* USER CODE BEGIN EVT_BLUE_GAP_PROCEDURE_COMPLETE */
+
+ /* USER CODE END EVT_BLUE_GAP_PROCEDURE_COMPLETE */
+ break; /* ACI_GAP_PROC_COMPLETE_VSEVT_CODE */
+
+#if (RADIO_ACTIVITY_EVENT != 0)
+ case ACI_HAL_END_OF_RADIO_ACTIVITY_VSEVT_CODE:
+ /* USER CODE BEGIN RADIO_ACTIVITY_EVENT*/
+
+ /* USER CODE END RADIO_ACTIVITY_EVENT*/
+ break; /* ACI_HAL_END_OF_RADIO_ACTIVITY_VSEVT_CODE */
+#endif /* RADIO_ACTIVITY_EVENT != 0 */
+
+ case ACI_GATT_INDICATION_VSEVT_CODE:
+ {
+ APP_DBG_MSG(">>== ACI_GATT_INDICATION_VSEVT_CODE \r");
+ aci_gatt_confirm_indication(BleApplicationContext.BleApplicationContext_legacy.connectionHandle);
+ }
+ break;
+
+ /* USER CODE BEGIN BLUE_EVT */
+
+ /* USER CODE END BLUE_EVT */
+ }
+ break; /* HCI_VENDOR_SPECIFIC_DEBUG_EVT_CODE */
+
+ /* USER CODE BEGIN EVENT_PCKT */
+
+ /* USER CODE END EVENT_PCKT */
+
+ default:
+ /* USER CODE BEGIN ECODE_DEFAULT*/
+
+ /* USER CODE END ECODE_DEFAULT*/
+ break;
+ }
+
+ return (SVCCTL_UserEvtFlowEnable);
+}
+
+APP_BLE_ConnStatus_t APP_BLE_Get_Server_Connection_Status(void)
+{
+ return BleApplicationContext.Device_Connection_Status;
+}
+
+/* USER CODE BEGIN FD*/
+
+/* USER CODE END FD*/
+
+/*************************************************************
+ *
+ * LOCAL FUNCTIONS
+ *
+ *************************************************************/
+static void Ble_Tl_Init(void)
+{
+ HCI_TL_HciInitConf_t Hci_Tl_Init_Conf;
+
+ Hci_Tl_Init_Conf.p_cmdbuffer = (uint8_t*)&BleCmdBuffer;
+ Hci_Tl_Init_Conf.StatusNotCallBack = BLE_StatusNot;
+ hci_init(BLE_UserEvtRx, (void*) &Hci_Tl_Init_Conf);
+
+ return;
+}
+
+static void Ble_Hci_Gap_Gatt_Init(void)
+{
+ uint8_t role;
+ uint16_t gap_service_handle, gap_dev_name_char_handle, gap_appearance_char_handle;
+ const uint8_t *p_bd_addr;
+ uint16_t a_appearance[1] = {BLE_CFG_GAP_APPEARANCE};
+ tBleStatus ret = BLE_STATUS_INVALID_PARAMS;
+ /* USER CODE BEGIN Ble_Hci_Gap_Gatt_Init*/
+
+ /* USER CODE END Ble_Hci_Gap_Gatt_Init*/
+
+ APP_DBG_MSG("==>> Start Ble_Hci_Gap_Gatt_Init function\n");
+
+ /**
+ * Initialize HCI layer
+ */
+ /*HCI Reset to synchronise BLE Stack*/
+ ret = hci_reset();
+ if (ret != BLE_STATUS_SUCCESS)
+ {
+ APP_DBG_MSG(" Fail : hci_reset command, result: 0x%x \n", ret);
+ }
+ else
+ {
+ APP_DBG_MSG(" Success: hci_reset command\n");
+ }
+
+ /**
+ * Write the BD Address
+ */
+ p_bd_addr = BleGetBdAddress();
+ ret = aci_hal_write_config_data(CONFIG_DATA_PUBLIC_ADDRESS_OFFSET, CONFIG_DATA_PUBLIC_ADDRESS_LEN, (uint8_t*) p_bd_addr);
+ if (ret != BLE_STATUS_SUCCESS)
+ {
+ APP_DBG_MSG(" Fail : aci_hal_write_config_data command - CONFIG_DATA_PUBLIC_ADDRESS_OFFSET, result: 0x%x \n", ret);
+ }
+ else
+ {
+ APP_DBG_MSG(" Success: aci_hal_write_config_data command - CONFIG_DATA_PUBLIC_ADDRESS_OFFSET\n");
+ APP_DBG_MSG(" Public Bluetooth Address: %02x:%02x:%02x:%02x:%02x:%02x\n",p_bd_addr[5],p_bd_addr[4],p_bd_addr[3],p_bd_addr[2],p_bd_addr[1],p_bd_addr[0]);
+ }
+
+#if (CFG_BLE_ADDRESS_TYPE == GAP_PUBLIC_ADDR)
+ /* BLE MAC in ADV Packet */
+ a_ManufData[ sizeof(a_ManufData)-6] = p_bd_addr[5];
+ a_ManufData[ sizeof(a_ManufData)-5] = p_bd_addr[4];
+ a_ManufData[ sizeof(a_ManufData)-4] = p_bd_addr[3];
+ a_ManufData[ sizeof(a_ManufData)-3] = p_bd_addr[2];
+ a_ManufData[ sizeof(a_ManufData)-2] = p_bd_addr[1];
+ a_ManufData[ sizeof(a_ManufData)-1] = p_bd_addr[0];
+#endif /* CFG_BLE_ADDRESS_TYPE == GAP_PUBLIC_ADDR */
+
+ /**
+ * Static random Address
+ * The two upper bits shall be set to 1
+ * The lowest 32bits is read from the UDN to differentiate between devices
+ * The RNG may be used to provide a random number on each power on
+ */
+#if (CFG_BLE_ADDRESS_TYPE != GAP_PUBLIC_ADDR)
+ /* BLE MAC in ADV Packet */
+ a_ManufData[ sizeof(a_ManufData)-6] = a_srd_bd_addr[1] >> 8 ;
+ a_ManufData[ sizeof(a_ManufData)-5] = a_srd_bd_addr[1];
+ a_ManufData[ sizeof(a_ManufData)-4] = a_srd_bd_addr[0] >> 24;
+ a_ManufData[ sizeof(a_ManufData)-3] = a_srd_bd_addr[0] >> 16;
+ a_ManufData[ sizeof(a_ManufData)-2] = a_srd_bd_addr[0] >> 8;
+ a_ManufData[ sizeof(a_ManufData)-1] = a_srd_bd_addr[0];
+
+ ret = aci_hal_write_config_data(CONFIG_DATA_RANDOM_ADDRESS_OFFSET, CONFIG_DATA_RANDOM_ADDRESS_LEN, (uint8_t*)a_srd_bd_addr);
+ if (ret != BLE_STATUS_SUCCESS)
+ {
+ APP_DBG_MSG(" Fail : aci_hal_write_config_data command - CONFIG_DATA_RANDOM_ADDRESS_OFFSET, result: 0x%x \n", ret);
+ }
+ else
+ {
+ APP_DBG_MSG(" Success: aci_hal_write_config_data command - CONFIG_DATA_RANDOM_ADDRESS_OFFSET\n");
+ APP_DBG_MSG(" Random Bluetooth Address: %02x:%02x:%02x:%02x:%02x:%02x\n", (uint8_t)(a_srd_bd_addr[1] >> 8),
+ (uint8_t)(a_srd_bd_addr[1]),
+ (uint8_t)(a_srd_bd_addr[0] >> 24),
+ (uint8_t)(a_srd_bd_addr[0] >> 16),
+ (uint8_t)(a_srd_bd_addr[0] >> 8),
+ (uint8_t)(a_srd_bd_addr[0]));
+ }
+#endif /* CFG_BLE_ADDRESS_TYPE != GAP_PUBLIC_ADDR */
+
+ /**
+ * Write Identity root key used to derive IRK and DHK(Legacy)
+ */
+ ret = aci_hal_write_config_data(CONFIG_DATA_IR_OFFSET, CONFIG_DATA_IR_LEN, (uint8_t*)a_BLE_CfgIrValue);
+ if (ret != BLE_STATUS_SUCCESS)
+ {
+ APP_DBG_MSG(" Fail : aci_hal_write_config_data command - CONFIG_DATA_IR_OFFSET, result: 0x%x \n", ret);
+ }
+ else
+ {
+ APP_DBG_MSG(" Success: aci_hal_write_config_data command - CONFIG_DATA_IR_OFFSET\n");
+ }
+
+ /**
+ * Write Encryption root key used to derive LTK and CSRK
+ */
+ ret = aci_hal_write_config_data(CONFIG_DATA_ER_OFFSET, CONFIG_DATA_ER_LEN, (uint8_t*)a_BLE_CfgErValue);
+ if (ret != BLE_STATUS_SUCCESS)
+ {
+ APP_DBG_MSG(" Fail : aci_hal_write_config_data command - CONFIG_DATA_ER_OFFSET, result: 0x%x \n", ret);
+ }
+ else
+ {
+ APP_DBG_MSG(" Success: aci_hal_write_config_data command - CONFIG_DATA_ER_OFFSET\n");
+ }
+
+ /**
+ * Set TX Power.
+ */
+ ret = aci_hal_set_tx_power_level(1, CFG_TX_POWER);
+ if (ret != BLE_STATUS_SUCCESS)
+ {
+ APP_DBG_MSG(" Fail : aci_hal_set_tx_power_level command, result: 0x%x \n", ret);
+ }
+ else
+ {
+ APP_DBG_MSG(" Success: aci_hal_set_tx_power_level command\n");
+ }
+
+ /**
+ * Initialize GATT interface
+ */
+ ret = aci_gatt_init();
+ if (ret != BLE_STATUS_SUCCESS)
+ {
+ APP_DBG_MSG(" Fail : aci_gatt_init command, result: 0x%x \n", ret);
+ }
+ else
+ {
+ APP_DBG_MSG(" Success: aci_gatt_init command\n");
+ }
+
+ /**
+ * Initialize GAP interface
+ */
+ role = 0;
+
+#if (BLE_CFG_PERIPHERAL == 1)
+ role |= GAP_PERIPHERAL_ROLE;
+#endif /* BLE_CFG_PERIPHERAL == 1 */
+
+#if (BLE_CFG_CENTRAL == 1)
+ role |= GAP_CENTRAL_ROLE;
+#endif /* BLE_CFG_CENTRAL == 1 */
+
+/* USER CODE BEGIN Role_Mngt*/
+
+/* USER CODE END Role_Mngt */
+
+ if (role > 0)
+ {
+ const char *name = "P2PSRV1";
+ ret = aci_gap_init(role,
+ CFG_PRIVACY,
+ APPBLE_GAP_DEVICE_NAME_LENGTH,
+ &gap_service_handle,
+ &gap_dev_name_char_handle,
+ &gap_appearance_char_handle);
+
+ if (ret != BLE_STATUS_SUCCESS)
+ {
+ APP_DBG_MSG(" Fail : aci_gap_init command, result: 0x%x \n", ret);
+ }
+ else
+ {
+ APP_DBG_MSG(" Success: aci_gap_init command\n");
+ }
+
+ ret = aci_gatt_update_char_value(gap_service_handle, gap_dev_name_char_handle, 0, strlen(name), (uint8_t *) name);
+ if (ret != BLE_STATUS_SUCCESS)
+ {
+ BLE_DBG_SVCCTL_MSG(" Fail : aci_gatt_update_char_value - Device Name\n");
+ }
+ else
+ {
+ BLE_DBG_SVCCTL_MSG(" Success: aci_gatt_update_char_value - Device Name\n");
+ }
+ }
+
+ ret = aci_gatt_update_char_value(gap_service_handle,
+ gap_appearance_char_handle,
+ 0,
+ 2,
+ (uint8_t *)&a_appearance);
+ if (ret != BLE_STATUS_SUCCESS)
+ {
+ BLE_DBG_SVCCTL_MSG(" Fail : aci_gatt_update_char_value - Appearance\n");
+ }
+ else
+ {
+ BLE_DBG_SVCCTL_MSG(" Success: aci_gatt_update_char_value - Appearance\n");
+ }
+
+ /**
+ * Initialize Default PHY
+ */
+ ret = hci_le_set_default_phy(ALL_PHYS_PREFERENCE,TX_2M_PREFERRED,RX_2M_PREFERRED);
+ if (ret != BLE_STATUS_SUCCESS)
+ {
+ APP_DBG_MSG(" Fail : hci_le_set_default_phy command, result: 0x%x \n", ret);
+ }
+ else
+ {
+ APP_DBG_MSG(" Success: hci_le_set_default_phy command\n");
+ }
+
+ /**
+ * Initialize IO capability
+ */
+ BleApplicationContext.BleApplicationContext_legacy.bleSecurityParam.ioCapability = CFG_IO_CAPABILITY;
+ ret = aci_gap_set_io_capability(BleApplicationContext.BleApplicationContext_legacy.bleSecurityParam.ioCapability);
+ if (ret != BLE_STATUS_SUCCESS)
+ {
+ APP_DBG_MSG(" Fail : aci_gap_set_io_capability command, result: 0x%x \n", ret);
+ }
+ else
+ {
+ APP_DBG_MSG(" Success: aci_gap_set_io_capability command\n");
+ }
+
+ /**
+ * Initialize authentication
+ */
+ BleApplicationContext.BleApplicationContext_legacy.bleSecurityParam.mitm_mode = CFG_MITM_PROTECTION;
+ BleApplicationContext.BleApplicationContext_legacy.bleSecurityParam.encryptionKeySizeMin = CFG_ENCRYPTION_KEY_SIZE_MIN;
+ BleApplicationContext.BleApplicationContext_legacy.bleSecurityParam.encryptionKeySizeMax = CFG_ENCRYPTION_KEY_SIZE_MAX;
+ BleApplicationContext.BleApplicationContext_legacy.bleSecurityParam.Use_Fixed_Pin = CFG_USED_FIXED_PIN;
+ BleApplicationContext.BleApplicationContext_legacy.bleSecurityParam.Fixed_Pin = CFG_FIXED_PIN;
+ BleApplicationContext.BleApplicationContext_legacy.bleSecurityParam.bonding_mode = CFG_BONDING_MODE;
+ /* USER CODE BEGIN Ble_Hci_Gap_Gatt_Init_1*/
+
+ /* USER CODE END Ble_Hci_Gap_Gatt_Init_1*/
+
+ ret = aci_gap_set_authentication_requirement(BleApplicationContext.BleApplicationContext_legacy.bleSecurityParam.bonding_mode,
+ BleApplicationContext.BleApplicationContext_legacy.bleSecurityParam.mitm_mode,
+ CFG_SC_SUPPORT,
+ CFG_KEYPRESS_NOTIFICATION_SUPPORT,
+ BleApplicationContext.BleApplicationContext_legacy.bleSecurityParam.encryptionKeySizeMin,
+ BleApplicationContext.BleApplicationContext_legacy.bleSecurityParam.encryptionKeySizeMax,
+ BleApplicationContext.BleApplicationContext_legacy.bleSecurityParam.Use_Fixed_Pin,
+ BleApplicationContext.BleApplicationContext_legacy.bleSecurityParam.Fixed_Pin,
+ CFG_IDENTITY_ADDRESS);
+ if (ret != BLE_STATUS_SUCCESS)
+ {
+ APP_DBG_MSG(" Fail : aci_gap_set_authentication_requirement command, result: 0x%x \n", ret);
+ }
+ else
+ {
+ APP_DBG_MSG(" Success: aci_gap_set_authentication_requirement command\n");
+ }
+
+ /**
+ * Initialize whitelist
+ */
+ if (BleApplicationContext.BleApplicationContext_legacy.bleSecurityParam.bonding_mode)
+ {
+ ret = aci_gap_configure_whitelist();
+ if (ret != BLE_STATUS_SUCCESS)
+ {
+ APP_DBG_MSG(" Fail : aci_gap_configure_whitelist command, result: 0x%x \n", ret);
+ }
+ else
+ {
+ APP_DBG_MSG(" Success: aci_gap_configure_whitelist command\n");
+ }
+ }
+ APP_DBG_MSG("==>> End Ble_Hci_Gap_Gatt_Init function\n\r");
+}
+
+static void Adv_Request(APP_BLE_ConnStatus_t NewStatus)
+{
+ tBleStatus ret = BLE_STATUS_INVALID_PARAMS;
+ uint16_t Min_Inter, Max_Inter;
+
+ if (NewStatus == APP_BLE_FAST_ADV)
+ {
+ Min_Inter = AdvIntervalMin;
+ Max_Inter = AdvIntervalMax;
+ }
+ else
+ {
+ Min_Inter = CFG_LP_CONN_ADV_INTERVAL_MIN;
+ Max_Inter = CFG_LP_CONN_ADV_INTERVAL_MAX;
+ }
+
+ /**
+ * Stop the timer, it will be restarted for a new shot
+ * It does not hurt if the timer was not running
+ */
+ HW_TS_Stop(BleApplicationContext.Advertising_mgr_timer_Id);
+
+ if ((NewStatus == APP_BLE_LP_ADV)
+ && ((BleApplicationContext.Device_Connection_Status == APP_BLE_FAST_ADV)
+ || (BleApplicationContext.Device_Connection_Status == APP_BLE_LP_ADV)))
+ {
+ /* Connection in ADVERTISE mode have to stop the current advertising */
+ ret = aci_gap_set_non_discoverable();
+ if (ret != BLE_STATUS_SUCCESS)
+ {
+ APP_DBG_MSG("==>> aci_gap_set_non_discoverable - Stop Advertising Failed , result: %d \n", ret);
+ }
+ else
+ {
+ APP_DBG_MSG("==>> aci_gap_set_non_discoverable - Successfully Stopped Advertising \n");
+ }
+ }
+
+ BleApplicationContext.Device_Connection_Status = NewStatus;
+ /* Start Fast or Low Power Advertising */
+ ret = aci_gap_set_discoverable(ADV_IND,
+ Min_Inter,
+ Max_Inter,
+ CFG_BLE_ADDRESS_TYPE,
+ NO_WHITE_LIST_USE, /* use white list */
+ sizeof(a_LocalName),
+ (uint8_t*) &a_LocalName,
+ BleApplicationContext.BleApplicationContext_legacy.advtServUUIDlen,
+ BleApplicationContext.BleApplicationContext_legacy.advtServUUID,
+ 0,
+ 0);
+ if (ret != BLE_STATUS_SUCCESS)
+ {
+ APP_DBG_MSG("==>> aci_gap_set_discoverable - fail, result: 0x%x \n", ret);
+ }
+ else
+ {
+ APP_DBG_MSG("==>> aci_gap_set_discoverable - Success\n");
+ }
+
+ /* Update Advertising data */
+ ret = aci_gap_update_adv_data(sizeof(a_ManufData), (uint8_t*) a_ManufData);
+ if (ret != BLE_STATUS_SUCCESS)
+ {
+ if (NewStatus == APP_BLE_FAST_ADV)
+ {
+ APP_DBG_MSG("==>> Start Fast Advertising Failed , result: %d \n\r", ret);
+ }
+ else
+ {
+ APP_DBG_MSG("==>> Start Low Power Advertising Failed , result: %d \n\r", ret);
+ }
+ }
+ else
+ {
+ if (NewStatus == APP_BLE_FAST_ADV)
+ {
+ APP_DBG_MSG("==>> Success: Start Fast Advertising \n\r");
+ /* Start Timer to STOP ADV - TIMEOUT - and next Restart Low Power Advertising */
+ HW_TS_Start(BleApplicationContext.Advertising_mgr_timer_Id, INITIAL_ADV_TIMEOUT);
+ }
+ else
+ {
+ APP_DBG_MSG("==>> Success: Start Low Power Advertising \n\r");
+ }
+ }
+
+ return;
+}
+
+const uint8_t* BleGetBdAddress(void)
+{
+ uint8_t *p_otp_addr;
+ const uint8_t *p_bd_addr;
+ uint32_t udn;
+ uint32_t company_id;
+ uint32_t device_id;
+
+ udn = LL_FLASH_GetUDN();
+
+ if (udn != 0xFFFFFFFF)
+ {
+ company_id = LL_FLASH_GetSTCompanyID();
+ device_id = LL_FLASH_GetDeviceID();
+
+ /**
+ * Public Address with the ST company ID
+ * bit[47:24] : 24bits (OUI) equal to the company ID
+ * bit[23:16] : Device ID.
+ * bit[15:0] : The last 16bits from the UDN
+ * Note: In order to use the Public Address in a final product, a dedicated
+ * 24bits company ID (OUI) shall be bought.
+ */
+ a_BdAddrUdn[0] = (uint8_t)(udn & 0x000000FF);
+ a_BdAddrUdn[1] = (uint8_t)((udn & 0x0000FF00) >> 8);
+ a_BdAddrUdn[2] = (uint8_t)device_id;
+ a_BdAddrUdn[3] = (uint8_t)(company_id & 0x000000FF);
+ a_BdAddrUdn[4] = (uint8_t)((company_id & 0x0000FF00) >> 8);
+ a_BdAddrUdn[5] = (uint8_t)((company_id & 0x00FF0000) >> 16);
+
+ p_bd_addr = (const uint8_t *)a_BdAddrUdn;
+ }
+ else
+ {
+ p_otp_addr = OTP_Read(0);
+ if (p_otp_addr)
+ {
+ p_bd_addr = ((OTP_ID0_t*)p_otp_addr)->bd_address;
+ }
+ else
+ {
+ p_bd_addr = a_MBdAddr;
+ }
+ }
+
+ return p_bd_addr;
+}
+
+/* USER CODE BEGIN FD_LOCAL_FUNCTION */
+
+/* USER CODE END FD_LOCAL_FUNCTION */
+
+/*************************************************************
+ *
+ * SPECIFIC FUNCTIONS FOR P2P SERVER
+ *
+ *************************************************************/
+static void Adv_Cancel(void)
+{
+ /* USER CODE BEGIN Adv_Cancel_1 */
+
+ /* USER CODE END Adv_Cancel_1 */
+
+ if (BleApplicationContext.Device_Connection_Status != APP_BLE_CONNECTED_SERVER)
+ {
+ tBleStatus ret = BLE_STATUS_INVALID_PARAMS;
+
+ ret = aci_gap_set_non_discoverable();
+
+ BleApplicationContext.Device_Connection_Status = APP_BLE_IDLE;
+ if (ret != BLE_STATUS_SUCCESS)
+ {
+ APP_DBG_MSG("** STOP ADVERTISING ** Failed \r\n\r");
+ }
+ else
+ {
+ APP_DBG_MSG(" \r\n\r");
+ APP_DBG_MSG("** STOP ADVERTISING ** \r\n\r");
+ }
+ }
+
+ /* USER CODE BEGIN Adv_Cancel_2 */
+
+ /* USER CODE END Adv_Cancel_2 */
+
+ return;
+}
+
+static void Adv_Cancel_Req(void)
+{
+ /* USER CODE BEGIN Adv_Cancel_Req_1 */
+
+ /* USER CODE END Adv_Cancel_Req_1 */
+
+ UTIL_SEQ_SetTask(1 << CFG_TASK_ADV_CANCEL_ID, CFG_SCH_PRIO_0);
+
+ /* USER CODE BEGIN Adv_Cancel_Req_2 */
+
+ /* USER CODE END Adv_Cancel_Req_2 */
+
+ return;
+}
+
+static void Switch_OFF_GPIO()
+{
+ /* USER CODE BEGIN Switch_OFF_GPIO */
+
+ /* USER CODE END Switch_OFF_GPIO */
+}
+
+#if (L2CAP_REQUEST_NEW_CONN_PARAM != 0)
+void BLE_SVC_L2CAP_Conn_Update(uint16_t ConnectionHandle)
+{
+ /* USER CODE BEGIN BLE_SVC_L2CAP_Conn_Update_1 */
+
+ /* USER CODE END BLE_SVC_L2CAP_Conn_Update_1 */
+
+ if (mutex == 1)
+ {
+ mutex = 0;
+ index_con_int = (index_con_int + 1)%SIZE_TAB_CONN_INT;
+ uint16_t interval_min = CONN_P(a_ConnInterval[index_con_int]);
+ uint16_t interval_max = CONN_P(a_ConnInterval[index_con_int]);
+ uint16_t peripheral_latency = L2CAP_PERIPHERAL_LATENCY;
+ uint16_t timeout_multiplier = L2CAP_TIMEOUT_MULTIPLIER;
+ tBleStatus ret;
+
+ ret = aci_l2cap_connection_parameter_update_req(BleApplicationContext.BleApplicationContext_legacy.connectionHandle,
+ interval_min, interval_max,
+ peripheral_latency, timeout_multiplier);
+ if (ret != BLE_STATUS_SUCCESS)
+ {
+ APP_DBG_MSG("BLE_SVC_L2CAP_Conn_Update(), Failed \r\n\r");
+ }
+ else
+ {
+ APP_DBG_MSG("BLE_SVC_L2CAP_Conn_Update(), Successfully \r\n\r");
+ }
+ }
+
+ /* USER CODE BEGIN BLE_SVC_L2CAP_Conn_Update_2 */
+
+ /* USER CODE END BLE_SVC_L2CAP_Conn_Update_2 */
+
+ return;
+}
+#endif /* L2CAP_REQUEST_NEW_CONN_PARAM != 0 */
+
+#if (L2CAP_REQUEST_NEW_CONN_PARAM != 0)
+static void Connection_Interval_Update_Req(void)
+{
+ if (BleApplicationContext.Device_Connection_Status != APP_BLE_FAST_ADV && BleApplicationContext.Device_Connection_Status != APP_BLE_IDLE)
+ {
+ BLE_SVC_L2CAP_Conn_Update(BleApplicationContext.BleApplicationContext_legacy.connectionHandle);
+ }
+
+ return;
+}
+#endif /* L2CAP_REQUEST_NEW_CONN_PARAM != 0 */
+
+/* USER CODE BEGIN FD_SPECIFIC_FUNCTIONS */
+
+/* USER CODE END FD_SPECIFIC_FUNCTIONS */
+/*************************************************************
+ *
+ * WRAP FUNCTIONS
+ *
+ *************************************************************/
+void hci_notify_asynch_evt(void* p_Data)
+{
+ UTIL_SEQ_SetTask(1 << CFG_TASK_HCI_ASYNCH_EVT_ID, CFG_SCH_PRIO_0);
+
+ return;
+}
+
+void hci_cmd_resp_release(uint32_t Flag)
+{
+ UTIL_SEQ_SetEvt(1 << CFG_IDLEEVT_HCI_CMD_EVT_RSP_ID);
+
+ return;
+}
+
+void hci_cmd_resp_wait(uint32_t Timeout)
+{
+ UTIL_SEQ_WaitEvt(1 << CFG_IDLEEVT_HCI_CMD_EVT_RSP_ID);
+
+ return;
+}
+
+static void BLE_UserEvtRx(void *p_Payload)
+{
+ SVCCTL_UserEvtFlowStatus_t svctl_return_status;
+ tHCI_UserEvtRxParam *p_param;
+
+ p_param = (tHCI_UserEvtRxParam *)p_Payload;
+
+ svctl_return_status = SVCCTL_UserEvtRx((void *)&(p_param->pckt->evtserial));
+ if (svctl_return_status != SVCCTL_UserEvtFlowDisable)
+ {
+ p_param->status = HCI_TL_UserEventFlow_Enable;
+ }
+ else
+ {
+ p_param->status = HCI_TL_UserEventFlow_Disable;
+ }
+
+ return;
+}
+
+static void BLE_StatusNot(HCI_TL_CmdStatus_t Status)
+{
+ uint32_t task_id_list;
+ switch (Status)
+ {
+ case HCI_TL_CmdBusy:
+ /**
+ * All tasks that may send an aci/hci commands shall be listed here
+ * This is to prevent a new command is sent while one is already pending
+ */
+ task_id_list = (1 << CFG_LAST_TASK_ID_WITH_HCICMD) - 1;
+ UTIL_SEQ_PauseTask(task_id_list);
+ /* USER CODE BEGIN HCI_TL_CmdBusy */
+
+ /* USER CODE END HCI_TL_CmdBusy */
+ break;
+
+ case HCI_TL_CmdAvailable:
+ /**
+ * All tasks that may send an aci/hci commands shall be listed here
+ * This is to prevent a new command is sent while one is already pending
+ */
+ task_id_list = (1 << CFG_LAST_TASK_ID_WITH_HCICMD) - 1;
+ UTIL_SEQ_ResumeTask(task_id_list);
+ /* USER CODE BEGIN HCI_TL_CmdAvailable */
+
+ /* USER CODE END HCI_TL_CmdAvailable */
+ break;
+
+ default:
+ /* USER CODE BEGIN Status */
+
+ /* USER CODE END Status */
+ break;
+ }
+
+ return;
+}
+
+void SVCCTL_ResumeUserEventFlow(void)
+{
+ hci_resume_flow();
+
+ return;
+}
+
+/* USER CODE BEGIN FD_WRAP_FUNCTIONS */
+
+/* USER CODE END FD_WRAP_FUNCTIONS */
diff --git a/firmware/memory_chip_gone/STM32_WPAN/App/app_ble.h b/firmware/memory_chip_gone/STM32_WPAN/App/app_ble.h new file mode 100644 index 0000000..2fd3c2b --- /dev/null +++ b/firmware/memory_chip_gone/STM32_WPAN/App/app_ble.h @@ -0,0 +1,81 @@ +/* USER CODE BEGIN Header */
+/**
+ ******************************************************************************
+ * @file App/app_ble.h
+ * @author MCD Application Team
+ * @brief Header for ble application
+ ******************************************************************************
+ * @attention
+ *
+ * Copyright (c) 2026 STMicroelectronics.
+ * All rights reserved.
+ *
+ * This software is licensed under terms that can be found in the LICENSE file
+ * in the root directory of this software component.
+ * If no LICENSE file comes with this software, it is provided AS-IS.
+ *
+ ******************************************************************************
+ */
+/* USER CODE END Header */
+
+/* Define to prevent recursive inclusion -------------------------------------*/
+#ifndef APP_BLE_H
+#define APP_BLE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Includes ------------------------------------------------------------------*/
+#include "hci_tl.h"
+
+/* Private includes ----------------------------------------------------------*/
+/* USER CODE BEGIN Includes */
+
+/* USER CODE END Includes */
+
+/* Exported types ------------------------------------------------------------*/
+
+typedef enum
+{
+ APP_BLE_IDLE,
+ APP_BLE_FAST_ADV,
+ APP_BLE_LP_ADV,
+ APP_BLE_SCAN,
+ APP_BLE_LP_CONNECTING,
+ APP_BLE_CONNECTED_SERVER,
+ APP_BLE_CONNECTED_CLIENT
+} APP_BLE_ConnStatus_t;
+
+/* USER CODE BEGIN ET */
+
+/* USER CODE END ET */
+
+/* Exported constants --------------------------------------------------------*/
+/* USER CODE BEGIN EC */
+
+/* USER CODE END EC */
+
+/* External variables --------------------------------------------------------*/
+/* USER CODE BEGIN EV */
+
+/* USER CODE END EV */
+
+/* Exported macro ------------------------------------------------------------*/
+/* USER CODE BEGIN EM */
+
+/* USER CODE END EM */
+
+/* Exported functions ---------------------------------------------*/
+void APP_BLE_Init(void);
+APP_BLE_ConnStatus_t APP_BLE_Get_Server_Connection_Status(void);
+
+/* USER CODE BEGIN EF */
+
+/* USER CODE END EF */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*APP_BLE_H */
diff --git a/firmware/memory_chip_gone/STM32_WPAN/App/ble_conf.h b/firmware/memory_chip_gone/STM32_WPAN/App/ble_conf.h new file mode 100644 index 0000000..84df175 --- /dev/null +++ b/firmware/memory_chip_gone/STM32_WPAN/App/ble_conf.h @@ -0,0 +1,70 @@ +/* USER CODE BEGIN Header */
+/**
+ ******************************************************************************
+ * @file ble_conf.h
+ * @author MCD Application Team
+ * @brief Configuration file for BLE Middleware.
+ ******************************************************************************
+ * @attention
+ *
+ * Copyright (c) 2026 STMicroelectronics.
+ * All rights reserved.
+ *
+ * This software is licensed under terms that can be found in the LICENSE file
+ * in the root directory of this software component.
+ * If no LICENSE file comes with this software, it is provided AS-IS.
+ *
+ ******************************************************************************
+ */
+/* USER CODE END Header */
+
+/* Define to prevent recursive inclusion -------------------------------------*/
+#ifndef BLE_CONF_H
+#define BLE_CONF_H
+
+#include "app_conf.h"
+
+/******************************************************************************
+ *
+ * BLE SERVICES CONFIGURATION
+ * blesvc
+ *
+ ******************************************************************************/
+
+/**
+ * This setting shall be set to '1' if the device needs to support the Peripheral Role
+ * In the MS configuration, both BLE_CFG_PERIPHERAL and BLE_CFG_CENTRAL shall be set to '1'
+ */
+#define BLE_CFG_PERIPHERAL 1
+
+/**
+ * This setting shall be set to '1' if the device needs to support the Central Role
+ * In the MS configuration, both BLE_CFG_PERIPHERAL and BLE_CFG_CENTRAL shall be set to '1'
+ */
+#define BLE_CFG_CENTRAL 0
+
+/**
+ * There is one handler per service enabled
+ * Note: There is no handler for the Device Information Service
+ *
+ * This shall take into account all registered handlers
+ * (from either the provided services or the custom services)
+ */
+#define BLE_CFG_SVC_MAX_NBR_CB 7
+
+#define BLE_CFG_CLT_MAX_NBR_CB 0
+
+/******************************************************************************
+ * GAP Service - Appearance
+ ******************************************************************************/
+
+#define BLE_CFG_UNKNOWN_APPEARANCE (0)
+#define BLE_CFG_HR_SENSOR_APPEARANCE (832)
+#define BLE_CFG_GAP_APPEARANCE (BLE_CFG_UNKNOWN_APPEARANCE)
+
+/******************************************************************************
+ * Over The Air Feature (OTA) - STM Proprietary
+ ******************************************************************************/
+#define BLE_CFG_OTA_REBOOT_CHAR 0/**< REBOOT OTA MODE CHARACTERISTIC */
+
+#endif /*BLE_CONF_H */
diff --git a/firmware/memory_chip_gone/STM32_WPAN/App/ble_dbg_conf.h b/firmware/memory_chip_gone/STM32_WPAN/App/ble_dbg_conf.h new file mode 100644 index 0000000..3d87556 --- /dev/null +++ b/firmware/memory_chip_gone/STM32_WPAN/App/ble_dbg_conf.h @@ -0,0 +1,198 @@ +/* USER CODE BEGIN Header */
+/**
+ ******************************************************************************
+ * @file App/ble_dbg_conf.h
+ * @author MCD Application Team
+ * @brief Debug configuration file for BLE Middleware.
+ ******************************************************************************
+ * @attention
+ *
+ * Copyright (c) 2026 STMicroelectronics.
+ * All rights reserved.
+ *
+ * This software is licensed under terms that can be found in the LICENSE file
+ * in the root directory of this software component.
+ * If no LICENSE file comes with this software, it is provided AS-IS.
+ *
+ ******************************************************************************
+ */
+/* USER CODE END Header */
+
+/* Define to prevent recursive inclusion -------------------------------------*/
+#ifndef BLE_DBG_CONF_H
+#define BLE_DBG_CONF_H
+
+/**
+ * Enable or Disable traces from BLE
+ */
+
+#define BLE_DBG_APP_EN 0
+#define BLE_DBG_DIS_EN 0
+#define BLE_DBG_HRS_EN 0
+#define BLE_DBG_SVCCTL_EN 0
+#define BLE_DBG_BLS_EN 0
+#define BLE_DBG_HTS_EN 0
+#define BLE_DBG_P2P_STM_EN 0
+
+/**
+ * Macro definition
+ */
+#if (BLE_DBG_APP_EN != 0)
+#define BLE_DBG_APP_MSG PRINT_MESG_DBG
+#else
+#define BLE_DBG_APP_MSG PRINT_NO_MESG
+#endif
+
+#if (BLE_DBG_DIS_EN != 0)
+#define BLE_DBG_DIS_MSG PRINT_MESG_DBG
+#else
+#define BLE_DBG_DIS_MSG PRINT_NO_MESG
+#endif
+
+#if (BLE_DBG_HRS_EN != 0)
+#define BLE_DBG_HRS_MSG PRINT_MESG_DBG
+#else
+#define BLE_DBG_HRS_MSG PRINT_NO_MESG
+#endif
+
+#if (BLE_DBG_P2P_STM_EN != 0)
+#define BLE_DBG_P2P_STM_MSG PRINT_MESG_DBG
+#else
+#define BLE_DBG_P2P_STM_MSG PRINT_NO_MESG
+#endif
+
+#if (BLE_DBG_TEMPLATE_STM_EN != 0)
+#define BLE_DBG_TEMPLATE_STM_MSG PRINT_MESG_DBG
+#else
+#define BLE_DBG_TEMPLATE_STM_MSG PRINT_NO_MESG
+#endif
+
+#if (BLE_DBG_EDS_STM_EN != 0)
+#define BLE_DBG_EDS_STM_MSG PRINT_MESG_DBG
+#else
+#define BLE_DBG_EDS_STM_MSG PRINT_NO_MESG
+#endif
+
+#if (BLE_DBG_LBS_STM_EN != 0)
+#define BLE_DBG_LBS_STM_MSG PRINT_MESG_DBG
+#else
+#define BLE_DBG_LBS_STM_MSG PRINT_NO_MESG
+#endif
+
+#if (BLE_DBG_SVCCTL_EN != 0)
+#define BLE_DBG_SVCCTL_MSG PRINT_MESG_DBG
+#else
+#define BLE_DBG_SVCCTL_MSG PRINT_NO_MESG
+#endif
+
+#if (BLE_DBG_CTS_EN != 0)
+#define BLE_DBG_CTS_MSG PRINT_MESG_DBG
+#else
+#define BLE_DBG_CTS_MSG PRINT_NO_MESG
+#endif
+
+#if (BLE_DBG_HIDS_EN != 0)
+#define BLE_DBG_HIDS_MSG PRINT_MESG_DBG
+#else
+#define BLE_DBG_HIDS_MSG PRINT_NO_MESG
+#endif
+
+#if (BLE_DBG_PASS_EN != 0)
+#define BLE_DBG_PASS_MSG PRINT_MESG_DBG
+#else
+#define BLE_DBG_PASS_MSG PRINT_NO_MESG
+#endif
+
+#if (BLE_DBG_BLS_EN != 0)
+#define BLE_DBG_BLS_MSG PRINT_MESG_DBG
+#else
+#define BLE_DBG_BLS_MSG PRINT_NO_MESG
+#endif
+
+#if (BLE_DBG_HTS_EN != 0)
+#define BLE_DBG_HTS_MSG PRINT_MESG_DBG
+#else
+#define BLE_DBG_HTS_MSG PRINT_NO_MESG
+#endif
+
+#if (BLE_DBG_ANS_EN != 0)
+#define BLE_DBG_ANS_MSG PRINT_MESG_DBG
+#else
+#define BLE_DBG_ANS_MSG PRINT_NO_MESG
+#endif
+
+#if (BLE_DBG_ESS_EN != 0)
+#define BLE_DBG_ESS_MSG PRINT_MESG_DBG
+#else
+#define BLE_DBG_ESS_MSG PRINT_NO_MESG
+#endif
+
+#if (BLE_DBG_GLS_EN != 0)
+#define BLE_DBG_GLS_MSG PRINT_MESG_DBG
+#else
+#define BLE_DBG_GLS_MSG PRINT_NO_MESG
+#endif
+
+#if (BLE_DBG_BAS_EN != 0)
+#define BLE_DBG_BAS_MSG PRINT_MESG_DBG
+#else
+#define BLE_DBG_BAS_MSG PRINT_NO_MESG
+#endif
+
+#if (BLE_DBG_RTUS_EN != 0)
+#define BLE_DBG_RTUS_MSG PRINT_MESG_DBG
+#else
+#define BLE_DBG_RTUS_MSG PRINT_NO_MESG
+#endif
+
+#if (BLE_DBG_HPS_EN != 0)
+#define BLE_DBG_HPS_MSG PRINT_MESG_DBG
+#else
+#define BLE_DBG_HPS_MSG PRINT_NO_MESG
+#endif
+
+#if (BLE_DBG_TPS_EN != 0)
+#define BLE_DBG_TPS_MSG PRINT_MESG_DBG
+#else
+#define BLE_DBG_TPS_MSG PRINT_NO_MESG
+#endif
+
+#if (BLE_DBG_LLS_EN != 0)
+#define BLE_DBG_LLS_MSG PRINT_MESG_DBG
+#else
+#define BLE_DBG_LLS_MSG PRINT_NO_MESG
+#endif
+
+#if (BLE_DBG_IAS_EN != 0)
+#define BLE_DBG_IAS_MSG PRINT_MESG_DBG
+#else
+#define BLE_DBG_IAS_MSG PRINT_NO_MESG
+#endif
+
+#if (BLE_DBG_WSS_EN != 0)
+#define BLE_DBG_WSS_MSG PRINT_MESG_DBG
+#else
+#define BLE_DBG_WSS_MSG PRINT_NO_MESG
+#endif
+
+#if (BLE_DBG_LNS_EN != 0)
+#define BLE_DBG_LNS_MSG PRINT_MESG_DBG
+#else
+#define BLE_DBG_LNS_MSG PRINT_NO_MESG
+#endif
+
+#if (BLE_DBG_SCPS_EN != 0)
+#define BLE_DBG_SCPS_MSG PRINT_MESG_DBG
+#else
+#define BLE_DBG_SCPS_MSG PRINT_NO_MESG
+#endif
+
+#if (BLE_DBG_DTS_EN != 0)
+#define BLE_DBG_DTS_MSG PRINT_MESG_DBG
+#define BLE_DBG_DTS_BUF PRINT_LOG_BUFF_DBG
+#else
+#define BLE_DBG_DTS_MSG PRINT_NO_MESG
+#define BLE_DBG_DTS_BUF PRINT_NO_MESG
+#endif
+
+#endif /*BLE_DBG_CONF_H */
diff --git a/firmware/memory_chip_gone/STM32_WPAN/App/p2p_server_app.c b/firmware/memory_chip_gone/STM32_WPAN/App/p2p_server_app.c new file mode 100644 index 0000000..5a5f5fb --- /dev/null +++ b/firmware/memory_chip_gone/STM32_WPAN/App/p2p_server_app.c @@ -0,0 +1,154 @@ +/* USER CODE BEGIN Header */
+/**
+ ******************************************************************************
+ * @file App/p2p_server_app.c
+ * @author MCD Application Team
+ * @brief Peer to peer Server Application
+ ******************************************************************************
+ * @attention
+ *
+ * Copyright (c) 2026 STMicroelectronics.
+ * All rights reserved.
+ *
+ * This software is licensed under terms that can be found in the LICENSE file
+ * in the root directory of this software component.
+ * If no LICENSE file comes with this software, it is provided AS-IS.
+ *
+ ******************************************************************************
+ */
+/* USER CODE END Header */
+
+/* Includes ------------------------------------------------------------------*/
+#include "main.h"
+#include "app_common.h"
+#include "dbg_trace.h"
+#include "ble.h"
+#include "p2p_server_app.h"
+#include "stm32_seq.h"
+
+/* Private includes ----------------------------------------------------------*/
+/* USER CODE BEGIN Includes */
+
+/* USER CODE END Includes */
+
+/* Private typedef -----------------------------------------------------------*/
+/* USER CODE BEGIN PTD */
+
+/* USER CODE END PTD */
+
+/* Private defines ------------------------------------------------------------*/
+/* USER CODE BEGIN PD */
+
+/* USER CODE END PD */
+
+/* Private macros -------------------------------------------------------------*/
+/* USER CODE BEGIN PM */
+
+/* USER CODE END PM */
+
+/* Private variables ---------------------------------------------------------*/
+/* USER CODE BEGIN PV */
+
+/* USER CODE END PV */
+
+/* Private function prototypes -----------------------------------------------*/
+/* USER CODE BEGIN PFP */
+
+/* USER CODE END PFP */
+
+/* Functions Definition ------------------------------------------------------*/
+void P2PS_STM_App_Notification(P2PS_STM_App_Notification_evt_t *pNotification)
+{
+/* USER CODE BEGIN P2PS_STM_App_Notification_1 */
+
+/* USER CODE END P2PS_STM_App_Notification_1 */
+ switch(pNotification->P2P_Evt_Opcode)
+ {
+/* USER CODE BEGIN P2PS_STM_App_Notification_P2P_Evt_Opcode */
+
+/* USER CODE END P2PS_STM_App_Notification_P2P_Evt_Opcode */
+
+ case P2PS_STM__NOTIFY_ENABLED_EVT:
+/* USER CODE BEGIN P2PS_STM__NOTIFY_ENABLED_EVT */
+
+/* USER CODE END P2PS_STM__NOTIFY_ENABLED_EVT */
+ break;
+
+ case P2PS_STM_NOTIFY_DISABLED_EVT:
+/* USER CODE BEGIN P2PS_STM_NOTIFY_DISABLED_EVT */
+
+/* USER CODE END P2PS_STM_NOTIFY_DISABLED_EVT */
+ break;
+
+ case P2PS_STM_WRITE_EVT:
+/* USER CODE BEGIN P2PS_STM_WRITE_EVT */
+
+/* USER CODE END P2PS_STM_WRITE_EVT */
+ break;
+
+ default:
+/* USER CODE BEGIN P2PS_STM_App_Notification_default */
+
+/* USER CODE END P2PS_STM_App_Notification_default */
+ break;
+ }
+/* USER CODE BEGIN P2PS_STM_App_Notification_2 */
+
+/* USER CODE END P2PS_STM_App_Notification_2 */
+ return;
+}
+
+void P2PS_APP_Notification(P2PS_APP_ConnHandle_Not_evt_t *pNotification)
+{
+/* USER CODE BEGIN P2PS_APP_Notification_1 */
+
+/* USER CODE END P2PS_APP_Notification_1 */
+ switch(pNotification->P2P_Evt_Opcode)
+ {
+/* USER CODE BEGIN P2PS_APP_Notification_P2P_Evt_Opcode */
+
+/* USER CODE END P2PS_APP_Notification_P2P_Evt_Opcode */
+ case PEER_CONN_HANDLE_EVT :
+/* USER CODE BEGIN PEER_CONN_HANDLE_EVT */
+
+/* USER CODE END PEER_CONN_HANDLE_EVT */
+ break;
+
+ case PEER_DISCON_HANDLE_EVT :
+/* USER CODE BEGIN PEER_DISCON_HANDLE_EVT */
+
+/* USER CODE END PEER_DISCON_HANDLE_EVT */
+ break;
+
+ default:
+/* USER CODE BEGIN P2PS_APP_Notification_default */
+
+/* USER CODE END P2PS_APP_Notification_default */
+ break;
+ }
+/* USER CODE BEGIN P2PS_APP_Notification_2 */
+
+/* USER CODE END P2PS_APP_Notification_2 */
+ return;
+}
+
+void P2PS_APP_Init(void)
+{
+/* USER CODE BEGIN P2PS_APP_Init */
+
+/* USER CODE END P2PS_APP_Init */
+ return;
+}
+
+/* USER CODE BEGIN FD */
+
+/* USER CODE END FD */
+
+/*************************************************************
+ *
+ * LOCAL FUNCTIONS
+ *
+ *************************************************************/
+/* USER CODE BEGIN FD_LOCAL_FUNCTIONS*/
+
+/* USER CODE END FD_LOCAL_FUNCTIONS*/
diff --git a/firmware/memory_chip_gone/STM32_WPAN/App/p2p_server_app.h b/firmware/memory_chip_gone/STM32_WPAN/App/p2p_server_app.h new file mode 100644 index 0000000..7c1d807 --- /dev/null +++ b/firmware/memory_chip_gone/STM32_WPAN/App/p2p_server_app.h @@ -0,0 +1,78 @@ +/* USER CODE BEGIN Header */
+/**
+ ******************************************************************************
+ * @file App/p2p_server_app.h
+ * @author MCD Application Team
+ * @brief Header for p2p_server_app.c module
+ ******************************************************************************
+ * @attention
+ *
+ * Copyright (c) 2026 STMicroelectronics.
+ * All rights reserved.
+ *
+ * This software is licensed under terms that can be found in the LICENSE file
+ * in the root directory of this software component.
+ * If no LICENSE file comes with this software, it is provided AS-IS.
+ *
+ ******************************************************************************
+ */
+/* USER CODE END Header */
+
+/* Define to prevent recursive inclusion -------------------------------------*/
+#ifndef P2P_SERVER_APP_H
+#define P2P_SERVER_APP_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Includes ------------------------------------------------------------------*/
+
+/* Private includes ----------------------------------------------------------*/
+/* USER CODE BEGIN Includes */
+
+/* USER CODE END Includes */
+
+/* Exported types ------------------------------------------------------------*/
+typedef enum
+{
+ PEER_CONN_HANDLE_EVT,
+ PEER_DISCON_HANDLE_EVT,
+} P2PS_APP__Opcode_Notification_evt_t;
+
+typedef struct
+{
+ P2PS_APP__Opcode_Notification_evt_t P2P_Evt_Opcode;
+ uint16_t ConnectionHandle;
+}P2PS_APP_ConnHandle_Not_evt_t;
+/* USER CODE BEGIN ET */
+
+/* USER CODE END ET */
+
+/* Exported constants --------------------------------------------------------*/
+/* USER CODE BEGIN EC */
+
+/* USER CODE END EC */
+
+/* External variables --------------------------------------------------------*/
+/* USER CODE BEGIN EV */
+
+/* USER CODE END EV */
+
+/* Exported macros ------------------------------------------------------------*/
+/* USER CODE BEGIN EM */
+
+/* USER CODE END EM */
+
+/* Exported functions ---------------------------------------------*/
+ void P2PS_APP_Init( void );
+ void P2PS_APP_Notification( P2PS_APP_ConnHandle_Not_evt_t *pNotification );
+/* USER CODE BEGIN EF */
+
+/* USER CODE END EF */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*P2P_SERVER_APP_H */
diff --git a/firmware/memory_chip_gone/STM32_WPAN/App/tl_dbg_conf.h b/firmware/memory_chip_gone/STM32_WPAN/App/tl_dbg_conf.h new file mode 100644 index 0000000..ba97122 --- /dev/null +++ b/firmware/memory_chip_gone/STM32_WPAN/App/tl_dbg_conf.h @@ -0,0 +1,133 @@ +/* USER CODE BEGIN Header */
+/**
+ ******************************************************************************
+ * @file App/tl_dbg_conf.h
+ * @author MCD Application Team
+ * @brief Debug configuration file for stm32wpan transport layer interface.
+ ******************************************************************************
+ * @attention
+ *
+ * Copyright (c) 2026 STMicroelectronics.
+ * All rights reserved.
+ *
+ * This software is licensed under terms that can be found in the LICENSE file
+ * in the root directory of this software component.
+ * If no LICENSE file comes with this software, it is provided AS-IS.
+ *
+ ******************************************************************************
+ */
+/* USER CODE END Header */
+
+/* Define to prevent recursive inclusion -------------------------------------*/
+#ifndef TL_DBG_CONF_H
+#define TL_DBG_CONF_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* USER CODE BEGIN Tl_Conf */
+
+/* Includes ------------------------------------------------------------------*/
+#include "app_conf.h" /* required as some configuration used in dbg_trace.h are set there */
+#include "dbg_trace.h"
+#include "hw_if.h"
+
+/**
+ * Enable or Disable traces
+ * The raw data output is the hci binary packet format as specified by the BT specification *
+ */
+#define TL_SHCI_CMD_DBG_EN 0 /* Reports System commands sent to CPU2 and the command response */
+#define TL_SHCI_CMD_DBG_RAW_EN 0 /* Reports raw data System commands sent to CPU2 and the command response */
+#define TL_SHCI_EVT_DBG_EN 0 /* Reports System Asynchronous Events received from CPU2 */
+#define TL_SHCI_EVT_DBG_RAW_EN 0 /* Reports raw data System Asynchronous Events received from CPU2 */
+
+#define TL_HCI_CMD_DBG_EN 0 /* Reports BLE command sent to CPU2 and the command response */
+#define TL_HCI_CMD_DBG_RAW_EN 0 /* Reports raw data BLE command sent to CPU2 and the command response */
+#define TL_HCI_EVT_DBG_EN 0 /* Reports BLE Asynchronous Events received from CPU2 */
+#define TL_HCI_EVT_DBG_RAW_EN 0 /* Reports raw data BLE Asynchronous Events received from CPU2 */
+
+#define TL_MM_DBG_EN 0 /* Reports the information of the buffer released to CPU2 */
+
+/**
+ * Macro definition
+ */
+
+/**
+ * System Transport Layer
+ */
+#if (TL_SHCI_CMD_DBG_EN != 0)
+#define TL_SHCI_CMD_DBG_MSG PRINT_MESG_DBG
+#define TL_SHCI_CMD_DBG_BUF PRINT_LOG_BUFF_DBG
+#else
+#define TL_SHCI_CMD_DBG_MSG(...)
+#define TL_SHCI_CMD_DBG_BUF(...)
+#endif
+
+#if (TL_SHCI_CMD_DBG_RAW_EN != 0)
+#define TL_SHCI_CMD_DBG_RAW(_PDATA_, _SIZE_) HW_UART_Transmit(hw_uart1, (uint8_t*)_PDATA_, _SIZE_, (~0))
+#else
+#define TL_SHCI_CMD_DBG_RAW(...)
+#endif
+
+#if (TL_SHCI_EVT_DBG_EN != 0)
+#define TL_SHCI_EVT_DBG_MSG PRINT_MESG_DBG
+#define TL_SHCI_EVT_DBG_BUF PRINT_LOG_BUFF_DBG
+#else
+#define TL_SHCI_EVT_DBG_MSG(...)
+#define TL_SHCI_EVT_DBG_BUF(...)
+#endif
+
+#if (TL_SHCI_EVT_DBG_RAW_EN != 0)
+#define TL_SHCI_EVT_DBG_RAW(_PDATA_, _SIZE_) HW_UART_Transmit(hw_uart1, (uint8_t*)_PDATA_, _SIZE_, (~0))
+#else
+#define TL_SHCI_EVT_DBG_RAW(...)
+#endif
+
+/**
+ * BLE Transport Layer
+ */
+#if (TL_HCI_CMD_DBG_EN != 0)
+#define TL_HCI_CMD_DBG_MSG PRINT_MESG_DBG
+#define TL_HCI_CMD_DBG_BUF PRINT_LOG_BUFF_DBG
+#else
+#define TL_HCI_CMD_DBG_MSG(...)
+#define TL_HCI_CMD_DBG_BUF(...)
+#endif
+
+#if (TL_HCI_CMD_DBG_RAW_EN != 0)
+#define TL_HCI_CMD_DBG_RAW(_PDATA_, _SIZE_) HW_UART_Transmit(hw_uart1, (uint8_t*)_PDATA_, _SIZE_, (~0))
+#else
+#define TL_HCI_CMD_DBG_RAW(...)
+#endif
+
+#if (TL_HCI_EVT_DBG_EN != 0)
+#define TL_HCI_EVT_DBG_MSG PRINT_MESG_DBG
+#define TL_HCI_EVT_DBG_BUF PRINT_LOG_BUFF_DBG
+#else
+#define TL_HCI_EVT_DBG_MSG(...)
+#define TL_HCI_EVT_DBG_BUF(...)
+#endif
+
+#if (TL_HCI_EVT_DBG_RAW_EN != 0)
+#define TL_HCI_EVT_DBG_RAW(_PDATA_, _SIZE_) HW_UART_Transmit(hw_uart1, (uint8_t*)_PDATA_, _SIZE_, (~0))
+#else
+#define TL_HCI_EVT_DBG_RAW(...)
+#endif
+
+/**
+ * Memory Manager - Released buffer tracing
+ */
+#if (TL_MM_DBG_EN != 0)
+#define TL_MM_DBG_MSG PRINT_MESG_DBG
+#else
+#define TL_MM_DBG_MSG(...)
+#endif
+
+/* USER CODE END Tl_Conf */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*TL_DBG_CONF_H */
diff --git a/firmware/memory_chip_gone/STM32_WPAN/Target/hw_ipcc.c b/firmware/memory_chip_gone/STM32_WPAN/Target/hw_ipcc.c new file mode 100644 index 0000000..4c01837 --- /dev/null +++ b/firmware/memory_chip_gone/STM32_WPAN/Target/hw_ipcc.c @@ -0,0 +1,747 @@ +/* USER CODE BEGIN Header */
+/**
+ ******************************************************************************
+ * @file Target/hw_ipcc.c
+ * @author MCD Application Team
+ * @brief Hardware IPCC source file for STM32WPAN Middleware.
+ ******************************************************************************
+ * @attention
+ *
+ * Copyright (c) 2026 STMicroelectronics.
+ * All rights reserved.
+ *
+ * This software is licensed under terms that can be found in the LICENSE file
+ * in the root directory of this software component.
+ * If no LICENSE file comes with this software, it is provided AS-IS.
+ *
+ ******************************************************************************
+ */
+/* USER CODE END Header */
+
+/* Includes ------------------------------------------------------------------*/
+#include "app_common.h"
+#include "mbox_def.h"
+#include "utilities_conf.h"
+
+/* Global variables ---------------------------------------------------------*/
+/* Private defines -----------------------------------------------------------*/
+#define HW_IPCC_TX_PENDING( channel ) ( !(LL_C1_IPCC_IsActiveFlag_CHx( IPCC, channel )) ) && (((~(IPCC->C1MR)) & (channel << 16U)))
+#define HW_IPCC_RX_PENDING( channel ) (LL_C2_IPCC_IsActiveFlag_CHx( IPCC, channel )) && (((~(IPCC->C1MR)) & (channel << 0U)))
+
+/* Private macros ------------------------------------------------------------*/
+/* Private typedef -----------------------------------------------------------*/
+/* Private variables ---------------------------------------------------------*/
+static void (*FreeBufCb)( void );
+
+/* Private function prototypes -----------------------------------------------*/
+static void HW_IPCC_BLE_EvtHandler( void );
+static void HW_IPCC_BLE_AclDataEvtHandler( void );
+static void HW_IPCC_MM_FreeBufHandler( void );
+static void HW_IPCC_SYS_CmdEvtHandler( void );
+static void HW_IPCC_SYS_EvtHandler( void );
+static void HW_IPCC_TRACES_EvtHandler( void );
+
+#ifdef THREAD_WB
+static void HW_IPCC_OT_CmdEvtHandler( void );
+static void HW_IPCC_THREAD_NotEvtHandler( void );
+static void HW_IPCC_THREAD_CliNotEvtHandler( void );
+#endif
+
+#ifdef LLD_TESTS_WB
+static void HW_IPCC_LLDTESTS_ReceiveCliRspHandler( void );
+static void HW_IPCC_LLDTESTS_ReceiveM0CmdHandler( void );
+#endif
+#ifdef LLD_BLE_WB
+/*static void HW_IPCC_LLD_BLE_ReceiveCliRspHandler( void );*/
+static void HW_IPCC_LLD_BLE_ReceiveRspHandler( void );
+static void HW_IPCC_LLD_BLE_ReceiveM0CmdHandler( void );
+#endif
+
+#ifdef MAC_802_15_4_WB
+static void HW_IPCC_MAC_802_15_4_CmdEvtHandler( void );
+static void HW_IPCC_MAC_802_15_4_NotEvtHandler( void );
+#endif
+
+#ifdef ZIGBEE_WB
+static void HW_IPCC_ZIGBEE_CmdEvtHandler( void );
+static void HW_IPCC_ZIGBEE_StackNotifEvtHandler( void );
+static void HW_IPCC_ZIGBEE_StackM0RequestHandler( void );
+#endif
+
+/* Public function definition -----------------------------------------------*/
+
+/******************************************************************************
+ * INTERRUPT HANDLER
+ ******************************************************************************/
+void HW_IPCC_Rx_Handler( void )
+{
+ if (HW_IPCC_RX_PENDING( HW_IPCC_SYSTEM_EVENT_CHANNEL ))
+ {
+ HW_IPCC_SYS_EvtHandler();
+ }
+#ifdef MAC_802_15_4_WB
+ else if (HW_IPCC_RX_PENDING( HW_IPCC_MAC_802_15_4_NOTIFICATION_ACK_CHANNEL ))
+ {
+ HW_IPCC_MAC_802_15_4_NotEvtHandler();
+ }
+#endif /* MAC_802_15_4_WB */
+#ifdef THREAD_WB
+ else if (HW_IPCC_RX_PENDING( HW_IPCC_THREAD_NOTIFICATION_ACK_CHANNEL ))
+ {
+ HW_IPCC_THREAD_NotEvtHandler();
+ }
+ else if (HW_IPCC_RX_PENDING( HW_IPCC_THREAD_CLI_NOTIFICATION_ACK_CHANNEL ))
+ {
+ HW_IPCC_THREAD_CliNotEvtHandler();
+ }
+#endif /* THREAD_WB */
+#ifdef LLD_TESTS_WB
+ else if (HW_IPCC_RX_PENDING( HW_IPCC_LLDTESTS_CLI_RSP_CHANNEL ))
+ {
+ HW_IPCC_LLDTESTS_ReceiveCliRspHandler();
+ }
+ else if (HW_IPCC_RX_PENDING( HW_IPCC_LLDTESTS_M0_CMD_CHANNEL ))
+ {
+ HW_IPCC_LLDTESTS_ReceiveM0CmdHandler();
+ }
+#endif /* LLD_TESTS_WB */
+#ifdef LLD_BLE_WB
+ else if (HW_IPCC_RX_PENDING( HW_IPCC_LLD_BLE_RSP_CHANNEL ))
+ {
+ HW_IPCC_LLD_BLE_ReceiveRspHandler();
+ }
+ else if (HW_IPCC_RX_PENDING( HW_IPCC_LLD_BLE_M0_CMD_CHANNEL ))
+ {
+ HW_IPCC_LLD_BLE_ReceiveM0CmdHandler();
+ }
+#endif /* LLD_TESTS_WB */
+#ifdef ZIGBEE_WB
+ else if (HW_IPCC_RX_PENDING( HW_IPCC_ZIGBEE_APPLI_NOTIF_ACK_CHANNEL ))
+ {
+ HW_IPCC_ZIGBEE_StackNotifEvtHandler();
+ }
+ else if (HW_IPCC_RX_PENDING( HW_IPCC_ZIGBEE_M0_REQUEST_CHANNEL ))
+ {
+ HW_IPCC_ZIGBEE_StackM0RequestHandler();
+ }
+#endif /* ZIGBEE_WB */
+ else if (HW_IPCC_RX_PENDING( HW_IPCC_BLE_EVENT_CHANNEL ))
+ {
+ HW_IPCC_BLE_EvtHandler();
+ }
+ else if (HW_IPCC_RX_PENDING( HW_IPCC_TRACES_CHANNEL ))
+ {
+ HW_IPCC_TRACES_EvtHandler();
+ }
+
+ return;
+}
+
+void HW_IPCC_Tx_Handler( void )
+{
+ if (HW_IPCC_TX_PENDING( HW_IPCC_SYSTEM_CMD_RSP_CHANNEL ))
+ {
+ HW_IPCC_SYS_CmdEvtHandler();
+ }
+#ifdef MAC_802_15_4_WB
+ else if (HW_IPCC_TX_PENDING( HW_IPCC_MAC_802_15_4_CMD_RSP_CHANNEL ))
+ {
+ HW_IPCC_MAC_802_15_4_CmdEvtHandler();
+ }
+#endif /* MAC_802_15_4_WB */
+#ifdef THREAD_WB
+ else if (HW_IPCC_TX_PENDING( HW_IPCC_THREAD_OT_CMD_RSP_CHANNEL ))
+ {
+ HW_IPCC_OT_CmdEvtHandler();
+ }
+#endif /* THREAD_WB */
+#ifdef LLD_TESTS_WB
+// No TX handler for LLD tests
+#endif /* LLD_TESTS_WB */
+#ifdef ZIGBEE_WB
+ if (HW_IPCC_TX_PENDING( HW_IPCC_ZIGBEE_CMD_APPLI_CHANNEL ))
+ {
+ HW_IPCC_ZIGBEE_CmdEvtHandler();
+ }
+#endif /* ZIGBEE_WB */
+ else if (HW_IPCC_TX_PENDING( HW_IPCC_MM_RELEASE_BUFFER_CHANNEL ))
+ {
+ HW_IPCC_MM_FreeBufHandler();
+ }
+ else if (HW_IPCC_TX_PENDING( HW_IPCC_HCI_ACL_DATA_CHANNEL ))
+ {
+ HW_IPCC_BLE_AclDataEvtHandler();
+ }
+
+ return;
+}
+/******************************************************************************
+ * GENERAL
+ ******************************************************************************/
+void HW_IPCC_Enable( void )
+{
+ /**
+ * Such as IPCC IP available to the CPU2, it is required to keep the IPCC clock running
+ * when FUS is running on CPU2 and CPU1 enters deep sleep mode
+ */
+ LL_C2_AHB3_GRP1_EnableClock(LL_C2_AHB3_GRP1_PERIPH_IPCC);
+
+ /**
+ * When the device is out of standby, it is required to use the EXTI mechanism to wakeup CPU2
+ */
+ LL_EXTI_EnableRisingTrig_32_63( LL_EXTI_LINE_41 );
+ /* It is required to have at least a system clock cycle before a SEV after LL_EXTI_EnableRisingTrig_32_63() */
+ LL_C2_EXTI_EnableEvent_32_63( LL_EXTI_LINE_41 );
+
+ /**
+ * In case the SBSFU is implemented, it may have already set the C2BOOT bit to startup the CPU2.
+ * In that case, to keep the mechanism transparent to the user application, it shall call the system command
+ * SHCI_C2_Reinit( ) before jumping to the application.
+ * When the CPU2 receives that command, it waits for its event input to be set to restart the CPU2 firmware.
+ * This is required because once C2BOOT has been set once, a clear/set on C2BOOT has no effect.
+ * When SHCI_C2_Reinit( ) is not called, generating an event to the CPU2 does not have any effect
+ * So, by default, the application shall both set the event flag and set the C2BOOT bit.
+ */
+ __SEV( ); /* Set the internal event flag and send an event to the CPU2 */
+ __WFE( ); /* Clear the internal event flag */
+ LL_PWR_EnableBootC2( );
+
+ return;
+}
+
+void HW_IPCC_Init( void )
+{
+ LL_AHB3_GRP1_EnableClock( LL_AHB3_GRP1_PERIPH_IPCC );
+
+ LL_C1_IPCC_EnableIT_RXO( IPCC );
+ LL_C1_IPCC_EnableIT_TXF( IPCC );
+
+ HAL_NVIC_EnableIRQ(IPCC_C1_RX_IRQn);
+ HAL_NVIC_EnableIRQ(IPCC_C1_TX_IRQn);
+
+ return;
+}
+
+/******************************************************************************
+ * BLE
+ ******************************************************************************/
+void HW_IPCC_BLE_Init( void )
+{
+ UTILS_ENTER_CRITICAL_SECTION();
+ LL_C1_IPCC_EnableReceiveChannel( IPCC, HW_IPCC_BLE_EVENT_CHANNEL );
+ UTILS_EXIT_CRITICAL_SECTION();
+
+ return;
+}
+
+void HW_IPCC_BLE_SendCmd( void )
+{
+ LL_C1_IPCC_SetFlag_CHx( IPCC, HW_IPCC_BLE_CMD_CHANNEL );
+
+ return;
+}
+
+static void HW_IPCC_BLE_EvtHandler( void )
+{
+ HW_IPCC_BLE_RxEvtNot();
+
+ LL_C1_IPCC_ClearFlag_CHx( IPCC, HW_IPCC_BLE_EVENT_CHANNEL );
+
+ return;
+}
+
+void HW_IPCC_BLE_SendAclData( void )
+{
+ LL_C1_IPCC_SetFlag_CHx( IPCC, HW_IPCC_HCI_ACL_DATA_CHANNEL );
+ UTILS_ENTER_CRITICAL_SECTION();
+ LL_C1_IPCC_EnableTransmitChannel( IPCC, HW_IPCC_HCI_ACL_DATA_CHANNEL );
+ UTILS_EXIT_CRITICAL_SECTION();
+
+ return;
+}
+
+static void HW_IPCC_BLE_AclDataEvtHandler( void )
+{
+ UTILS_ENTER_CRITICAL_SECTION();
+ LL_C1_IPCC_DisableTransmitChannel( IPCC, HW_IPCC_HCI_ACL_DATA_CHANNEL );
+ UTILS_EXIT_CRITICAL_SECTION();
+
+ HW_IPCC_BLE_AclDataAckNot();
+
+ return;
+}
+
+__weak void HW_IPCC_BLE_AclDataAckNot( void ){};
+__weak void HW_IPCC_BLE_RxEvtNot( void ){};
+
+/******************************************************************************
+ * SYSTEM
+ ******************************************************************************/
+void HW_IPCC_SYS_Init( void )
+{
+ UTILS_ENTER_CRITICAL_SECTION();
+ LL_C1_IPCC_EnableReceiveChannel( IPCC, HW_IPCC_SYSTEM_EVENT_CHANNEL );
+ UTILS_EXIT_CRITICAL_SECTION();
+
+ return;
+}
+
+void HW_IPCC_SYS_SendCmd( void )
+{
+ LL_C1_IPCC_SetFlag_CHx( IPCC, HW_IPCC_SYSTEM_CMD_RSP_CHANNEL );
+ UTILS_ENTER_CRITICAL_SECTION();
+ LL_C1_IPCC_EnableTransmitChannel( IPCC, HW_IPCC_SYSTEM_CMD_RSP_CHANNEL );
+ UTILS_EXIT_CRITICAL_SECTION();
+
+ return;
+}
+
+static void HW_IPCC_SYS_CmdEvtHandler( void )
+{
+ UTILS_ENTER_CRITICAL_SECTION();
+ LL_C1_IPCC_DisableTransmitChannel( IPCC, HW_IPCC_SYSTEM_CMD_RSP_CHANNEL );
+ UTILS_EXIT_CRITICAL_SECTION();
+
+ HW_IPCC_SYS_CmdEvtNot();
+
+ return;
+}
+
+static void HW_IPCC_SYS_EvtHandler( void )
+{
+ HW_IPCC_SYS_EvtNot();
+
+ LL_C1_IPCC_ClearFlag_CHx( IPCC, HW_IPCC_SYSTEM_EVENT_CHANNEL );
+
+ return;
+}
+
+__weak void HW_IPCC_SYS_CmdEvtNot( void ){};
+__weak void HW_IPCC_SYS_EvtNot( void ){};
+
+/******************************************************************************
+ * MAC 802.15.4
+ ******************************************************************************/
+#ifdef MAC_802_15_4_WB
+void HW_IPCC_MAC_802_15_4_Init( void )
+{
+ UTILS_ENTER_CRITICAL_SECTION();
+ LL_C1_IPCC_EnableReceiveChannel( IPCC, HW_IPCC_MAC_802_15_4_NOTIFICATION_ACK_CHANNEL );
+ UTILS_EXIT_CRITICAL_SECTION();
+
+ return;
+}
+
+void HW_IPCC_MAC_802_15_4_SendCmd( void )
+{
+ LL_C1_IPCC_SetFlag_CHx( IPCC, HW_IPCC_MAC_802_15_4_CMD_RSP_CHANNEL );
+ UTILS_ENTER_CRITICAL_SECTION();
+ LL_C1_IPCC_EnableTransmitChannel( IPCC, HW_IPCC_MAC_802_15_4_CMD_RSP_CHANNEL );
+ UTILS_EXIT_CRITICAL_SECTION();
+
+ return;
+}
+
+void HW_IPCC_MAC_802_15_4_SendAck( void )
+{
+ LL_C1_IPCC_ClearFlag_CHx( IPCC, HW_IPCC_MAC_802_15_4_NOTIFICATION_ACK_CHANNEL );
+ UTILS_ENTER_CRITICAL_SECTION();
+ LL_C1_IPCC_EnableReceiveChannel( IPCC, HW_IPCC_MAC_802_15_4_NOTIFICATION_ACK_CHANNEL );
+ UTILS_EXIT_CRITICAL_SECTION();
+
+ return;
+}
+
+static void HW_IPCC_MAC_802_15_4_CmdEvtHandler( void )
+{
+ UTILS_ENTER_CRITICAL_SECTION();
+ LL_C1_IPCC_DisableTransmitChannel( IPCC, HW_IPCC_MAC_802_15_4_CMD_RSP_CHANNEL );
+ UTILS_EXIT_CRITICAL_SECTION();
+
+ HW_IPCC_MAC_802_15_4_CmdEvtNot();
+
+ return;
+}
+
+static void HW_IPCC_MAC_802_15_4_NotEvtHandler( void )
+{
+ UTILS_ENTER_CRITICAL_SECTION();
+ LL_C1_IPCC_DisableReceiveChannel( IPCC, HW_IPCC_MAC_802_15_4_NOTIFICATION_ACK_CHANNEL );
+ UTILS_EXIT_CRITICAL_SECTION();
+
+ HW_IPCC_MAC_802_15_4_EvtNot();
+
+ return;
+}
+__weak void HW_IPCC_MAC_802_15_4_CmdEvtNot( void ){};
+__weak void HW_IPCC_MAC_802_15_4_EvtNot( void ){};
+#endif
+
+/******************************************************************************
+ * THREAD
+ ******************************************************************************/
+#ifdef THREAD_WB
+void HW_IPCC_THREAD_Init( void )
+{
+ UTILS_ENTER_CRITICAL_SECTION();
+ LL_C1_IPCC_EnableReceiveChannel( IPCC, HW_IPCC_THREAD_NOTIFICATION_ACK_CHANNEL );
+ LL_C1_IPCC_EnableReceiveChannel( IPCC, HW_IPCC_THREAD_CLI_NOTIFICATION_ACK_CHANNEL );
+ UTILS_EXIT_CRITICAL_SECTION();
+
+ return;
+}
+
+void HW_IPCC_OT_SendCmd( void )
+{
+ LL_C1_IPCC_SetFlag_CHx( IPCC, HW_IPCC_THREAD_OT_CMD_RSP_CHANNEL );
+ UTILS_ENTER_CRITICAL_SECTION();
+ LL_C1_IPCC_EnableTransmitChannel( IPCC, HW_IPCC_THREAD_OT_CMD_RSP_CHANNEL );
+ UTILS_EXIT_CRITICAL_SECTION();
+
+ return;
+}
+
+void HW_IPCC_CLI_SendCmd( void )
+{
+ LL_C1_IPCC_SetFlag_CHx( IPCC, HW_IPCC_THREAD_CLI_CMD_CHANNEL );
+
+ return;
+}
+
+void HW_IPCC_THREAD_SendAck( void )
+{
+ LL_C1_IPCC_ClearFlag_CHx( IPCC, HW_IPCC_THREAD_NOTIFICATION_ACK_CHANNEL );
+ UTILS_ENTER_CRITICAL_SECTION();
+ LL_C1_IPCC_EnableReceiveChannel( IPCC, HW_IPCC_THREAD_NOTIFICATION_ACK_CHANNEL );
+ UTILS_EXIT_CRITICAL_SECTION();
+
+ return;
+}
+
+void HW_IPCC_THREAD_CliSendAck( void )
+{
+ LL_C1_IPCC_ClearFlag_CHx( IPCC, HW_IPCC_THREAD_CLI_NOTIFICATION_ACK_CHANNEL );
+ UTILS_ENTER_CRITICAL_SECTION();
+ LL_C1_IPCC_EnableReceiveChannel( IPCC, HW_IPCC_THREAD_CLI_NOTIFICATION_ACK_CHANNEL );
+ UTILS_EXIT_CRITICAL_SECTION();
+
+ return;
+}
+
+static void HW_IPCC_OT_CmdEvtHandler( void )
+{
+ UTILS_ENTER_CRITICAL_SECTION();
+ LL_C1_IPCC_DisableTransmitChannel( IPCC, HW_IPCC_THREAD_OT_CMD_RSP_CHANNEL );
+ UTILS_EXIT_CRITICAL_SECTION();
+
+ HW_IPCC_OT_CmdEvtNot();
+
+ return;
+}
+
+static void HW_IPCC_THREAD_NotEvtHandler( void )
+{
+ UTILS_ENTER_CRITICAL_SECTION();
+ LL_C1_IPCC_DisableReceiveChannel( IPCC, HW_IPCC_THREAD_NOTIFICATION_ACK_CHANNEL );
+ UTILS_EXIT_CRITICAL_SECTION();
+
+ HW_IPCC_THREAD_EvtNot();
+
+ return;
+}
+
+static void HW_IPCC_THREAD_CliNotEvtHandler( void )
+{
+ UTILS_ENTER_CRITICAL_SECTION();
+ LL_C1_IPCC_DisableReceiveChannel( IPCC, HW_IPCC_THREAD_CLI_NOTIFICATION_ACK_CHANNEL );
+ UTILS_EXIT_CRITICAL_SECTION();
+
+ HW_IPCC_THREAD_CliEvtNot();
+
+ return;
+}
+
+__weak void HW_IPCC_OT_CmdEvtNot( void ){};
+__weak void HW_IPCC_CLI_CmdEvtNot( void ){};
+__weak void HW_IPCC_THREAD_EvtNot( void ){};
+
+#endif /* THREAD_WB */
+
+/******************************************************************************
+ * LLD TESTS
+ ******************************************************************************/
+#ifdef LLD_TESTS_WB
+void HW_IPCC_LLDTESTS_Init( void )
+{
+ UTILS_ENTER_CRITICAL_SECTION();
+ LL_C1_IPCC_EnableReceiveChannel( IPCC, HW_IPCC_LLDTESTS_CLI_RSP_CHANNEL );
+ LL_C1_IPCC_EnableReceiveChannel( IPCC, HW_IPCC_LLDTESTS_M0_CMD_CHANNEL );
+ UTILS_EXIT_CRITICAL_SECTION();
+ return;
+}
+
+void HW_IPCC_LLDTESTS_SendCliCmd( void )
+{
+ LL_C1_IPCC_SetFlag_CHx( IPCC, HW_IPCC_LLDTESTS_CLI_CMD_CHANNEL );
+ return;
+}
+
+static void HW_IPCC_LLDTESTS_ReceiveCliRspHandler( void )
+{
+ UTILS_ENTER_CRITICAL_SECTION();
+ LL_C1_IPCC_DisableReceiveChannel( IPCC, HW_IPCC_LLDTESTS_CLI_RSP_CHANNEL );
+ UTILS_EXIT_CRITICAL_SECTION();
+
+ HW_IPCC_LLDTESTS_ReceiveCliRsp();
+ return;
+}
+
+void HW_IPCC_LLDTESTS_SendCliRspAck( void )
+{
+ LL_C1_IPCC_ClearFlag_CHx( IPCC, HW_IPCC_LLDTESTS_CLI_RSP_CHANNEL );
+ UTILS_ENTER_CRITICAL_SECTION();
+ LL_C1_IPCC_EnableReceiveChannel( IPCC, HW_IPCC_LLDTESTS_CLI_RSP_CHANNEL );
+ UTILS_EXIT_CRITICAL_SECTION();
+ return;
+}
+
+static void HW_IPCC_LLDTESTS_ReceiveM0CmdHandler( void )
+{
+ UTILS_ENTER_CRITICAL_SECTION();
+ LL_C1_IPCC_DisableReceiveChannel( IPCC, HW_IPCC_LLDTESTS_M0_CMD_CHANNEL );
+ UTILS_EXIT_CRITICAL_SECTION();
+ HW_IPCC_LLDTESTS_ReceiveM0Cmd();
+ return;
+}
+
+void HW_IPCC_LLDTESTS_SendM0CmdAck( void )
+{
+ LL_C1_IPCC_ClearFlag_CHx( IPCC, HW_IPCC_LLDTESTS_M0_CMD_CHANNEL );
+ UTILS_ENTER_CRITICAL_SECTION();
+ LL_C1_IPCC_EnableReceiveChannel( IPCC, HW_IPCC_LLDTESTS_M0_CMD_CHANNEL );
+ UTILS_EXIT_CRITICAL_SECTION();
+ return;
+}
+__weak void HW_IPCC_LLDTESTS_ReceiveCliRsp( void ){};
+__weak void HW_IPCC_LLDTESTS_ReceiveM0Cmd( void ){};
+#endif /* LLD_TESTS_WB */
+
+/******************************************************************************
+ * LLD BLE
+ ******************************************************************************/
+#ifdef LLD_BLE_WB
+void HW_IPCC_LLD_BLE_Init( void )
+{
+ UTILS_ENTER_CRITICAL_SECTION();
+ LL_C1_IPCC_EnableReceiveChannel( IPCC, HW_IPCC_LLD_BLE_RSP_CHANNEL );
+ LL_C1_IPCC_EnableReceiveChannel( IPCC, HW_IPCC_LLD_BLE_M0_CMD_CHANNEL );
+ UTILS_EXIT_CRITICAL_SECTION();
+ return;
+}
+
+void HW_IPCC_LLD_BLE_SendCliCmd( void )
+{
+ LL_C1_IPCC_SetFlag_CHx( IPCC, HW_IPCC_LLD_BLE_CLI_CMD_CHANNEL );
+ return;
+}
+
+/*static void HW_IPCC_LLD_BLE_ReceiveCliRspHandler( void )
+{
+ UTILS_ENTER_CRITICAL_SECTION();
+ LL_C1_IPCC_DisableReceiveChannel( IPCC, HW_IPCC_LLD_BLE_CLI_RSP_CHANNEL );
+ UTILS_EXIT_CRITICAL_SECTION();
+ HW_IPCC_LLD_BLE_ReceiveCliRsp();
+ return;
+}*/
+
+void HW_IPCC_LLD_BLE_SendCliRspAck( void )
+{
+ LL_C1_IPCC_ClearFlag_CHx( IPCC, HW_IPCC_LLD_BLE_CLI_RSP_CHANNEL );
+ UTILS_ENTER_CRITICAL_SECTION();
+ LL_C1_IPCC_EnableReceiveChannel( IPCC, HW_IPCC_LLD_BLE_CLI_RSP_CHANNEL );
+ UTILS_EXIT_CRITICAL_SECTION();
+ return;
+}
+
+static void HW_IPCC_LLD_BLE_ReceiveM0CmdHandler( void )
+{
+ //LL_C1_IPCC_DisableReceiveChannel( IPCC, HW_IPCC_LLD_BLE_M0_CMD_CHANNEL );
+ HW_IPCC_LLD_BLE_ReceiveM0Cmd();
+ return;
+}
+
+void HW_IPCC_LLD_BLE_SendM0CmdAck( void )
+{
+ LL_C1_IPCC_ClearFlag_CHx( IPCC, HW_IPCC_LLD_BLE_M0_CMD_CHANNEL );
+ //LL_C1_IPCC_EnableReceiveChannel( IPCC, HW_IPCC_LLD_BLE_M0_CMD_CHANNEL );
+ return;
+}
+__weak void HW_IPCC_LLD_BLE_ReceiveCliRsp( void ){};
+__weak void HW_IPCC_LLD_BLE_ReceiveM0Cmd( void ){};
+
+/* Transparent Mode */
+void HW_IPCC_LLD_BLE_SendCmd( void )
+{
+ LL_C1_IPCC_SetFlag_CHx( IPCC, HW_IPCC_LLD_BLE_CMD_CHANNEL );
+ return;
+}
+
+static void HW_IPCC_LLD_BLE_ReceiveRspHandler( void )
+{
+ UTILS_ENTER_CRITICAL_SECTION();
+ LL_C1_IPCC_DisableReceiveChannel( IPCC, HW_IPCC_LLD_BLE_RSP_CHANNEL );
+ UTILS_EXIT_CRITICAL_SECTION();
+ HW_IPCC_LLD_BLE_ReceiveRsp();
+ return;
+}
+
+void HW_IPCC_LLD_BLE_SendRspAck( void )
+{
+ LL_C1_IPCC_ClearFlag_CHx( IPCC, HW_IPCC_LLD_BLE_RSP_CHANNEL );
+ UTILS_ENTER_CRITICAL_SECTION();
+ LL_C1_IPCC_EnableReceiveChannel( IPCC, HW_IPCC_LLD_BLE_RSP_CHANNEL );
+ UTILS_EXIT_CRITICAL_SECTION();
+ return;
+}
+
+#endif /* LLD_BLE_WB */
+
+/******************************************************************************
+ * ZIGBEE
+ ******************************************************************************/
+#ifdef ZIGBEE_WB
+void HW_IPCC_ZIGBEE_Init( void )
+{
+ UTILS_ENTER_CRITICAL_SECTION();
+ LL_C1_IPCC_EnableReceiveChannel( IPCC, HW_IPCC_ZIGBEE_APPLI_NOTIF_ACK_CHANNEL );
+ LL_C1_IPCC_EnableReceiveChannel( IPCC, HW_IPCC_ZIGBEE_M0_REQUEST_CHANNEL );
+ UTILS_EXIT_CRITICAL_SECTION();
+
+ return;
+}
+
+void HW_IPCC_ZIGBEE_SendM4RequestToM0( void )
+{
+ LL_C1_IPCC_SetFlag_CHx( IPCC, HW_IPCC_ZIGBEE_CMD_APPLI_CHANNEL );
+ UTILS_ENTER_CRITICAL_SECTION();
+ LL_C1_IPCC_EnableTransmitChannel( IPCC, HW_IPCC_ZIGBEE_CMD_APPLI_CHANNEL );
+ UTILS_EXIT_CRITICAL_SECTION();
+
+ return;
+}
+
+void HW_IPCC_ZIGBEE_SendM4AckToM0Notify( void )
+{
+ LL_C1_IPCC_ClearFlag_CHx( IPCC, HW_IPCC_ZIGBEE_APPLI_NOTIF_ACK_CHANNEL );
+ UTILS_ENTER_CRITICAL_SECTION();
+ LL_C1_IPCC_EnableReceiveChannel( IPCC, HW_IPCC_ZIGBEE_APPLI_NOTIF_ACK_CHANNEL );
+ UTILS_EXIT_CRITICAL_SECTION();
+
+ return;
+}
+
+static void HW_IPCC_ZIGBEE_CmdEvtHandler( void )
+{
+ UTILS_ENTER_CRITICAL_SECTION();
+ LL_C1_IPCC_DisableTransmitChannel( IPCC, HW_IPCC_ZIGBEE_CMD_APPLI_CHANNEL );
+ UTILS_EXIT_CRITICAL_SECTION();
+
+ HW_IPCC_ZIGBEE_RecvAppliAckFromM0();
+
+ return;
+}
+
+static void HW_IPCC_ZIGBEE_StackNotifEvtHandler( void )
+{
+ UTILS_ENTER_CRITICAL_SECTION();
+ LL_C1_IPCC_DisableReceiveChannel( IPCC, HW_IPCC_ZIGBEE_APPLI_NOTIF_ACK_CHANNEL );
+ UTILS_EXIT_CRITICAL_SECTION();
+
+ HW_IPCC_ZIGBEE_RecvM0NotifyToM4();
+
+ return;
+}
+
+static void HW_IPCC_ZIGBEE_StackM0RequestHandler( void )
+{
+ UTILS_ENTER_CRITICAL_SECTION();
+ LL_C1_IPCC_DisableReceiveChannel( IPCC, HW_IPCC_ZIGBEE_M0_REQUEST_CHANNEL );
+ UTILS_EXIT_CRITICAL_SECTION();
+
+ HW_IPCC_ZIGBEE_RecvM0RequestToM4();
+
+ return;
+}
+
+void HW_IPCC_ZIGBEE_SendM4AckToM0Request( void )
+{
+ LL_C1_IPCC_ClearFlag_CHx( IPCC, HW_IPCC_ZIGBEE_M0_REQUEST_CHANNEL );
+ UTILS_ENTER_CRITICAL_SECTION();
+ LL_C1_IPCC_EnableReceiveChannel( IPCC, HW_IPCC_ZIGBEE_M0_REQUEST_CHANNEL );
+ UTILS_EXIT_CRITICAL_SECTION();
+
+ return;
+}
+
+__weak void HW_IPCC_ZIGBEE_RecvAppliAckFromM0( void ){};
+__weak void HW_IPCC_ZIGBEE_RecvM0NotifyToM4( void ){};
+__weak void HW_IPCC_ZIGBEE_RecvM0RequestToM4( void ){};
+#endif /* ZIGBEE_WB */
+
+/******************************************************************************
+ * MEMORY MANAGER
+ ******************************************************************************/
+void HW_IPCC_MM_SendFreeBuf( void (*cb)( void ) )
+{
+ if ( LL_C1_IPCC_IsActiveFlag_CHx( IPCC, HW_IPCC_MM_RELEASE_BUFFER_CHANNEL ) )
+ {
+ FreeBufCb = cb;
+ UTILS_ENTER_CRITICAL_SECTION();
+ LL_C1_IPCC_EnableTransmitChannel( IPCC, HW_IPCC_MM_RELEASE_BUFFER_CHANNEL );
+ UTILS_EXIT_CRITICAL_SECTION();
+ }
+ else
+ {
+ cb();
+
+ LL_C1_IPCC_SetFlag_CHx( IPCC, HW_IPCC_MM_RELEASE_BUFFER_CHANNEL );
+ }
+
+ return;
+}
+
+static void HW_IPCC_MM_FreeBufHandler( void )
+{
+ UTILS_ENTER_CRITICAL_SECTION();
+ LL_C1_IPCC_DisableTransmitChannel( IPCC, HW_IPCC_MM_RELEASE_BUFFER_CHANNEL );
+ UTILS_EXIT_CRITICAL_SECTION();
+
+ FreeBufCb();
+
+ LL_C1_IPCC_SetFlag_CHx( IPCC, HW_IPCC_MM_RELEASE_BUFFER_CHANNEL );
+
+ return;
+}
+
+/******************************************************************************
+ * TRACES
+ ******************************************************************************/
+void HW_IPCC_TRACES_Init( void )
+{
+ UTILS_ENTER_CRITICAL_SECTION();
+ LL_C1_IPCC_EnableReceiveChannel( IPCC, HW_IPCC_TRACES_CHANNEL );
+ UTILS_EXIT_CRITICAL_SECTION();
+
+ return;
+}
+
+static void HW_IPCC_TRACES_EvtHandler( void )
+{
+ HW_IPCC_TRACES_EvtNot();
+
+ LL_C1_IPCC_ClearFlag_CHx( IPCC, HW_IPCC_TRACES_CHANNEL );
+
+ return;
+}
+
+__weak void HW_IPCC_TRACES_EvtNot( void ){};
|