jochen/stm32cubeide
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
stm32cubeide/USB-PD_Provider_1port/Src/usbpd_dpm_user.c

1012 lines
35 KiB
C
Raw Normal View History

Initial commit
2021-01-01 14:06:20 +01:00
/* USER CODE BEGIN Header */
/**
******************************************************************************
* @file usbpd_dpm_user.c
* @author MCD Application Team
* @brief USBPD DPM user code
******************************************************************************
* @attention
*
* <h2><center>&copy; Copyright (c) 2020 STMicroelectronics.
* All rights reserved.</center></h2>
*
* This software component is licensed by ST under Ultimate Liberty license
* SLA0044, the "License"; You may not use this file except in compliance with
* the License. You may obtain a copy of the License at:
* www.st.com/SLA0044
*
******************************************************************************
*/
/* USER CODE END Header */
#define USBPD_DPM_USER_C
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "usbpd_core.h"
#include "usbpd_dpm_user.h"
#include "usbpd_pdo_defs.h"
#include "usbpd_dpm_core.h"
#include "usbpd_dpm_conf.h"
#include "usbpd_vdm_user.h"
#include "usbpd_pwr_if.h"
#include "usbpd_pwr_user.h"
#include "cmsis_os.h"
#if defined(_TRACE)
#include "usbpd_trace.h"
#include "string.h"
#include "stdio.h"
#endif /* _TRACE */
/** @addtogroup STM32_USBPD_APPLICATION
* @{
*/
/** @addtogroup STM32_USBPD_APPLICATION_DPM_USER
* @{
*/
/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN Private_Typedef */
/* USER CODE END Private_Typedef */
/* Private define ------------------------------------------------------------*/
/** @defgroup USBPD_USER_PRIVATE_DEFINES USBPD USER Private Defines
* @{
*/
#define DPM_GUI_NOTIF_ISCONNECTED (1 << 5)
#define DPM_GUI_NOTIF_POWER_EVENT (1 << 15)
#if (osCMSIS < 0x20000U)
void USBPD_DPM_UserExecute(void const *argument);
#else
void USBPD_DPM_UserExecute(void *argument);
#endif /* osCMSIS < 0x20000U */
/* USER CODE BEGIN Private_Define */
/* USER CODE END Private_Define */
/**
* @}
*/
/* Private macro -------------------------------------------------------------*/
/** @defgroup USBPD_USER_PRIVATE_MACROS USBPD USER Private Macros
* @{
*/
#if defined(_TRACE)
#define DPM_USER_DEBUG_TRACE_SIZE 50u
#define DPM_USER_DEBUG_TRACE(_PORT_, ...) do { \
char _str[DPM_USER_DEBUG_TRACE_SIZE]; \
uint8_t _size = snprintf(_str, DPM_USER_DEBUG_TRACE_SIZE, __VA_ARGS__); \
if (_size < DPM_USER_DEBUG_TRACE_SIZE) \
USBPD_TRACE_Add(USBPD_TRACE_DEBUG, (uint8_t)(_PORT_), 0, (uint8_t*)_str, strlen(_str)); \
else \
USBPD_TRACE_Add(USBPD_TRACE_DEBUG, (uint8_t)(_PORT_), 0, (uint8_t*)_str, DPM_USER_DEBUG_TRACE_SIZE); \
} while(0)
#define DPM_USER_ERROR_TRACE(_PORT_, _STATUS_, ...) do { \
if (USBPD_OK != _STATUS_) { \
char _str[DPM_USER_DEBUG_TRACE_SIZE]; \
uint8_t _size = snprintf(_str, DPM_USER_DEBUG_TRACE_SIZE, __VA_ARGS__); \
if (_size < DPM_USER_DEBUG_TRACE_SIZE) \
USBPD_TRACE_Add(USBPD_TRACE_DEBUG, (uint8_t)(_PORT_), 0, (uint8_t*)_str, strlen(_str)); \
else \
USBPD_TRACE_Add(USBPD_TRACE_DEBUG, (uint8_t)(_PORT_), 0, (uint8_t*)_str, DPM_USER_DEBUG_TRACE_SIZE); \
} \
} while(0)
#else
#define DPM_USER_DEBUG_TRACE(_PORT_, ...)
#define DPM_USER_ERROR_TRACE(_PORT_, _STATUS_, ...)
#endif /* _TRACE */
/* USER CODE BEGIN Private_Macro */
/* USER CODE END Private_Macro */
/**
* @}
*/
/* Private variables ---------------------------------------------------------*/
/** @defgroup USBPD_USER_PRIVATE_VARIABLES USBPD USER Private Variables
* @{
*/
GUI_NOTIFICATION_POST DPM_GUI_PostNotificationMessage = NULL;
GUI_NOTIFICATION_FORMAT_SEND DPM_GUI_FormatAndSendNotification = NULL;
GUI_SAVE_INFO DPM_GUI_SaveInfo = NULL;
/* USER CODE BEGIN Private_Variables */
USBPD_HandleTypeDef DPM_Ports[USBPD_PORT_COUNT];
/* USER CODE END Private_Variables */
/**
* @}
*/
/* Private function prototypes -----------------------------------------------*/
/** @defgroup USBPD_USER_PRIVATE_FUNCTIONS USBPD USER Private Functions
* @{
*/
/* USER CODE BEGIN USBPD_USER_PRIVATE_FUNCTIONS_Prototypes */
/* USER CODE END USBPD_USER_PRIVATE_FUNCTIONS_Prototypes */
/**
* @}
*/
/* Exported functions ------- ------------------------------------------------*/
/** @defgroup USBPD_USER_EXPORTED_FUNCTIONS USBPD USER Exported Functions
* @{
*/
/* USER CODE BEGIN USBPD_USER_EXPORTED_FUNCTIONS */
/* USER CODE END USBPD_USER_EXPORTED_FUNCTIONS */
/** @defgroup USBPD_USER_EXPORTED_FUNCTIONS_GROUP1 USBPD USER Exported Functions called by DPM CORE
* @{
*/
/* USER CODE BEGIN USBPD_USER_EXPORTED_FUNCTIONS_GROUP1 */
/* USER CODE END USBPD_USER_EXPORTED_FUNCTIONS_GROUP1 */
/**
* @brief Initialize DPM (port power role, PWR_IF, CAD and PE Init procedures)
* @retval USBPD Status
*/
USBPD_StatusTypeDef USBPD_DPM_UserInit(void)
{
/* USER CODE BEGIN USBPD_DPM_UserInit */
/* PWR SET UP */
if(USBPD_OK != USBPD_PWR_IF_Init())
{
return USBPD_ERROR;
}
return USBPD_OK;
/* USER CODE END USBPD_DPM_UserInit */
}
/**
* @brief Function to set the function ptr linked to GUI interface
* @param PtrFormatSend Pointer on function to format and send GUI notifications
* @param PtrPost Pointer on function to send GUI notifications
* @param PtrSaveInfo Pointer on function to save information from Port Partner
* @retval None
*/
void USBPD_DPM_SetNotification_GUI(GUI_NOTIFICATION_FORMAT_SEND PtrFormatSend, GUI_NOTIFICATION_POST PtrPost, GUI_SAVE_INFO PtrSaveInfo)
{
DPM_GUI_PostNotificationMessage = PtrPost;
DPM_GUI_FormatAndSendNotification = PtrFormatSend;
DPM_GUI_SaveInfo = PtrSaveInfo;
}
/**
* @brief User processing time, it is recommended to avoid blocking task for long time
* @param argument DPM User event
* @retval None
*/
#if (osCMSIS < 0x20000U)
void USBPD_DPM_UserExecute(void const *argument)
#else
void USBPD_DPM_UserExecute(void *argument)
#endif /* osCMSIS < 0x20000U */
{
/* USER CODE BEGIN USBPD_DPM_UserExecute */
/* USER CODE END USBPD_DPM_UserExecute */
}
/**
* @brief UserCableDetection reporting events on a specified port from CAD layer.
* @param PortNum The handle of the port
* @param State CAD state
* @retval None
*/
void USBPD_DPM_UserCableDetection(uint8_t PortNum, USBPD_CAD_EVENT State)
{
switch(State)
{
case USBPD_CAD_EVENT_ATTEMC:
case USBPD_CAD_EVENT_ATTACHED:
/* Format and send a notification to GUI if enabled */
if (NULL != DPM_GUI_FormatAndSendNotification)
{
DPM_GUI_FormatAndSendNotification(PortNum, DPM_GUI_NOTIF_ISCONNECTED, 0);
}
break;
default :
/* Format and send a notification to GUI if enabled */
if (NULL != DPM_GUI_FormatAndSendNotification)
{
DPM_GUI_FormatAndSendNotification(PortNum, DPM_GUI_NOTIF_ISCONNECTED | DPM_GUI_NOTIF_POWER_EVENT, 0);
}
}
/* USER CODE BEGIN USBPD_DPM_UserCableDetection */
switch(State)
{
case USBPD_CAD_EVENT_ATTACHED:
case USBPD_CAD_EVENT_ATTEMC:
{
if (USBPD_OK != USBPD_PWR_IF_VBUSEnable(PortNum))
{
/* Should not occur */
osDelay(6000);
NVIC_SystemReset();
}
break;
}
case USBPD_CAD_EVENT_DETACHED :
case USBPD_CAD_EVENT_EMC :
default :
{
if (USBPD_OK != USBPD_PWR_IF_VBUSDisable(PortNum))
{
/* Should not occur */
while(1);
}
break;
}
}
/* USER CODE END USBPD_DPM_UserCableDetection */
}
/**
* @brief function used to manage user timer.
* @param PortNum Port number
* @retval None
*/
void USBPD_DPM_UserTimerCounter(uint8_t PortNum)
{
/* USER CODE BEGIN USBPD_DPM_UserTimerCounter */
/* USER CODE END USBPD_DPM_UserTimerCounter */
}
/**
* @}
*/
/** @defgroup USBPD_USER_EXPORTED_FUNCTIONS_GROUP2 USBPD USER Exported Callbacks functions called by PE
* @{
*/
/**
* @brief Callback function called by PE layer when HardReset message received from PRL
* @param PortNum The current port number
* @param CurrentRole the current role
* @param Status status on hard reset event
* @retval None
*/
void USBPD_DPM_HardReset(uint8_t PortNum, USBPD_PortPowerRole_TypeDef CurrentRole, USBPD_HR_Status_TypeDef Status)
{
/* USER CODE BEGIN USBPD_DPM_HardReset */
switch (Status)
{
case USBPD_HR_STATUS_START_ACK:
case USBPD_HR_STATUS_START_REQ:
{
/* Reset the power supply */
USBPD_PWR_IF_VBUSDisable(PortNum);
break;
}
case USBPD_HR_STATUS_COMPLETED:
{
/* Reset the power supply */
USBPD_PWR_IF_VBUSEnable(PortNum);
break;
}
default:
break;
}
/* USER CODE END USBPD_DPM_HardReset */
}
/**
* @brief Request the DPM to setup the new power level.
* @param PortNum The current port number
* @retval USBPD status
*/
USBPD_StatusTypeDef USBPD_DPM_SetupNewPower(uint8_t PortNum)
{
/* USER CODE BEGIN USBPD_DPM_SetupNewPower */
return USBPD_PWR_IF_SetProfile(PortNum);
/* USER CODE END USBPD_DPM_SetupNewPower */
}
/**
* @brief Callback function called by PE to inform DPM about PE event.
* @param PortNum The current port number
* @param EventVal @ref USBPD_NotifyEventValue_TypeDef
* @retval None
*/
void USBPD_DPM_Notification(uint8_t PortNum, USBPD_NotifyEventValue_TypeDef EventVal)
{
/* Forward PE notifications to GUI if enabled */
if (NULL != DPM_GUI_PostNotificationMessage)
{
DPM_GUI_PostNotificationMessage(PortNum, EventVal);
}
/* USER CODE BEGIN USBPD_DPM_Notification */
/* USER CODE END USBPD_DPM_Notification */
}
/**
* @brief DPM callback to allow PE to retrieve information from DPM/PWR_IF.
* @param PortNum Port number
* @param DataId Type of data to be updated in DPM based on @ref USBPD_CORE_DataInfoType_TypeDef
* @param Ptr Pointer on address where DPM data should be written (u8 pointer)
* @param Size Pointer on nb of u8 written by DPM
* @retval None
*/
void USBPD_DPM_GetDataInfo(uint8_t PortNum, USBPD_CORE_DataInfoType_TypeDef DataId, uint8_t *Ptr, uint32_t *Size)
{
/* USER CODE BEGIN USBPD_DPM_GetDataInfo */
/* Check type of information targeted by request */
switch(DataId)
{
/* Case Port Source PDO Data information :
Case Port SINK PDO Data information :
Call PWR_IF PDO reading request.
*/
case USBPD_CORE_DATATYPE_SRC_PDO :
case USBPD_CORE_DATATYPE_SNK_PDO :
USBPD_PWR_IF_GetPortPDOs(PortNum, DataId, Ptr, Size);
*Size *= 4;
break;
default:
*Size = 0;
}
/* USER CODE END USBPD_DPM_GetDataInfo */
}
/**
* @brief DPM callback to allow PE to update information in DPM/PWR_IF.
* @param PortNum Port number
* @param DataId Type of data to be updated in DPM based on @ref USBPD_CORE_DataInfoType_TypeDef
* @param Ptr Pointer on the data
* @param Size Nb of bytes to be updated in DPM
* @retval None
*/
void USBPD_DPM_SetDataInfo(uint8_t PortNum, USBPD_CORE_DataInfoType_TypeDef DataId, uint8_t *Ptr, uint32_t Size)
{
/* USER CODE BEGIN USBPD_DPM_SetDataInfo */
/* Check type of information targeted by request */
switch(DataId)
{
/* Case Received Request PDO Data information :
*/
case USBPD_CORE_DATATYPE_RCV_REQ_PDO :
if (Size == 4)
{
memcpy((uint8_t *)&DPM_Ports[PortNum].DPM_RcvRequestDOMsg, Ptr, 4);
}
break;
/* In case of unexpected data type (Set request could not be fulfilled) :
*/
default:
break;
}
/* USER CODE END USBPD_DPM_SetDataInfo */
/* Forward info to GUI if enabled */
if (NULL != DPM_GUI_SaveInfo)
{
DPM_GUI_SaveInfo(PortNum, DataId, Ptr, Size);
}
}
/**
* @brief Evaluate received Request Message from Sink port
* @param PortNum Port number
* @param PtrPowerObject Pointer on the power data object
* @retval USBPD status : USBPD_ACCEPT, USBPD_REJECT, USBPD_WAIT, USBPD_GOTOMIN
*/
USBPD_StatusTypeDef USBPD_DPM_EvaluateRequest(uint8_t PortNum, USBPD_CORE_PDO_Type_TypeDef *PtrPowerObject)
{
/* USER CODE BEGIN USBPD_DPM_EvaluateRequest */
USBPD_StatusTypeDef _retr = USBPD_REJECT;
USBPD_PDO_TypeDef pdo;
USBPD_SNKRDO_TypeDef rdo;
/* read the request value received */
rdo.d32 = DPM_Ports[PortNum].DPM_RcvRequestDOMsg;
/* Search PDO in Port Source PDO list, that corresponds to Position provided in Request RDO */
if (USBPD_PWR_IF_SearchRequestedPDO(PortNum, rdo.GenericRDO.ObjectPosition, &pdo.d32) == USBPD_OK)
{
/* Evaluate the request */
if(pdo.GenericPDO.PowerObject == USBPD_CORE_PDO_TYPE_FIXED)
{
if((rdo.FixedVariableRDO.OperatingCurrentIn10mAunits > pdo.SRCFixedPDO.MaxCurrentIn10mAunits)
|| (rdo.FixedVariableRDO.MaxOperatingCurrent10mAunits > pdo.SRCFixedPDO.MaxCurrentIn10mAunits))
{
/* Sink requests too much maximum operating current */
/* USBPD_DPM_EvaluateRequest: Sink requests too much maximum operating current */
_retr = USBPD_REJECT;
}
else
{
/* Save the power object */
*PtrPowerObject = pdo.GenericPDO.PowerObject;
/* Set RDO position and requested voltage in DPM port structure */
DPM_Ports[PortNum].DPM_RequestedVoltage = pdo.SRCFixedPDO.VoltageIn50mVunits * 50;
DPM_Ports[PortNum].DPM_RDOPositionPrevious = DPM_Ports[PortNum].DPM_RDOPosition;
DPM_Ports[PortNum].DPM_RDOPosition = rdo.GenericRDO.ObjectPosition;
_retr = USBPD_ACCEPT;
}
}
}
return _retr;
/* USER CODE END USBPD_DPM_EvaluateRequest */
}
/**
* @brief Callback to be used by PE to evaluate a Vconn swap
* @param PortNum Port number
* @retval USBPD_ACCEPT, USBPD_REJECT, USBPD_WAIT
*/
USBPD_StatusTypeDef USBPD_DPM_EvaluateVconnSwap(uint8_t PortNum)
{
/* USER CODE BEGIN USBPD_DPM_EvaluateVconnSwap */
USBPD_StatusTypeDef status = USBPD_REJECT;
if (USBPD_TRUE == DPM_USER_Settings[PortNum].PE_VconnSwap)
{
status = USBPD_ACCEPT;
}
return status;
/* USER CODE END USBPD_DPM_EvaluateVconnSwap */
}
/**
* @brief Callback to be used by PE to manage VConn
* @param PortNum Port number
* @param State Enable or Disable VConn on CC lines
* @retval USBPD_ACCEPT, USBPD_REJECT
*/
USBPD_StatusTypeDef USBPD_DPM_PE_VconnPwr(uint8_t PortNum, USBPD_FunctionalState State)
{
/* USER CODE BEGIN USBPD_DPM_PE_VconnPwr */
return USBPD_ERROR;
/* USER CODE END USBPD_DPM_PE_VconnPwr */
}
/**
* @brief DPM callback to allow PE to forward extended message information.
* @param PortNum Port number
* @param MsgType Type of message to be handled in DPM
* This parameter can be one of the following values:
* @arg @ref USBPD_EXT_SECURITY_REQUEST Security Request extended message
* @arg @ref USBPD_EXT_SECURITY_RESPONSE Security Response extended message
* @param ptrData Pointer on address Extended Message data could be read (u8 pointer)
* @param DataSize Nb of u8 that compose Extended message
* @retval None
*/
void USBPD_DPM_ExtendedMessageReceived(uint8_t PortNum, USBPD_ExtendedMsg_TypeDef MsgType, uint8_t *ptrData, uint16_t DataSize)
{
/* USER CODE BEGIN USBPD_DPM_ExtendedMessageReceived */
/* USER CODE END USBPD_DPM_ExtendedMessageReceived */
}
/**
* @brief Callback used to ask application the reply status for a DataRoleSwap request
* @note if the callback is not set (ie NULL) the stack will automatically reject the request
* @param PortNum Port number
* @retval Returned values are:
@ref USBPD_ACCEPT if DRS can be accepted
@ref USBPD_REJECT if DRS is not accepted in one data role (DFP or UFP) or in PD2.0 config
@ref USBPD_NOTSUPPORTED if DRS is not supported at all by the application (in both data roles) - P3.0 only
*/
USBPD_StatusTypeDef USBPD_DPM_EvaluateDataRoleSwap(uint8_t PortNum)
{
/* USER CODE BEGIN USBPD_DPM_EvaluateDataRoleSwap */
USBPD_StatusTypeDef status = USBPD_REJECT;
/* Sent NOT_SUPPORTED if DRS is not supported at all by the application (in both data roles) - P3.0 only */
if ((USBPD_FALSE == DPM_USER_Settings[PortNum].PE_DataSwap)
|| ((USBPD_FALSE == DPM_USER_Settings[PortNum].PE_DR_Swap_To_DFP)
&& (USBPD_FALSE == DPM_USER_Settings[PortNum].PE_DR_Swap_To_UFP)))
{
status = USBPD_NOTSUPPORTED;
}
else
{
/* ACCEPT DRS if at least supported by 1 data role */
if (((USBPD_TRUE == DPM_USER_Settings[PortNum].PE_DR_Swap_To_DFP) && (USBPD_PORTDATAROLE_UFP == DPM_Params[PortNum].PE_DataRole))
|| ((USBPD_TRUE == DPM_USER_Settings[PortNum].PE_DR_Swap_To_UFP) && (USBPD_PORTDATAROLE_DFP == DPM_Params[PortNum].PE_DataRole)))
{
status = USBPD_ACCEPT;
}
}
return status;
/* USER CODE END USBPD_DPM_EvaluateDataRoleSwap */
}
/**
* @brief Callback to be used by PE to check is VBUS is ready or present
* @param PortNum Port number
* @param Vsafe Vsafe status based on @ref USBPD_VSAFE_StatusTypeDef
* @retval USBPD_DISABLE or USBPD_ENABLE
*/
USBPD_FunctionalState USBPD_DPM_IsPowerReady(uint8_t PortNum, USBPD_VSAFE_StatusTypeDef Vsafe)
{
/* USER CODE BEGIN USBPD_DPM_IsPowerReady */
return ((USBPD_OK == USBPD_PWR_IF_SupplyReady(PortNum, Vsafe)) ? USBPD_ENABLE : USBPD_DISABLE);
/* USER CODE END USBPD_DPM_IsPowerReady */
}
/**
* @}
*/
/** @defgroup USBPD_USER_EXPORTED_FUNCTIONS_GROUP3 USBPD USER Functions PD messages requests
* @{
*/
/**
* @brief Request the PE to send a hard reset
* @param PortNum The current port number
* @retval USBPD Status
*/
USBPD_StatusTypeDef USBPD_DPM_RequestHardReset(uint8_t PortNum)
{
USBPD_StatusTypeDef _status = USBPD_PE_Request_HardReset(PortNum);
DPM_USER_ERROR_TRACE(PortNum, _status, "HARD RESET not accepted by the stack");
return _status;
}
/**
* @brief Request the PE to send a cable reset.
* @note Only a DFP Shall generate Cable Reset Signaling. A DFP Shall only generate Cable Reset Signaling within an Explicit Contract.
The DFP has to be supplying VCONN prior to a Cable Reset
* @param PortNum The current port number
* @retval USBPD Status
*/
USBPD_StatusTypeDef USBPD_DPM_RequestCableReset(uint8_t PortNum)
{
USBPD_StatusTypeDef _status = USBPD_PE_Request_CableReset(PortNum);
DPM_USER_ERROR_TRACE(PortNum, _status, "CABLE RESET not accepted by the stack");
return _status;
}
/**
* @brief Request the PE to send a GOTOMIN message
* @param PortNum The current port number
* @retval USBPD Status
*/
USBPD_StatusTypeDef USBPD_DPM_RequestGotoMin(uint8_t PortNum)
{
USBPD_StatusTypeDef _status = USBPD_PE_Request_CtrlMessage(PortNum, USBPD_CONTROLMSG_GOTOMIN, USBPD_SOPTYPE_SOP);
DPM_USER_ERROR_TRACE(PortNum, _status, "GOTOMIN not accepted by the stack");
return _status;
}
/**
* @brief Request the PE to send a PING message
* @note In USB-PD stack, only ping management for P3.0 is implemented.
* If PD2.0 is used, PING timer needs to be implemented on user side.
* @param PortNum The current port number
* @retval USBPD Status
*/
USBPD_StatusTypeDef USBPD_DPM_RequestPing(uint8_t PortNum)
{
USBPD_StatusTypeDef _status = USBPD_PE_Request_CtrlMessage(PortNum, USBPD_CONTROLMSG_PING, USBPD_SOPTYPE_SOP);
DPM_USER_ERROR_TRACE(PortNum, _status, "PING not accepted by the stack");
return _status;
}
/**
* @brief Request the PE to send a request message.
* @param PortNum The current port number
* @param IndexSrcPDO Index on the selected SRC PDO (value between 1 to 7)
* @param RequestedVoltage Requested voltage (in MV and use mainly for APDO)
* @retval USBPD Status
*/
USBPD_StatusTypeDef USBPD_DPM_RequestMessageRequest(uint8_t PortNum, uint8_t IndexSrcPDO, uint16_t RequestedVoltage)
{
USBPD_StatusTypeDef _status = USBPD_ERROR;
/* USER CODE BEGIN USBPD_DPM_RequestMessageRequest */
/* To be adapted to call the PE function */
/* _status = USBPD_PE_Send_Request(PortNum, rdo.d32, pdo_object);*/
DPM_USER_DEBUG_TRACE(PortNum, "ADVICE: update USBPD_DPM_RequestMessageRequest");
/* USER CODE END USBPD_DPM_RequestMessageRequest */
DPM_USER_ERROR_TRACE(PortNum, _status, "REQUEST not accepted by the stack");
return _status;
}
/**
* @brief Request the PE to send a GET_SRC_CAPA message
* @param PortNum The current port number
* @retval USBPD Status
*/
USBPD_StatusTypeDef USBPD_DPM_RequestGetSourceCapability(uint8_t PortNum)
{
USBPD_StatusTypeDef _status = USBPD_PE_Request_CtrlMessage(PortNum, USBPD_CONTROLMSG_GET_SRC_CAP, USBPD_SOPTYPE_SOP);
DPM_USER_ERROR_TRACE(PortNum, _status, "GET_SRC_CAPA not accepted by the stack");
return _status;
}
/**
* @brief Request the PE to send a GET_SNK_CAPA message
* @param PortNum The current port number
* @retval USBPD Status
*/
USBPD_StatusTypeDef USBPD_DPM_RequestGetSinkCapability(uint8_t PortNum)
{
USBPD_StatusTypeDef _status = USBPD_PE_Request_CtrlMessage(PortNum, USBPD_CONTROLMSG_GET_SNK_CAP, USBPD_SOPTYPE_SOP);
DPM_USER_ERROR_TRACE(PortNum, _status, "GET_SINK_CAPA not accepted by the stack");
return _status;
}
/**
* @brief Request the PE to perform a Data Role Swap.
* @param PortNum The current port number
* @retval USBPD Status
*/
USBPD_StatusTypeDef USBPD_DPM_RequestDataRoleSwap(uint8_t PortNum)
{
USBPD_StatusTypeDef _status = USBPD_PE_Request_CtrlMessage(PortNum, USBPD_CONTROLMSG_DR_SWAP, USBPD_SOPTYPE_SOP);
DPM_USER_ERROR_TRACE(PortNum, _status, "DRS not accepted by the stack");
return _status;
}
/**
* @brief Request the PE to perform a Power Role Swap.
* @param PortNum The current port number
* @retval USBPD Status
*/
USBPD_StatusTypeDef USBPD_DPM_RequestPowerRoleSwap(uint8_t PortNum)
{
DPM_USER_ERROR_TRACE(PortNum, USBPD_ERROR, "PRS not accepted by the stack");
return USBPD_ERROR;
}
/**
* @brief Request the PE to perform a VCONN Swap.
* @param PortNum The current port number
* @retval USBPD Status
*/
USBPD_StatusTypeDef USBPD_DPM_RequestVconnSwap(uint8_t PortNum)
{
USBPD_StatusTypeDef _status = USBPD_PE_Request_CtrlMessage(PortNum, USBPD_CONTROLMSG_VCONN_SWAP, USBPD_SOPTYPE_SOP);
DPM_USER_ERROR_TRACE(PortNum, _status, "VCS not accepted by the stack");
return _status;
}
/**
* @brief Request the PE to send a soft reset
* @param PortNum The current port number
* @param SOPType SOP Type based on @ref USBPD_SOPType_TypeDef
* @retval USBPD Status
*/
USBPD_StatusTypeDef USBPD_DPM_RequestSoftReset(uint8_t PortNum, USBPD_SOPType_TypeDef SOPType)
{
USBPD_StatusTypeDef _status = USBPD_PE_Request_CtrlMessage(PortNum, USBPD_CONTROLMSG_SOFT_RESET, SOPType);
DPM_USER_ERROR_TRACE(PortNum, _status, "SOFT_RESET not accepted by the stack");
return _status;
}
/**
* @brief Request the PE to send a Source Capability message.
* @param PortNum The current port number
* @retval USBPD Status
*/
USBPD_StatusTypeDef USBPD_DPM_RequestSourceCapability(uint8_t PortNum)
{
/* PE will directly get the PDO saved in structure @ref PWR_Port_PDO_Storage */
USBPD_StatusTypeDef _status = USBPD_PE_Request_DataMessage(PortNum, USBPD_DATAMSG_SRC_CAPABILITIES, NULL);
DPM_USER_ERROR_TRACE(PortNum, _status, "SRC_CAPA not accepted by the stack");
return _status;
}
/**
* @brief Request the PE to send a VDM discovery identity
* @param PortNum The current port number
* @param SOPType SOP Type
* @retval USBPD Status
*/
USBPD_StatusTypeDef USBPD_DPM_RequestVDM_DiscoveryIdentify(uint8_t PortNum, USBPD_SOPType_TypeDef SOPType)
{
USBPD_StatusTypeDef _status = USBPD_ERROR;
/* USER CODE BEGIN USBPD_DPM_RequestVDM_DiscoveryIdentify */
if (USBPD_SOPTYPE_SOP == SOPType)
{
_status = USBPD_PE_SVDM_RequestIdentity(PortNum, SOPType);
}
/* USER CODE END USBPD_DPM_RequestVDM_DiscoveryIdentify */
DPM_USER_ERROR_TRACE(PortNum, _status, "VDM Discovery Ident not accepted by the stack");
return _status;
}
/**
* @brief Request the PE to send a VDM discovery SVID
* @param PortNum The current port number
* @param SOPType SOP Type
* @retval USBPD Status
*/
USBPD_StatusTypeDef USBPD_DPM_RequestVDM_DiscoverySVID(uint8_t PortNum, USBPD_SOPType_TypeDef SOPType)
{
USBPD_StatusTypeDef _status = USBPD_PE_SVDM_RequestSVID(PortNum, SOPType);
DPM_USER_ERROR_TRACE(PortNum, _status, "VDM discovery SVID not accepted by the stack");
return _status;
}
/**
* @brief Request the PE to perform a VDM Discovery mode message on one SVID.
* @param PortNum The current port number
* @param SOPType SOP Type
* @param SVID SVID used for discovery mode message
* @retval USBPD Status
*/
USBPD_StatusTypeDef USBPD_DPM_RequestVDM_DiscoveryMode(uint8_t PortNum, USBPD_SOPType_TypeDef SOPType, uint16_t SVID)
{
USBPD_StatusTypeDef _status = USBPD_PE_SVDM_RequestMode(PortNum, SOPType, SVID);
DPM_USER_ERROR_TRACE(PortNum, _status, "VDM Discovery mode not accepted by the stack");
return _status;
}
/**
* @brief Request the PE to perform a VDM mode enter.
* @param PortNum The current port number
* @param SOPType SOP Type
* @param SVID SVID used for discovery mode message
* @param ModeIndex Index of the mode to be entered
* @retval USBPD Status
*/
USBPD_StatusTypeDef USBPD_DPM_RequestVDM_EnterMode(uint8_t PortNum, USBPD_SOPType_TypeDef SOPType, uint16_t SVID, uint8_t ModeIndex)
{
USBPD_StatusTypeDef _status = USBPD_PE_SVDM_RequestModeEnter(PortNum, SOPType, SVID, ModeIndex);
DPM_USER_ERROR_TRACE(PortNum, _status, "VDM mode enter not accepted by the stack");
return _status;
}
/**
* @brief Request the PE to perform a VDM mode exit.
* @param PortNum The current port number
* @param SOPType SOP Type
* @param SVID SVID used for discovery mode message
* @param ModeIndex Index of the mode to be exit
* @retval USBPD Status
*/
USBPD_StatusTypeDef USBPD_DPM_RequestVDM_ExitMode(uint8_t PortNum, USBPD_SOPType_TypeDef SOPType, uint16_t SVID, uint8_t ModeIndex)
{
USBPD_StatusTypeDef _status = USBPD_PE_SVDM_RequestModeExit(PortNum, SOPType, SVID, ModeIndex);
DPM_USER_ERROR_TRACE(PortNum, _status, "VDM mode exit not accepted by the stack");
return _status;
}
/**
* @brief Request the PE to send a Display Port status
* @param PortNum The current port number
* @param SOPType SOP Type
* @param SVID Used SVID
* @param pDPStatus Pointer on DP Status data (32 bit)
* @retval USBPD Status
*/
USBPD_StatusTypeDef USBPD_DPM_RequestDisplayPortStatus(uint8_t PortNum, USBPD_SOPType_TypeDef SOPType, uint16_t SVID, uint32_t *pDPStatus)
{
USBPD_StatusTypeDef _status;
/* USER CODE BEGIN USBPD_DPM_RequestDisplayPortStatus */
/*USBPD_VDM_FillDPStatus(PortNum, (USBPD_DPStatus_TypeDef*)pDPStatus);*/
/* USER CODE END USBPD_DPM_RequestDisplayPortStatus */
_status = USBPD_PE_SVDM_RequestSpecific(PortNum, SOPType, SVDM_SPECIFIC_1, SVID);
DPM_USER_ERROR_TRACE(PortNum, _status, "Display Port status not accepted by the stack");
return _status;
}
/**
* @brief Request the PE to send a Display Port Config
* @param PortNum The current port number
* @param SOPType SOP Type
* @param SVID Used SVID
* @param pDPConfig Pointer on DP Config data (32 bit)
* @retval USBPD Status
*/
USBPD_StatusTypeDef USBPD_DPM_RequestDisplayPortConfig(uint8_t PortNum, USBPD_SOPType_TypeDef SOPType, uint16_t SVID, uint32_t *pDPConfig)
{
USBPD_StatusTypeDef _status;
/* USER CODE BEGIN USBPD_DPM_RequestDisplayPortConfig */
/*USBPD_VDM_FillDPConfig(PortNum, (USBPD_DPConfig_TypeDef*)pDPConfig);*/
/* USER CODE END USBPD_DPM_RequestDisplayPortConfig */
_status = USBPD_PE_SVDM_RequestSpecific(PortNum, SOPType, SVDM_SPECIFIC_2, SVID);
DPM_USER_ERROR_TRACE(PortNum, _status, "Display Port Config not accepted by the stack");
return _status;
}
/**
* @brief Request the PE to perform a VDM Attention.
* @param PortNum The current port number
* @param SOPType SOP Type
* @param SVID Used SVID
* @retval USBPD Status
*/
USBPD_StatusTypeDef USBPD_DPM_RequestAttention(uint8_t PortNum, USBPD_SOPType_TypeDef SOPType, uint16_t SVID)
{
USBPD_StatusTypeDef _status = USBPD_PE_SVDM_RequestAttention(PortNum, SOPType, SVID);
DPM_USER_ERROR_TRACE(PortNum, _status, "VDM ATTENTION not accepted by the stack");
return _status;
}
/**
* @brief Request the PE to send an ALERT to port partner
* @param PortNum The current port number
* @param Alert Alert based on @ref USBPD_ADO_TypeDef
* @retval USBPD Status
*/
USBPD_StatusTypeDef USBPD_DPM_RequestAlert(uint8_t PortNum, USBPD_ADO_TypeDef Alert)
{
USBPD_StatusTypeDef _status = USBPD_PE_Request_DataMessage(PortNum, USBPD_DATAMSG_ALERT, (uint32_t*)&Alert.d32);
DPM_USER_ERROR_TRACE(PortNum, _status, "ALERT not accepted by the stack");
return _status;
}
/**
* @brief Request the PE to get a source capability extended
* @param PortNum The current port number
* @retval USBPD Status
*/
USBPD_StatusTypeDef USBPD_DPM_RequestGetSourceCapabilityExt(uint8_t PortNum)
{
USBPD_StatusTypeDef _status = USBPD_PE_Request_CtrlMessage(PortNum, USBPD_CONTROLMSG_GET_SRC_CAPEXT, USBPD_SOPTYPE_SOP);
DPM_USER_ERROR_TRACE(PortNum, _status, "GET_SRC_CAPA_EXT not accepted by the stack");
return _status;
}
/**
* @brief Request the PE to get a sink capability extended
* @param PortNum The current port number
* @retval USBPD Status
*/
USBPD_StatusTypeDef USBPD_DPM_RequestGetSinkCapabilityExt(uint8_t PortNum)
{
DPM_USER_ERROR_TRACE(PortNum, USBPD_ERROR, "GET_SINK_CAPA_EXT not accepted by the stack");
return USBPD_ERROR;
}
/**
* @brief Request the PE to get a manufacturer info
* @param PortNum The current port number
* @param SOPType SOP Type
* @param pManuInfoData Pointer on manufacturer info based on @ref USBPD_GMIDB_TypeDef
* @retval USBPD Status
*/
USBPD_StatusTypeDef USBPD_DPM_RequestGetManufacturerInfo(uint8_t PortNum, USBPD_SOPType_TypeDef SOPType, uint8_t* pManuInfoData)
{
USBPD_StatusTypeDef _status = USBPD_ERROR;
if (USBPD_SOPTYPE_SOP == SOPType)
{
_status = USBPD_PE_SendExtendedMessage(PortNum, SOPType, USBPD_EXT_GET_MANUFACTURER_INFO, (uint8_t*)pManuInfoData, sizeof(USBPD_GMIDB_TypeDef));
}
DPM_USER_ERROR_TRACE(PortNum, _status, "GET_MANU_INFO not accepted by the stack");
return _status;
}
/**
* @brief Request the PE to request a GET_PPS_STATUS
* @param PortNum The current port number
* @retval USBPD Status
*/
USBPD_StatusTypeDef USBPD_DPM_RequestGetPPS_Status(uint8_t PortNum)
{
USBPD_StatusTypeDef _status = USBPD_PE_Request_CtrlMessage(PortNum, USBPD_CONTROLMSG_GET_PPS_STATUS, USBPD_SOPTYPE_SOP);
DPM_USER_ERROR_TRACE(PortNum, _status, "GET_PPS_STATUS not accepted by the stack");
return _status;
}
/**
* @brief Request the PE to request a GET_STATUS
* @param PortNum The current port number
* @retval USBPD Status
*/
USBPD_StatusTypeDef USBPD_DPM_RequestGetStatus(uint8_t PortNum)
{
USBPD_StatusTypeDef _status = USBPD_PE_Request_CtrlMessage(PortNum, USBPD_CONTROLMSG_GET_STATUS, USBPD_SOPTYPE_SOP);
DPM_USER_ERROR_TRACE(PortNum, _status, "GET_STATUS not accepted by the stack");
return _status;
}
/**
* @brief Request the PE to perform a Fast Role Swap.
* @param PortNum The current port number
* @retval USBPD Status
*/
USBPD_StatusTypeDef USBPD_DPM_RequestFastRoleSwap(uint8_t PortNum)
{
USBPD_StatusTypeDef _status = USBPD_PE_Request_CtrlMessage(PortNum, USBPD_CONTROLMSG_FR_SWAP, USBPD_SOPTYPE_SOP);
DPM_USER_ERROR_TRACE(PortNum, _status, "FRS not accepted by the stack");
return _status;
}
/**
* @brief Request the PE to send a GET_COUNTRY_CODES message
* @param PortNum The current port number
* @retval USBPD Status
*/
USBPD_StatusTypeDef USBPD_DPM_RequestGetCountryCodes(uint8_t PortNum)
{
USBPD_StatusTypeDef _status = USBPD_PE_Request_CtrlMessage(PortNum, USBPD_CONTROLMSG_GET_COUNTRY_CODES, USBPD_SOPTYPE_SOP);
DPM_USER_ERROR_TRACE(PortNum, _status, "GET_COUNTRY_CODES not accepted by the stack");
return _status;
}
/**
* @brief Request the PE to send a GET_COUNTRY_INFO message
* @param PortNum The current port number
* @param CountryCode Country code (1st character and 2nd of the Alpha-2 Country)
* @retval USBPD Status
*/
USBPD_StatusTypeDef USBPD_DPM_RequestGetCountryInfo(uint8_t PortNum, uint16_t CountryCode)
{
USBPD_StatusTypeDef _status = USBPD_PE_Request_DataMessage(PortNum, USBPD_DATAMSG_GET_COUNTRY_INFO, (uint32_t*)&CountryCode);
DPM_USER_ERROR_TRACE(PortNum, _status, "GET_COUNTRY_INFO not accepted by the stack");
return _status;
}
/**
* @brief Request the PE to send a GET_BATTERY_CAPA
* @param PortNum The current port number
* @param pBatteryCapRef Pointer on the Battery Capability reference
* @retval USBPD Status
*/
USBPD_StatusTypeDef USBPD_DPM_RequestGetBatteryCapability(uint8_t PortNum, uint8_t *pBatteryCapRef)
{
USBPD_StatusTypeDef _status = USBPD_PE_SendExtendedMessage(PortNum, USBPD_SOPTYPE_SOP, USBPD_EXT_GET_BATTERY_CAP, (uint8_t*)pBatteryCapRef, 1);
DPM_USER_ERROR_TRACE(PortNum, _status, "GET_BATTERY_CAPA not accepted by the stack");
return _status;
}
/**
* @brief Request the PE to send a GET_BATTERY_STATUS
* @param PortNum The current port number
* @param pBatteryStatusRef Pointer on the Battery Status reference
* @retval USBPD Status
*/
USBPD_StatusTypeDef USBPD_DPM_RequestGetBatteryStatus(uint8_t PortNum, uint8_t *pBatteryStatusRef)
{
USBPD_StatusTypeDef _status = USBPD_PE_SendExtendedMessage(PortNum, USBPD_SOPTYPE_SOP, USBPD_EXT_GET_BATTERY_STATUS, (uint8_t*)pBatteryStatusRef, 1);
DPM_USER_ERROR_TRACE(PortNum, _status, "GET_BATTERY_STATUS not accepted by the stack");
return _status;
}
/**
* @brief Request the PE to send a SECURITY_REQUEST
* @param PortNum The current port number
* @retval USBPD Status
*/
USBPD_StatusTypeDef USBPD_DPM_RequestSecurityRequest(uint8_t PortNum)
{
USBPD_StatusTypeDef _status = USBPD_ERROR;
DPM_USER_ERROR_TRACE(PortNum, _status, "SECURITY_REQUEST not accepted by the stack");
return _status;
}
/**
* @}
*/
/** @addtogroup USBPD_USER_PRIVATE_FUNCTIONS
* @{
*/
/* USER CODE BEGIN USBPD_USER_PRIVATE_FUNCTIONS */
/* USER CODE END USBPD_USER_PRIVATE_FUNCTIONS */
/**
* @}
*/
/**
* @}
*/
/**
* @}
*/
/**
* @}
*/
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
Reference in a new issue Copy permalink