488 lines
23 KiB
C++
488 lines
23 KiB
C++
/////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// file: autoGen_PowerDeliveryClass_CPP.h //
|
|
// //
|
|
/////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// Copyright (c) 2026 Acroname Inc. - All Rights Reserved //
|
|
// //
|
|
// This file is part of the BrainStem release. See the license.txt //
|
|
// file included with this package or go to //
|
|
// https://acroname.com/software/brainstem-development-kit //
|
|
// for full license details. //
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
#ifndef __AUTOGEN_POWERDELIVERY_CPP_H__
|
|
#define __AUTOGEN_POWERDELIVERY_CPP_H__
|
|
|
|
#include "BrainStem-core.h"
|
|
|
|
#ifdef __GNUC__
|
|
#define DEPRECATED(...) __attribute__((deprecated(__VA_ARGS__)))
|
|
#elif defined(_MSC_VER)
|
|
#define DEPRECATED(...) __declspec(deprecated(__VA_ARGS__))
|
|
#else
|
|
#define DEPRECATED(...)
|
|
#pragma message("DEPRECATED is not defined for this compiler")
|
|
#endif
|
|
|
|
#if defined(__cplusplus)
|
|
|
|
namespace Acroname {
|
|
namespace BrainStem {
|
|
|
|
/// PowerDeliveryClass:
|
|
/// Power Delivery or PD is a power specification which allows more charging options and
|
|
/// device behaviors within the USB interface.
|
|
/// This Entity will allow you to directly access the vast landscape of PD.
|
|
///
|
|
class aLIBEXPORT PowerDeliveryClass : public EntityClass {
|
|
|
|
public:
|
|
|
|
/// Constructor.
|
|
PowerDeliveryClass(void);
|
|
|
|
/// Destructor.
|
|
virtual ~PowerDeliveryClass(void);
|
|
|
|
/// Initialize the PowerDelivery Class.
|
|
///
|
|
/// \param pModule The module to which this entity belongs.
|
|
/// \param index The index of the PowerDelivery entity to be addressed.
|
|
///
|
|
void init(Module* pModule, const uint8_t index);
|
|
|
|
/// Gets the current state of the connection in the form of an enumeration.
|
|
///
|
|
/// \param state Pointer to be filled with the current connection state.
|
|
///
|
|
/// \return Returns \ref EntityReturnValues "common entity" return values
|
|
aErr getConnectionState(uint8_t* state);
|
|
|
|
/// Gets the number of Power Data Objects (PDOs) for a given partner and power role.
|
|
///
|
|
/// \param partner Indicates which side of the PD connection is in question.
|
|
/// - Local = 0 = powerdeliveryPartnerLocal
|
|
/// - Remote = 1 = powerdeliveryPartnerRemote
|
|
/// \param powerRole Indicates which power role of PD connection is in question.
|
|
/// - Source = 1 = powerdeliveryPowerRoleSource
|
|
/// - Sink = 2 = powerdeliveryPowerRoleSink
|
|
/// \param numRules Variable to be filled with the number of PDOs.
|
|
///
|
|
/// \return Returns \ref EntityReturnValues "common entity" return values
|
|
aErr getNumberOfPowerDataObjects(const uint8_t partner, const uint8_t powerRole, uint8_t* numRules);
|
|
|
|
/// Gets the Power Data Object (PDO) for the requested partner, powerRole and index.
|
|
///
|
|
/// \param partner Indicates which side of the PD connection is in question.
|
|
/// - Local = 0 = powerdeliveryPartnerLocal
|
|
/// - Remote = 1 = powerdeliveryPartnerRemote
|
|
/// \param powerRole Indicates which power role of PD connection is in question.
|
|
/// - Source = 1 = powerdeliveryPowerRoleSource
|
|
/// - Sink = 2 = powerdeliveryPowerRoleSink
|
|
/// \param ruleIndex The index of the PDO in question. Valid index are 1-7.
|
|
/// \param pdo Variable to be filled with the requested power rule.
|
|
///
|
|
/// \return Returns \ref EntityReturnValues "common entity" return values
|
|
aErr getPowerDataObject(const uint8_t partner, const uint8_t powerRole, const uint8_t ruleIndex, uint32_t* pdo);
|
|
|
|
/// Sets the Power Data Object (PDO) of the local partner for a given power role and index.
|
|
///
|
|
/// \param powerRole Indicates which power role of PD connection is in question.
|
|
/// - Source = 1 = powerdeliveryPowerRoleSource
|
|
/// - Sink = 2 = powerdeliveryPowerRoleSink
|
|
/// \param ruleIndex The index of the PDO in question. Valid index are 1-7.
|
|
/// \param pdo Power Data Object to be set.
|
|
///
|
|
/// \return Returns \ref EntityReturnValues "common entity" return values
|
|
aErr setPowerDataObject(const uint8_t powerRole, const uint8_t ruleIndex, const uint32_t pdo);
|
|
|
|
/// Resets the Power Data Object (PDO) of the Local partner for a given power role and index.
|
|
///
|
|
/// \param powerRole Indicates which power role of PD connection is in question.
|
|
/// - Source = 1 = powerdeliveryPowerRoleSource
|
|
/// - Sink = 2 = powerdeliveryPowerRoleSink
|
|
/// \param ruleIndex The index of the PDO in question. Valid index are 1-7.
|
|
///
|
|
/// \return Returns \ref EntityReturnValues "common entity" return values
|
|
aErr resetPowerDataObjectToDefault(const uint8_t powerRole, const uint8_t ruleIndex);
|
|
|
|
/// Gets all Power Data Objects (PDOs).
|
|
/// Equivalent to calling PowerDeliveryClass::getPowerDataObject() on all partners, power
|
|
/// roles, and index's.
|
|
///
|
|
/// \param buffer pointer to the start of a c style buffer to be filled
|
|
/// The order of which is:
|
|
/// - Rules 1-7 Local Source
|
|
/// - Rules 1-7 Local Sink
|
|
/// - Rules 1-7 Partner Source
|
|
/// - Rules 1-7 Partner Sink.
|
|
/// \param bufferLength Length of the buffer to be filed
|
|
/// \param unloadedLength Length that was actually received and filled.
|
|
/// On success this value should be 28 (7 rules * 2 partners * 2 power roles)
|
|
///
|
|
/// \return Returns \ref EntityReturnValues "common entity" return values
|
|
aErr getPowerDataObjectList(uint32_t* buffer, const size_t bufferLength, size_t* unloadedLength);
|
|
|
|
/// Gets the enabled state of the Local Power Data Object (PDO) for a given power role and
|
|
/// index.
|
|
/// Enabled refers to whether the PDO will be advertised when a PD connection is made.
|
|
/// This does not indicate the currently active rule index. This information can be found in
|
|
/// Request Data Object (RDO).
|
|
///
|
|
/// \param powerRole Indicates which power role of PD connection is in question.
|
|
/// - Source = 1 = powerdeliveryPowerRoleSource
|
|
/// - Sink = 2 = powerdeliveryPowerRoleSink
|
|
/// \param ruleIndex The index of the PDO in question. Valid index are 1-7.
|
|
/// \param enabled Variable to be filled with enabled state.
|
|
///
|
|
/// \return Returns \ref EntityReturnValues "common entity" return values
|
|
aErr getPowerDataObjectEnabled(const uint8_t powerRole, const uint8_t ruleIndex, uint8_t* enabled);
|
|
|
|
/// Sets the enabled state of the Local Power Data Object (PDO) for a given powerRole and
|
|
/// index.
|
|
/// Enabled refers to whether the PDO will be advertised when a PD connection is made.
|
|
/// This does not indicate the currently active rule index. This information can be found in
|
|
/// Request Data Object (RDO).
|
|
///
|
|
/// \param powerRole Indicates which power role of PD connection is in question.
|
|
/// - Source = 1 = powerdeliveryPowerRoleSource
|
|
/// - Sink = 2 = powerdeliveryPowerRoleSink
|
|
/// \param ruleIndex The index of the PDO in question. Valid index are 1-7.
|
|
/// \param enabled The state to be set.
|
|
///
|
|
/// \return Returns \ref EntityReturnValues "common entity" return values
|
|
aErr setPowerDataObjectEnabled(const uint8_t powerRole, const uint8_t ruleIndex, const uint8_t enabled);
|
|
|
|
/// Gets all Power Data Object enables for a given power role.
|
|
/// Equivalent of calling PowerDeliveryClass::getPowerDataObjectEnabled() for all indexes.
|
|
///
|
|
/// \param powerRole Indicates which power role of PD connection is in question.
|
|
/// - Source = 1 = powerdeliveryPowerRoleSource
|
|
/// - Sink = 2 = powerdeliveryPowerRoleSink
|
|
/// \param enabledList Variable to be filled with a mapped representation of the enabled PDOs
|
|
/// for a given power role.
|
|
/// Values align with a given rule index (bits 1-7, bit 0 is invalid)
|
|
///
|
|
/// \return Returns \ref EntityReturnValues "common entity" return values
|
|
aErr getPowerDataObjectEnabledList(const uint8_t powerRole, uint8_t* enabledList);
|
|
|
|
/// Gets the current Request Data Object (RDO) for a given partner.
|
|
/// RDOs are provided by the sinking device and exist only after a successful PD negotiation
|
|
/// (Otherwise zero).
|
|
/// Only one RDO can exist at a time. i.e. Either the Local or Remote partner RDO
|
|
///
|
|
/// \param partner Indicates which side of the PD connection is in question.
|
|
/// - Local = 0 = powerdeliveryPartnerLocal
|
|
/// - Remote = 1 = powerdeliveryPartnerRemote
|
|
/// \param rdo Variable to be filled with the current RDO.
|
|
/// Zero indicates the RDO is not active.
|
|
///
|
|
/// \return Returns \ref EntityReturnValues "common entity" return values
|
|
aErr getRequestDataObject(const uint8_t partner, uint32_t* rdo);
|
|
|
|
/// Sets the current Request Data Object (RDO) for a given partner.
|
|
/// Only the local partner can be changed.
|
|
/// RDOs are provided by the sinking device and exist only after a successful PD negotiation
|
|
/// (Otherwise zero).
|
|
/// Only one RDO can exist at a time. i.e. Either the Local or Remote partner RDO
|
|
///
|
|
/// \param rdo Request Data Object to be set.
|
|
///
|
|
/// \return Returns \ref EntityReturnValues "common entity" return values
|
|
aErr setRequestDataObject(const uint32_t rdo);
|
|
|
|
/// Gets the current state of the connection in the form of a bitmask.
|
|
///
|
|
/// \param state Pointer to be filled with the current connection state bits.
|
|
///
|
|
/// \return Returns \ref EntityReturnValues "common entity" return values
|
|
aErr getLinkState(uint32_t* state);
|
|
|
|
/// Gets the length of time that the port has been in the attached state.
|
|
/// Returned as a list of two unsigned integers, first seconds, then microseconds.
|
|
///
|
|
/// \param secondsAndMicroseconds Pointer to list of unsigned integers to fill with attach
|
|
/// time elapsed
|
|
/// \param bufferLength Length of the buffer to be filed
|
|
/// \param unloadedLength Length that was actually received and filled.
|
|
///
|
|
/// \return Returns \ref EntityReturnValues "common entity" return values
|
|
aErr getAttachTimeElapsed(uint32_t* secondsAndMicroseconds, const size_t bufferLength, size_t* unloadedLength);
|
|
|
|
/// Gets the power roles that may be advertised by the local partner. (CC Strapping).
|
|
///
|
|
/// \param powerRole Variable to be filed with the power role
|
|
/// - None = 0 = pdPowerRoleCapabilities_None
|
|
/// - Source = 1 = pdPowerRoleCapabilities_Source
|
|
/// - Sink = 2 = pdPowerRoleCapabilities_Sink
|
|
/// - Source/Sink = 3 = pdPowerRoleCapabilities_DualRole (Dual Role Port)
|
|
///
|
|
/// \return Returns \ref EntityReturnValues "common entity" return values
|
|
aErr getPowerRoleCapabilities(uint8_t* powerRole);
|
|
|
|
/// Gets the power role that is currently being advertised by the local partner. (CC
|
|
/// Strapping).
|
|
///
|
|
/// \param powerRole Variable to be filed with the power role
|
|
/// - Disabled = 0 = powerdeliveryPowerRoleDisabled
|
|
/// - Source = 1= powerdeliveryPowerRoleSource
|
|
/// - Sink = 2 = powerdeliveryPowerRoleSink
|
|
/// - Source/Sink = 3 = powerdeliveryPowerRoleSourceSink (Dual Role Port)
|
|
///
|
|
/// \return Returns \ref EntityReturnValues "common entity" return values
|
|
aErr getPowerRole(uint8_t* powerRole);
|
|
|
|
/// Set the current power role to be advertised by the Local partner. (CC Strapping).
|
|
///
|
|
/// \param powerRole Value to be applied.
|
|
/// - Disabled = 0 = powerdeliveryPowerRoleDisabled
|
|
/// - Source = 1= powerdeliveryPowerRoleSource
|
|
/// - Sink = 2 = powerdeliveryPowerRoleSink
|
|
/// - Source/Sink = 3 = powerdeliveryPowerRoleSourceSink (Dual Role Port)
|
|
///
|
|
/// \return Returns \ref EntityReturnValues "common entity" return values
|
|
aErr setPowerRole(const uint8_t powerRole);
|
|
|
|
/// Gets the preferred power role currently being advertised by the Local partner. (CC
|
|
/// Strapping).
|
|
///
|
|
/// \param powerRole Value to be applied.
|
|
/// - Disabled = 0 = powerdeliveryPowerRoleDisabled
|
|
/// - Source = 1= powerdeliveryPowerRoleSource
|
|
/// - Sink = 2 = powerdeliveryPowerRoleSink
|
|
///
|
|
/// \return Returns \ref EntityReturnValues "common entity" return values
|
|
aErr getPowerRolePreferred(uint8_t* powerRole);
|
|
|
|
/// Set the preferred power role to be advertised by the Local partner (CC Strapping).
|
|
///
|
|
/// \param powerRole Value to be applied.
|
|
/// - Disabled = 0 = powerdeliveryPowerRoleDisabled
|
|
/// - Source = 1= powerdeliveryPowerRoleSource
|
|
/// - Sink = 2 = powerdeliveryPowerRoleSink
|
|
///
|
|
/// \return Returns \ref EntityReturnValues "common entity" return values
|
|
aErr setPowerRolePreferred(const uint8_t powerRole);
|
|
|
|
/// Gets the data roles that may be advertised by the local partner.
|
|
///
|
|
/// \param dataRole Variable to be filed with the data role
|
|
/// - None = 0 = pdDataRoleCapabilities_None
|
|
/// - DFP = 1 = pdDataRoleCapabilities_DFP
|
|
/// - UFP = 2 = pdDataRoleCapabilities_UFP
|
|
/// - DFP/UFP = 3 = pdDataRoleCapabilities_DualRole (Dual Role Port)
|
|
///
|
|
/// \return Returns \ref EntityReturnValues "common entity" return values
|
|
aErr getDataRoleCapabilities(uint8_t* dataRole);
|
|
|
|
/// Gets the maximum voltage capability reported by the e-mark of the attached cable.
|
|
///
|
|
/// \param maxVoltage Variable to be filled with an enumerated representation of voltage.
|
|
/// - Unknown/Unattached (0)
|
|
/// - 20 Volts DC (1)
|
|
/// - 30 Volts DC (2)
|
|
/// - 40 Volts DC (3)
|
|
/// - 50 Volts DC (4)
|
|
///
|
|
/// \return Returns \ref EntityReturnValues "common entity" return values
|
|
aErr getCableVoltageMax(uint8_t* maxVoltage);
|
|
|
|
/// Gets the maximum current capability report by the e-mark of the attached cable.
|
|
///
|
|
/// \param maxCurrent Variable to be filled with an enumerated representation of current.
|
|
/// - Unknown/Unattached (0)
|
|
/// - 3 Amps (1)
|
|
/// - 5 Amps (2)
|
|
///
|
|
/// \return Returns \ref EntityReturnValues "common entity" return values
|
|
aErr getCableCurrentMax(uint8_t* maxCurrent);
|
|
|
|
/// Gets the maximum data rate capability reported by the e-mark of the attached cable.
|
|
///
|
|
/// \param maxSpeed Variable to be filled with an enumerated representation of data speed.
|
|
/// - Unknown/Unattached (0)
|
|
/// - USB 2.0 (1)
|
|
/// - USB 3.2 gen 1 (2)
|
|
/// - USB 3.2 / USB 4 gen 2 (3)
|
|
/// - USB 4 gen 3 (4)
|
|
///
|
|
/// \return Returns \ref EntityReturnValues "common entity" return values
|
|
aErr getCableSpeedMax(uint8_t* maxSpeed);
|
|
|
|
/// Gets the cable type reported by the e-mark of the attached cable.
|
|
///
|
|
/// \param type Variable to be filled with an enumerated representation of the cable type.
|
|
/// - Invalid, no e-mark and not Vconn powered (0)
|
|
/// - Passive cable with e-mark (1)
|
|
/// - Active cable (2)
|
|
///
|
|
/// \return Returns \ref EntityReturnValues "common entity" return values
|
|
aErr getCableType(uint8_t* type);
|
|
|
|
/// Gets the current orientation being used for PD communication
|
|
///
|
|
/// \param orientation Variable filled with an enumeration of the orientation.
|
|
/// - Unconnected (0)
|
|
/// - CC1 (1)
|
|
/// - CC2 (2)
|
|
///
|
|
/// \return Returns \ref EntityReturnValues "common entity" return values
|
|
aErr getCableOrientation(uint8_t* orientation);
|
|
|
|
/// Requests an action of the Remote partner.
|
|
/// Actions are not guaranteed to occur.
|
|
///
|
|
/// \param request Request to be issued to the remote partner
|
|
/// - pdRequestHardReset (0)
|
|
/// - pdRequestSoftReset (1)
|
|
/// - pdRequestDataReset (2)
|
|
/// - pdRequestPowerRoleSwap (3)
|
|
/// - pdRequestPowerFastRoleSwap (4)
|
|
/// - pdRequestDataRoleSwap (5)
|
|
/// - pdRequestVconnSwap (6)
|
|
/// - pdRequestSinkGoToMinimum (7)
|
|
/// - pdRequestRemoteSourcePowerDataObjects (8)
|
|
/// - pdRequestRemoteSinkPowerDataObjects (9)
|
|
///
|
|
/// \return Returns \ref EntityReturnValues "common entity" return values
|
|
aErr request(const uint8_t request);
|
|
|
|
/// Gets the status of the last request command sent.
|
|
///
|
|
/// \param status Variable to be filled with the status
|
|
///
|
|
/// \return Returns \ref EntityReturnValues "common entity" return values
|
|
aErr requestStatus(uint32_t* status);
|
|
|
|
/// Gets the current enabled overrides
|
|
///
|
|
/// \param overrides Bit mapped representation of the current override configuration.
|
|
///
|
|
/// \return Returns \ref EntityReturnValues "common entity" return values
|
|
aErr getOverride(uint32_t* overrides);
|
|
|
|
/// Sets the current enabled overrides
|
|
///
|
|
/// \param overrides Overrides to be set in a bit mapped representation.
|
|
///
|
|
/// \return Returns \ref EntityReturnValues "common entity" return values
|
|
aErr setOverride(const uint32_t overrides);
|
|
|
|
/// Gets the current mode of the local partner flag/advertisement.
|
|
/// These flags are apart of the first Local Power Data Object and must be managed in order to
|
|
/// accurately represent the system to other PD devices.
|
|
/// This API allows overriding of that feature. Overriding may lead to unexpected behaviors.
|
|
///
|
|
/// \param flag Flag/Advertisement to be modified
|
|
/// \param mode Variable to be filled with the current mode.
|
|
/// - Disabled (0)
|
|
/// - Enabled (1)
|
|
/// - Auto (2) default
|
|
///
|
|
/// \return Returns \ref EntityReturnValues "common entity" return values
|
|
aErr getFlagMode(const uint8_t flag, uint8_t* mode);
|
|
|
|
/// Sets how the local partner flag/advertisement is managed.
|
|
/// These flags are apart of the first Local Power Data Object and must be managed in order to
|
|
/// accurately represent the system to other PD devices.
|
|
/// This API allows overriding of that feature. Overriding may lead to unexpected behaviors.
|
|
///
|
|
/// \param flag Flag/Advertisement to be modified
|
|
/// \param mode Value to be applied.
|
|
/// - Disabled (0)
|
|
/// - Enabled (1)
|
|
/// - Auto (2) default
|
|
///
|
|
/// \return Returns \ref EntityReturnValues "common entity" return values
|
|
aErr setFlagMode(const uint8_t flag, const uint8_t mode);
|
|
|
|
/// Gets the Peak Current Configuration for the Local Source.
|
|
/// The peak current configuration refers to the allowable tolerance/overload capabilities in
|
|
/// regards to the devices max current.
|
|
/// This tolerance includes a maximum value and a time unit.
|
|
///
|
|
/// \param configuration An enumerated value referring to the current configuration.
|
|
/// - Allowable values are 0 - 4
|
|
///
|
|
/// \return Returns \ref EntityReturnValues "common entity" return values
|
|
aErr getPeakCurrentConfiguration(uint8_t* configuration);
|
|
|
|
/// Sets the Peak Current Configuration for the Local Source.
|
|
/// The peak current configuration refers to the allowable tolerance/overload capabilities in
|
|
/// regards to the devices max current.
|
|
/// This tolerance includes a maximum value and a time unit.
|
|
///
|
|
/// \param configuration An enumerated value referring to the configuration to be set
|
|
/// - Allowable values are 0 - 4
|
|
///
|
|
/// \return Returns \ref EntityReturnValues "common entity" return values
|
|
aErr setPeakCurrentConfiguration(const uint8_t configuration);
|
|
|
|
/// Gets the Fast Role Swap Current
|
|
/// The fast role swap current refers to the amount of current required by the Local Sink in
|
|
/// order to successfully preform the swap.
|
|
///
|
|
/// \param swapCurrent An enumerated value referring to current swap value.
|
|
/// - 0A (0)
|
|
/// - 900mA (1)
|
|
/// - 1.5A (2)
|
|
/// - 3A (3)
|
|
///
|
|
/// \return Returns \ref EntityReturnValues "common entity" return values
|
|
aErr getFastRoleSwapCurrent(uint8_t* swapCurrent);
|
|
|
|
/// Sets the Fast Role Swap Current
|
|
/// The fast role swap current refers to the amount of current required by the Local Sink in
|
|
/// order to successfully preform the swap.
|
|
///
|
|
/// \param swapCurrent An enumerated value referring to value to be set.
|
|
/// - 0A (0)
|
|
/// - 900mA (1)
|
|
/// - 1.5A (2)
|
|
/// - 3A (3)
|
|
///
|
|
/// \return Returns \ref EntityReturnValues "common entity" return values
|
|
aErr setFastRoleSwapCurrent(const uint8_t swapCurrent);
|
|
|
|
/// Helper function for packing Data Object attributes.
|
|
/// This value is used as a subindex for all Data Object calls with the BrainStem Protocol.
|
|
///
|
|
/// \param attributes Variable to be filled with packed values.
|
|
/// \param partner Indicates which side of the PD connection.
|
|
/// - Local = 0 = powerdeliveryPartnerLocal
|
|
/// - Remote = 1 = powerdeliveryPartnerRemote
|
|
/// \param powerRole Indicates which power role of PD connection.
|
|
/// - Source = 1 = powerdeliveryPowerRoleSource
|
|
/// - Sink = 2 = powerdeliveryPowerRoleSink
|
|
/// \param ruleIndex Data object index.
|
|
///
|
|
/// \return Returns \ref EntityReturnValues "common entity" return values
|
|
static aErr packDataObjectAttributes(uint8_t* attributes, const uint8_t partner, const uint8_t powerRole, const uint8_t ruleIndex);
|
|
|
|
/// Helper function for unpacking Data Object attributes.
|
|
/// This value is used as a subindex for all Data Object calls with the BrainStem Protocol.
|
|
///
|
|
/// \param attributes Variable to be filled with packed values.
|
|
/// \param partner Indicates which side of the PD connection.
|
|
/// - Local = 0 = powerdeliveryPartnerLocal
|
|
/// - Remote = 1 = powerdeliveryPartnerRemote
|
|
/// \param powerRole Indicates which power role of PD connection.
|
|
/// - Source = 1 = powerdeliveryPowerRoleSource
|
|
/// - Sink = 2 = powerdeliveryPowerRoleSink
|
|
/// \param ruleIndex Data object index.
|
|
///
|
|
/// \return Returns \ref EntityReturnValues "common entity" return values
|
|
static aErr unpackDataObjectAttributes(const uint8_t attributes, uint8_t* partner, uint8_t* powerRole, uint8_t* ruleIndex);
|
|
|
|
|
|
|
|
};
|
|
|
|
} // namespace BrainStem
|
|
} // namespace Acroname
|
|
|
|
#endif // defined(__cplusplus)
|
|
|
|
#endif // __AUTOGEN_POWERDELIVERY_CPP_H__
|