Added over-temperature protection

I think so, anyway.  Testing with a heat gun didn't result in the Sink
resetting itself, so I'm not confident that I understand the FUSB302B's
over-temperature sensing mechanism.

I must point out though that I'm not confident that this
over-temperature protection is even useful.  The PD Buddy Sink doesn't
get hot on its own, and if it did, it might not even be from the device
it's powering, making a hard reset useless.  The spec says that we Shall
implement over temperature protection though, and that we Shall send a
Hard Reset message when it engages, so even though I take issue with the
requirement, I'll try to do what the standard says I Shall.

src/int_n.c

@@ -26,6 +26,7 @@
 #include "protocol_rx.h"
 #include "protocol_tx.h"
 #include "hard_reset.h"
+#include "policy_engine.h"
 
 
 /*
@@ -70,6 +71,14 @@ static THD_FUNCTION(IntNPoll, arg) {
                 events |= PDB_EVT_HARDRST_I_HARDSENT;
             }
             chEvtSignal(pdb_hardrst_thread, events);
+
+            /* If the I_OCP_TEMP and OVRTEMP flags are set, tell the Policy
+             * Engine thread */
+            if (status.interrupta & FUSB_INTERRUPTA_I_OCP_TEMP
+                    && status.status1 & FUSB_STATUS1_OVRTEMP) {
+                chEvtSignal(pdb_pe_thread, PDB_EVT_PE_I_OVRTEMP);
+            }
+
         }
         chThdSleepMilliseconds(1);
     }

src/policy_engine.c

@@ -62,7 +62,9 @@ mailbox_t pdb_pe_mailbox;
 
 static enum policy_engine_state pe_sink_startup(void)
 {
+    /* We don't have an explicit contract currently */
     explicit_contract = false;
+    /* Tell the DPM that we've started negotiations */
     pdb_dpm_pd_start();
 
     /* No need to reset the protocol layer here.  There are two ways into this
@@ -85,29 +87,37 @@ static enum policy_engine_state pe_sink_discovery(void)
 static enum policy_engine_state pe_sink_wait_cap(void)
 {
     /* Fetch a message from the protocol layer */
-    eventmask_t evt = chEvtWaitAnyTimeout(PDB_EVT_PE_MSG_RX, PD_T_TYPEC_SINK_WAIT_CAP);
+    eventmask_t evt = chEvtWaitAnyTimeout(PDB_EVT_PE_MSG_RX
+            | PDB_EVT_PE_I_OVRTEMP, PD_T_TYPEC_SINK_WAIT_CAP);
     /* If we timed out waiting for Source_Capabilities, send a hard reset */
     if (evt == 0) {
         return PESinkHardReset;
     }
+    /* If we're too hot, we shouldn't negotiate power yet */
+    if (evt & PDB_EVT_PE_I_OVRTEMP) {
+        return PESinkWaitCap;
+    }
 
-    /* Get the message */
-    if (chMBFetch(&pdb_pe_mailbox, (msg_t *) &policy_engine_message, TIME_IMMEDIATE) == MSG_OK) {
-        /* If we got a Source_Capabilities message, read it. */
-        if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_SOURCE_CAPABILITIES
-                && PD_NUMOBJ_GET(policy_engine_message) > 0) {
-            return PESinkEvalCap;
-        /* If the message was a Soft_Reset, do the soft reset procedure */
-        } else if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_SOFT_RESET
-                && PD_NUMOBJ_GET(policy_engine_message) == 0) {
-            chPoolFree(&pdb_msg_pool, policy_engine_message);
-            policy_engine_message = NULL;
-            return PESinkSoftReset;
-        /* If we got an unexpected message, reset */
-        } else {
-            /* Free the received message */
-            chPoolFree(&pdb_msg_pool, policy_engine_message);
-            return PESinkHardReset;
+    /* If we got a message */
+    if (evt & PDB_EVT_PE_MSG_RX) {
+        /* Get the message */
+        if (chMBFetch(&pdb_pe_mailbox, (msg_t *) &policy_engine_message, TIME_IMMEDIATE) == MSG_OK) {
+            /* If we got a Source_Capabilities message, read it. */
+            if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_SOURCE_CAPABILITIES
+                    && PD_NUMOBJ_GET(policy_engine_message) > 0) {
+                return PESinkEvalCap;
+            /* If the message was a Soft_Reset, do the soft reset procedure */
+            } else if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_SOFT_RESET
+                    && PD_NUMOBJ_GET(policy_engine_message) == 0) {
+                chPoolFree(&pdb_msg_pool, policy_engine_message);
+                policy_engine_message = NULL;
+                return PESinkSoftReset;
+            /* If we got an unexpected message, reset */
+            } else {
+                /* Free the received message */
+                chPoolFree(&pdb_msg_pool, policy_engine_message);
+                return PESinkHardReset;
+            }
         }
     }
 
@@ -236,13 +246,19 @@ static enum policy_engine_state pe_sink_transition_sink(void)
 static enum policy_engine_state pe_sink_ready(void)
 {
     /* Wait for an event */
-    eventmask_t evt = chEvtWaitAny(PDB_EVT_PE_MSG_RX | PDB_EVT_PE_RESET);
+    eventmask_t evt = chEvtWaitAny(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) {
         return PESinkTransitionDefault;
     }
 
+    /* If we overheated, send a hard reset */
+    if (evt & PDB_EVT_PE_I_OVRTEMP) {
+        return PESinkHardReset;
+    }
+
     /* If we received a message */
     if (evt & PDB_EVT_PE_MSG_RX) {
         if (chMBFetch(&pdb_pe_mailbox, (msg_t *) &policy_engine_message, TIME_IMMEDIATE) == MSG_OK) {

src/policy_engine.h

@@ -28,6 +28,7 @@
 #define PDB_EVT_PE_TX_DONE EVENT_MASK(2)
 #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)
 
 /* The Policy Engine thread object */
 extern thread_t *pdb_pe_thread;