me/IronOS
1
0
Fork 1
mirror of https://github.com/Ralim/IronOS.git synced 2025-02-26 07:53:55 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Allow query PD for status and remove more cruft from PPS

Browse Source
This commit is contained in:
Ben V. Brown
2020-07-29 22:52:36 +10:00
parent a59d008d07
commit a39185315d
5 changed files with 29 additions and 125 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
workspace/TS100/Core/Drivers/FUSB302/int_n.cpp
View File

@@ -45,7 +45,8 @@ void InterruptHandler::Thread(const void *arg) {
bool notifSent = false;
while (true) {
/* If the INT_N line is low */
if (xTaskNotifyWait(0x00, 0x0F, NULL, 200) == pdPASS) {
if (xTaskNotifyWait(0x00, 0x0F, NULL,
PolicyEngine::setupCompleteOrTimedOut() ? 1000 : 200) == pdPASS) {
//delay slightly so we catch the crc with better timing
osDelay(2);
}

16
workspace/TS100/Core/Drivers/FUSB302/pd.h
View File

@@ -273,18 +273,18 @@
* Where a range is specified, the middle of the range (rounded down to the
* nearest millisecond) is used.
*/
#define PD_T_CHUNKING_NOT_SUPPORTED (450)
#define PD_T_HARD_RESET_COMPLETE (400)
#define PD_T_PS_TRANSITION (5000)
#define PD_T_SENDER_RESPONSE (2700)
#define PD_T_SINK_REQUEST (1000)
#define PD_T_TYPEC_SINK_WAIT_CAP (5000)
#define PD_T_PD_DEBOUNCE (2000)
#define PD_T_CHUNKING_NOT_SUPPORTED (45)
#define PD_T_HARD_RESET_COMPLETE (40)
#define PD_T_PS_TRANSITION (500)
#define PD_T_SENDER_RESPONSE (270)
#define PD_T_SINK_REQUEST (100)
#define PD_T_TYPEC_SINK_WAIT_CAP (45)
#define PD_T_PD_DEBOUNCE (20)
/*
* Counter maximums
*/
#define PD_N_HARD_RESET_COUNT 20
#define PD_N_HARD_RESET_COUNT 2
/*
* Value parameters

37
workspace/TS100/Core/Drivers/FUSB302/policy_engine.cpp
View File

@@ -263,19 +263,6 @@ PolicyEngine::policy_engine_state PolicyEngine::pe_sink_select_cap() {
return PESinkHardReset;
}
/* If we're using PD 3.0 */
if ((hdr_template & PD_HDR_SPECREV) == PD_SPECREV_3_0) {
/* If the request was for a PPS APDO, start SinkPPSPeriodicTimer */
if (PD_RDO_OBJPOS_GET(&_last_dpm_request) >= _pps_index) {
start_pps_timer();
/* Otherwise, stop SinkPPSPeriodicTimer */
} else {
stop_pps_timer();
}
}
/* This will use a virtual timer to send an event flag to this thread after
* PD_T_PPS_REQUEST */
/* Wait for a response */
evt = waitForEvent(PDB_EVT_PE_MSG_RX | PDB_EVT_PE_RESET,
PD_T_SENDER_RESPONSE);
@@ -367,8 +354,7 @@ PolicyEngine::policy_engine_state PolicyEngine::pe_sink_ready() {
/* Wait for an event */
evt = waitForEvent(
PDB_EVT_PE_MSG_RX | PDB_EVT_PE_RESET | PDB_EVT_PE_I_OVRTEMP
| PDB_EVT_PE_PPS_REQUEST);
PDB_EVT_PE_MSG_RX | PDB_EVT_PE_RESET | PDB_EVT_PE_I_OVRTEMP);
/* If we got reset signaling, transition to default */
if (evt & PDB_EVT_PE_RESET) {
@@ -380,14 +366,6 @@ PolicyEngine::policy_engine_state PolicyEngine::pe_sink_ready() {
return PESinkHardReset;
}
/* If SinkPPSPeriodicTimer ran out, send a new request */
if (evt & PDB_EVT_PE_PPS_REQUEST) {
/* Tell the protocol layer we're starting an AMS */
ProtocolTransmit::notify(
ProtocolTransmit::Notifications::PDB_EVT_PRLTX_START_AMS);
return PESinkSelectCap;
}
/* If we received a message */
if (evt & PDB_EVT_PE_MSG_RX) {
if (messageWaiting()) {
@@ -717,14 +695,6 @@ PolicyEngine::policy_engine_state PolicyEngine::pe_sink_source_unresponsive() {
return PESinkSourceUnresponsive;
}
void PolicyEngine::PPSTimerCallBack() {
notify(PDB_EVT_PE_PPS_REQUEST);
}
bool PolicyEngine::pdHasNegotiated() {
return pdNegotiationComplete;
}
uint32_t PolicyEngine::waitForEvent(uint32_t mask, uint32_t ticksToWait) {
return xEventGroupWaitBits(xEventGroupHandle, mask, mask, pdFALSE,
ticksToWait);
@@ -735,8 +705,3 @@ bool PolicyEngine::isPD3_0() {
return (hdr_template & PD_HDR_SPECREV) == PD_SPECREV_3_0;
}
void PolicyEngine::start_pps_timer() {
}
void PolicyEngine::stop_pps_timer() {
}

18
workspace/TS100/Core/Drivers/FUSB302/policy_engine.h
View File

@@ -31,7 +31,6 @@
#define PDB_EVT_PE_TX_ERR EVENT_MASK(3)
#define PDB_EVT_PE_HARD_SENT EVENT_MASK(4)
#define PDB_EVT_PE_I_OVRTEMP EVENT_MASK(5)
#define PDB_EVT_PE_PPS_REQUEST EVENT_MASK(6)
#define PDB_EVT_PE_MSG_RX_PEND EVENT_MASK(7) /* Never SEND THIS DIRECTLY*/
class PolicyEngine {
@@ -44,10 +43,19 @@ public:
static void notify(uint32_t notification);
//Returns true if headers indicate PD3.0 compliant
static bool isPD3_0();
static void PPSTimerCallBack();
static bool setupCompleteOrTimedOut() {
if (pdNegotiationComplete)
return true;
if (state == policy_engine_state::PESinkSourceUnresponsive)
return true;
if (state == policy_engine_state::PESinkReady)
return true;
return false;
}
//Has pd negotiation completed
static bool pdHasNegotiated();
static bool pdHasNegotiated() {
return pdNegotiationComplete;
}
private:
static bool pdNegotiationComplete;
static int current_voltage_mv; //The current voltage PD is expecting
@@ -125,8 +133,6 @@ private:
static bool messageWaiting();
//Read a pending message into the temp message
static bool readMessage();
static void start_pps_timer();
static void stop_pps_timer();
// These callbacks are called to implement the logic for the iron to select the desired voltage

80
workspace/TS100/Core/Drivers/FUSB302/policy_engine_user.cpp
View File

@@ -84,7 +84,7 @@ bool PolicyEngine::pdbs_dpm_evaluate_capability(
PD_RDO_FV_MAX_CURRENT_SET(
current) | PD_RDO_FV_CURRENT_SET(current)
| PD_RDO_NO_USB_SUSPEND | PD_RDO_OBJPOS_SET(i + 1);
//We support usb comms (ish)
request->obj[0] |= PD_RDO_USB_COMMS;
/* Update requested voltage */
@@ -94,69 +94,10 @@ bool PolicyEngine::pdbs_dpm_evaluate_capability(
}
}
}
#if 0
/* If we have a PPS APDO, our desired V lies within its range, and
* its I is at least our desired I */
if ((capabilities->obj[i] & PD_PDO_TYPE) == PD_PDO_TYPE_AUGMENTED
&& (capabilities->obj[i] & PD_APDO_TYPE) == PD_APDO_TYPE_PPS) {
int min_mv = PD_PAV2MV(
PD_APDO_PPS_MIN_VOLTAGE_GET(capabilities->obj[i]));
int max_mv = PD_PAV2MV(
PD_APDO_PPS_MAX_VOLTAGE_GET(capabilities->obj[i]));
int current = PD_CA2PAI(
PD_APDO_PPS_CURRENT_GET(capabilities->obj[i]));
/* We got what we wanted, so build a request for that */
//
// request->hdr = hdr_template | PD_MSGTYPE_REQUEST | PD_NUMOBJ(1);
//
// /* Build a request */
// request->obj[0] =
// PD_RDO_PROG_CURRENT_SET(
// PD_CA2PAI(current)) | PD_RDO_PROG_VOLTAGE_SET(PD_MV2PRV(voltage))
// | PD_RDO_NO_USB_SUSPEND | PD_RDO_OBJPOS_SET(i + 1);
//
// request->obj[0] |= PD_RDO_USB_COMMS;
//
// /* Update requested voltage */
// _requested_voltage = PD_PRV2MV(PD_MV2PRV(voltage));
//
// return true;
}
#endif
}
}
/* If there's a PDO in the voltage range, use it */
// int8_t i = dpm_get_range_fixed_pdo_index(caps, scfg);
// if (i >= 0) {
// /* We got what we wanted, so build a request for that */
// request->hdr = hdr_template | PD_MSGTYPE_REQUEST | PD_NUMOBJ(1);
// /* Get the current we need at this voltage */
// current = dpm_get_current(scfg,
// PD_PDV2MV(PD_PDO_SRC_FIXED_VOLTAGE_GET(caps->obj[i])));
// if (scfg->flags & PDBS_CONFIG_FLAGS_GIVEBACK) {
// /* GiveBack enabled */
// request->obj[0] =
// PD_RDO_FV_MIN_CURRENT_SET(
// DPM_MIN_CURRENT) | PD_RDO_FV_CURRENT_SET(current) | PD_RDO_NO_USB_SUSPEND
// | PD_RDO_GIVEBACK | PD_RDO_OBJPOS_SET(i + 1);
// } else {
// /* GiveBack disabled */
// request->obj[0] =
// PD_RDO_FV_MAX_CURRENT_SET(
// current) | PD_RDO_FV_CURRENT_SET(current) | PD_RDO_NO_USB_SUSPEND
// | PD_RDO_OBJPOS_SET(i + 1);
// }
// if (usb_comms) {
// request->obj[0] |= PD_RDO_USB_COMMS;
// }
//
// /* Update requested voltage */
// _requested_voltage = PD_PDV2MV(
// PD_PDO_SRC_FIXED_VOLTAGE_GET(caps->obj[i]));
//
// _capability_match = true;
// return true;
// }
/* Nothing matched (or no configuration), so get 5 V at low current */
request->hdr = hdr_template | PD_MSGTYPE_REQUEST | PD_NUMOBJ(1);
request->obj[0] =
@@ -168,7 +109,6 @@ bool PolicyEngine::pdbs_dpm_evaluate_capability(
if (pdNegotiationComplete) {
request->obj[0] |= PD_RDO_CAP_MISMATCH;
}
/* If we can do USB communications, tell the power supply */
request->obj[0] |= PD_RDO_USB_COMMS;
/* Update requested voltage */
@@ -191,8 +131,8 @@ void PolicyEngine::pdbs_dpm_get_sink_capability(union pd_msg *cap) {
PD_MV2PDV(5000)) | PD_PDO_SNK_FIXED_CURRENT_SET(DPM_MIN_CURRENT);
/* Get the current we want */
uint16_t current = 100; // In centi-amps
uint16_t voltage = 9000; // in mv
uint16_t current = USB_PD_Desired_Levels[1] / 10; // In centi-amps
uint16_t voltage = USB_PD_Desired_Levels[0]; // in mv
/* Add a PDO for the desired power. */
cap->obj[numobj++] = PD_PDO_TYPE_FIXED
| PD_PDO_SNK_FIXED_VOLTAGE_SET(
@@ -233,15 +173,6 @@ void PolicyEngine::pdbs_dpm_get_sink_capability(union pd_msg *cap) {
}
}
/* If we're using PD 3.0, add a PPS APDO for our desired voltage */
if (isPD3_0()) {
cap->obj[numobj++] =
PD_PDO_TYPE_AUGMENTED | PD_APDO_TYPE_PPS
| PD_APDO_PPS_MAX_VOLTAGE_SET(
PD_MV2PAV(voltage)) | PD_APDO_PPS_MIN_VOLTAGE_SET(PD_MV2PAV(voltage))
| PD_APDO_PPS_CURRENT_SET(PD_CA2PAI(current));
}
/* Set the unconstrained power flag. */
if (_unconstrained_power) {
cap->obj[0] |= PD_PDO_SNK_FIXED_UNCONSTRAINED;
@@ -259,6 +190,7 @@ bool PolicyEngine::pdbs_dpm_evaluate_typec_current(
/* We don't control the voltage anymore; it will always be 5 V. */
current_voltage_mv = _requested_voltage = 5000;
//For the soldering iron we accept this as a fallback, but it sucks
pdNegotiationComplete = false;
return true;
}