From fb1611c0ca99d9e609057c46507be2af8389bb7b Mon Sep 17 00:00:00 2001 From: Anson Bridges Date: Tue, 17 Feb 2026 11:37:50 -0800 Subject: firmware coad --- firmware/memory_chip_gone/STM32_WPAN/App/app_ble.c | 1432 ++++++++++++++++++++ firmware/memory_chip_gone/STM32_WPAN/App/app_ble.h | 81 ++ .../memory_chip_gone/STM32_WPAN/App/ble_conf.h | 70 + .../memory_chip_gone/STM32_WPAN/App/ble_dbg_conf.h | 198 +++ .../STM32_WPAN/App/p2p_server_app.c | 154 +++ .../STM32_WPAN/App/p2p_server_app.h | 78 ++ .../memory_chip_gone/STM32_WPAN/App/tl_dbg_conf.h | 133 ++ .../memory_chip_gone/STM32_WPAN/Target/hw_ipcc.c | 747 ++++++++++ 8 files changed, 2893 insertions(+) create mode 100644 firmware/memory_chip_gone/STM32_WPAN/App/app_ble.c create mode 100644 firmware/memory_chip_gone/STM32_WPAN/App/app_ble.h create mode 100644 firmware/memory_chip_gone/STM32_WPAN/App/ble_conf.h create mode 100644 firmware/memory_chip_gone/STM32_WPAN/App/ble_dbg_conf.h create mode 100644 firmware/memory_chip_gone/STM32_WPAN/App/p2p_server_app.c create mode 100644 firmware/memory_chip_gone/STM32_WPAN/App/p2p_server_app.h create mode 100644 firmware/memory_chip_gone/STM32_WPAN/App/tl_dbg_conf.h create mode 100644 firmware/memory_chip_gone/STM32_WPAN/Target/hw_ipcc.c (limited to 'firmware/memory_chip_gone/STM32_WPAN') 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<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 ){}; -- cgit v1.2.3