Add SinkPPSPeriodicTimer

Now if we make a request for a PPS APDO, the SinkPPSPeriodicTimer is
run, forcing a new request to be made every 10 s.  This is important
because without it, the Source Shall perform a Hard Reset 15 s after the
request is made.

lib/include/pd.h

 #define PD_PDO_TYPE (0x3 << PD_PDO_TYPE_SHIFT)
 
 /* PDO types */
-#define PD_PDO_TYPE_FIXED (0x0 << PD_PDO_TYPE_SHIFT)
-#define PD_PDO_TYPE_BATTERY (0x1 << PD_PDO_TYPE_SHIFT)
-#define PD_PDO_TYPE_VARIABLE (0x2 << PD_PDO_TYPE_SHIFT)
+#define PD_PDO_TYPE_FIXED ((unsigned) (0x0 << PD_PDO_TYPE_SHIFT))
+#define PD_PDO_TYPE_BATTERY ((unsigned) (0x1 << PD_PDO_TYPE_SHIFT))
+#define PD_PDO_TYPE_VARIABLE ((unsigned) (0x2 << PD_PDO_TYPE_SHIFT))
+#define PD_PDO_TYPE_AUGMENTED ((unsigned) (0x3 << PD_PDO_TYPE_SHIFT))
+
+#define PD_APDO_TYPE_SHIFT 28
+#define PD_APDO_TYPE (0x3 << PD_APDO_TYPE_SHIFT)
+
+/* APDO types */
+#define PD_APDO_TYPE_PPS (0x0 << PD_APDO_TYPE_SHIFT)
 
 /* PD Source Fixed PDO */
 #define PD_PDO_SRC_FIXED_DUAL_ROLE_PWR_SHIFT 29
 #define PD_RDO_UNCHUNKED_EXT_MSG (1 << PD_RDO_UNCHUNKED_EXT_MSG_SHIFT)
 
 #define PD_RDO_OBJPOS_SET(i) (((i) << PD_RDO_OBJPOS_SHIFT) & PD_RDO_OBJPOS)
+#define PD_RDO_OBJPOS_GET(msg) (((msg)->obj[0] & PD_RDO_OBJPOS) >> PD_RDO_OBJPOS_SHIFT)
 
 /* Fixed and Variable RDO, no GiveBack support */
 #define PD_RDO_FV_CURRENT_SHIFT 10
 #define PD_T_SENDER_RESPONSE MS2ST(27)
 #define PD_T_SINK_REQUEST MS2ST(100)
 #define PD_T_TYPEC_SINK_WAIT_CAP MS2ST(465)
+#define PD_T_PPS_REQUEST S2ST(10)
 /* This is actually from Type-C, not Power Delivery, but who cares? */
 #define PD_T_PD_DEBOUNCE MS2ST(15)
 

lib/include/pdb_pe.h

  * Events for the Policy Engine thread, sent by user code
  */
 /* Tell the PE to send a Get_Source_Cap message */
-#define PDB_EVT_PE_GET_SOURCE_CAP EVENT_MASK(6)
+#define PDB_EVT_PE_GET_SOURCE_CAP EVENT_MASK(7)
 /* Tell the PE that new power is required */
-#define PDB_EVT_PE_NEW_POWER EVENT_MASK(7)
+#define PDB_EVT_PE_NEW_POWER EVENT_MASK(8)
 
 
 /*
     int8_t _hard_reset_counter;
     /* The result of the last Type-C Current match comparison */
     int8_t _old_tcc_match;
+    /* The index of the first PPS APDO */
+    uint8_t _pps_index;
+    /* Virtual timer for SinkPPSPeriodicTimer */
+    virtual_timer_t _sink_pps_periodic_timer;
     /* Queue for the PE mailbox */
     msg_t _mailbox_queue[PDB_MSG_POOL_SIZE];
 };

lib/src/policy_engine.c

 #include "fusb302b.h"
 
 
+static void pe_sink_pps_periodic_timer_cb(void *cfg)
+{
+    /* Signal the PE thread to make a new PPS request */
+    chSysLockFromISR();
+    chEvtSignalI(((struct pdb_config *) cfg)->pe.thread, PDB_EVT_PE_PPS_REQUEST);
+    chSysUnlockFromISR();
+}
+
+
 enum policy_engine_state {
     PESinkStartup,
     PESinkDiscovery,
 
 static enum policy_engine_state pe_sink_eval_cap(struct pdb_config *cfg)
 {
+    /* If we have a message, remember the index of the first PPS APDO so we can
+     * check if the request is for a PPS APDO in PE_SNK_Select_Cap. */
+    if (cfg->pe._message != NULL) {
+        /* Start by assuming we won't find a PPS APDO (set the index greater
+         * than the maximum possible) */
+        cfg->pe._pps_index = 8;
+        /* Search for the first PPS APDO */
+        for (int8_t i = 0; i < PD_NUMOBJ_GET(cfg->pe._message); i++) {
+            if ((cfg->pe._message->obj[i] & PD_PDO_TYPE) == PD_PDO_TYPE_AUGMENTED
+                    && (cfg->pe._message->obj[i] & PD_APDO_TYPE) == PD_APDO_TYPE_PPS) {
+                cfg->pe._pps_index = i + 1;
+                break;
+            }
+        }
+    }
     /* Get a message object for the request if we don't have one already */
     if (cfg->pe._last_dpm_request == NULL) {
         cfg->pe._last_dpm_request = chPoolAlloc(&pdb_msg_pool);
         return PESinkHardReset;
     }
 
+    /* If we're using PD 3.0 */
+    if ((cfg->pe.hdr_template & PD_HDR_SPECREV) == PD_SPECREV_3_0) {
+        /* If the request was for a PPS APDO, start SinkPPSPeriodicTimer */
+        if (PD_RDO_OBJPOS_GET(cfg->pe._last_dpm_request) >= cfg->pe._pps_index) {
+            chVTSet(&cfg->pe._sink_pps_periodic_timer, PD_T_PPS_REQUEST,
+                    pe_sink_pps_periodic_timer_cb, cfg);
+        /* Otherwise, stop SinkPPSPeriodicTimer */
+        } else {
+            chVTReset(&cfg->pe._sink_pps_periodic_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 = chEvtWaitAnyTimeout(PDB_EVT_PE_MSG_RX | PDB_EVT_PE_RESET,
             PD_T_SENDER_RESPONSE);
     if (cfg->pe._min_power) {
         evt = chEvtWaitAnyTimeout(PDB_EVT_PE_MSG_RX | PDB_EVT_PE_RESET
                 | PDB_EVT_PE_I_OVRTEMP | PDB_EVT_PE_GET_SOURCE_CAP
-                | PDB_EVT_PE_NEW_POWER, PD_T_SINK_REQUEST);
+                | PDB_EVT_PE_NEW_POWER | PDB_EVT_PE_PPS_REQUEST,
+                PD_T_SINK_REQUEST);
     } else {
         evt = chEvtWaitAny(PDB_EVT_PE_MSG_RX | PDB_EVT_PE_RESET
                 | PDB_EVT_PE_I_OVRTEMP | PDB_EVT_PE_GET_SOURCE_CAP
-                | PDB_EVT_PE_NEW_POWER);
+                | PDB_EVT_PE_NEW_POWER | PDB_EVT_PE_PPS_REQUEST);
     }
 
     /* If we got reset signaling, transition to default */
         return PESinkEvalCap;
     }
 
+    /* If SinkPPSPeriodicTimer ran out, send a new request */
+    if (evt & PDB_EVT_PE_PPS_REQUEST) {
+        return PESinkSelectCap;
+    }
+
     /* If no event was received, the timer ran out. */
     if (evt == 0) {
         /* Repeat our Request message */
 
     /* Initialize the mailbox */
     chMBObjectInit(&cfg->pe.mailbox, cfg->pe._mailbox_queue, PDB_MSG_POOL_SIZE);
+    /* Initialize the VT for SinkPPSPeriodicTimer */
+    chVTObjectInit(&cfg->pe._sink_pps_periodic_timer);
     /* Initialize the old_tcc_match */
     cfg->pe._old_tcc_match = -1;
+    /* Initialize the pps_index */
+    cfg->pe._pps_index = 8;
     /* Initialize the PD message header template */
     cfg->pe.hdr_template = PD_DATAROLE_UFP | PD_POWERROLE_SINK;
 

lib/src/policy_engine.h

 #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)
 
 
 /*