Add support for GiveBack

Now we correctly set the GiveBack flag and minimum current fields in the
Request message when GiveBack is enabled.  Also when GiveBack is
enabled, we correctly handle GotoMin messages by lowering our power
consumption, completing negotiation, and Requesting our normal power
periodically until the power supply Accepts our Request.

At least, I believe it's correct.  I don't have any hardware that sends
GotoMin messages, so I can't test it other than that it doesn't break
anything with the GiveBack flag set to 1 or 0 when the source doesn't
ask to reduce power.

src/device_policy_manager.c

@@ -66,9 +66,18 @@ bool pdb_dpm_evaluate_capability(const union pd_msg *capabilities, union pd_msg
                 /* We got what we wanted, so build a request for that */
                 request->hdr = PD_MSGTYPE_REQUEST | PD_DATAROLE_UFP |
                     PD_SPECREV_2_0 | PD_POWERROLE_SINK | PD_NUMOBJ(1);
-                request->obj[0] = PD_RDO_FV_MAX_CURRENT_SET(cfg->i)
-                    | PD_RDO_FV_CURRENT_SET(cfg->i)
-                    | PD_RDO_NO_USB_SUSPEND | PD_RDO_OBJPOS_SET(i + 1);
+                if (cfg->flags & PDB_CONFIG_FLAGS_GIVEBACK) {
+                    /* GiveBack enabled */
+                    request->obj[0] = PD_RDO_FV_MIN_CURRENT_SET(10)
+                        | PD_RDO_FV_CURRENT_SET(cfg->i)
+                        | 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(cfg->i)
+                        | PD_RDO_FV_CURRENT_SET(cfg->i)
+                        | PD_RDO_NO_USB_SUSPEND | PD_RDO_OBJPOS_SET(i + 1);
+                }
 
                 /* Update requested voltage */
                 dpm_requested_voltage = cfg->v;
@@ -77,7 +86,7 @@ bool pdb_dpm_evaluate_capability(const union pd_msg *capabilities, union pd_msg
             }
         }
     }
-    /* Nothing matched (or no configuration), so get 5 V */
+    /* Nothing matched (or no configuration), so get 5 V at low current */
     request->hdr = PD_MSGTYPE_REQUEST | PD_DATAROLE_UFP |
         PD_SPECREV_2_0 | PD_POWERROLE_SINK | PD_NUMOBJ(1);
     request->obj[0] = PD_RDO_FV_MAX_CURRENT_SET(10)

src/policy_engine.c

@@ -56,6 +56,8 @@ static union pd_msg *last_dpm_request = NULL;
 static bool capability_match = false;
 /* Whether or not we have an explicit contract */
 static bool explicit_contract = false;
+/* Whether or not we're receiving minimum power*/
+static bool min_power = false;
 /* Keep track of how many hard resets we've sent */
 static int hard_reset_counter = 0;
 /* Policy Engine thread mailbox */
@@ -183,6 +185,8 @@ static enum policy_engine_state pe_sink_select_cap(void)
             /* Transition to Sink Standby if necessary */
             pdb_dpm_sink_standby();
 
+            min_power = false;
+
             chPoolFree(&pdb_msg_pool, policy_engine_message);
             policy_engine_message = NULL;
             return PESinkTransitionSink;
@@ -203,9 +207,10 @@ static enum policy_engine_state pe_sink_select_cap(void)
                 return PESinkWaitCap;
             /* If we do have an explicit contract, go to the ready state */
             } else {
-                /* TODO: we should take note if we got here from a Wait
-                 * message, because we Should run the SinkRequestTimer in the
-                 * Ready state if that's the case. */
+                /* If we got here from a Wait message, we Should run
+                 * SinkRequestTimer in the Ready state. */
+                min_power = (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_WAIT);
+
                 chPoolFree(&pdb_msg_pool, policy_engine_message);
                 policy_engine_message = NULL;
                 return PESinkReady;
@@ -242,7 +247,7 @@ static enum policy_engine_state pe_sink_transition_sink(void)
             explicit_contract = true;
 
             /* Set the output appropriately */
-            pdb_dpm_output_set(capability_match);
+            pdb_dpm_output_set(capability_match && !min_power);
 
             chPoolFree(&pdb_msg_pool, policy_engine_message);
             policy_engine_message = NULL;
@@ -265,9 +270,16 @@ static enum policy_engine_state pe_sink_transition_sink(void)
 
 static enum policy_engine_state pe_sink_ready(void)
 {
+    eventmask_t evt;
+
     /* Wait for an event */
-    eventmask_t evt = chEvtWaitAny(PDB_EVT_PE_MSG_RX | PDB_EVT_PE_RESET
-            | PDB_EVT_PE_I_OVRTEMP);
+    if (min_power) {
+        evt = chEvtWaitAnyTimeout(PDB_EVT_PE_MSG_RX | PDB_EVT_PE_RESET
+                | PDB_EVT_PE_I_OVRTEMP, PD_T_SINK_REQUEST);
+    } else {
+        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) {
@@ -279,6 +291,12 @@ static enum policy_engine_state pe_sink_ready(void)
         return PESinkHardReset;
     }
 
+    /* If no event was received, the timer ran out. */
+    if (evt == 0) {
+        /* Repeat our Request message */
+        return PESinkSelectCap;
+    }
+
     /* 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) {
@@ -330,14 +348,23 @@ static enum policy_engine_state pe_sink_ready(void)
                 chPoolFree(&pdb_msg_pool, policy_engine_message);
                 policy_engine_message = NULL;
                 return PESinkSendReject;
-            /* Reject GotoMin messages
-             * Until we actually support GiveBack, this is the correct
-             * behavior according to S. 6.3.4 */
+            /* Handle GotoMin messages */
             } else if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_GOTOMIN
                     && PD_NUMOBJ_GET(policy_engine_message) == 0) {
-                chPoolFree(&pdb_msg_pool, policy_engine_message);
-                policy_engine_message = NULL;
-                return PESinkSendReject;
+                if (pdb_dpm_giveback_enabled()) {
+                    /* We support GiveBack, so go to minimum power */
+                    pdb_dpm_output_set(false);
+                    min_power = true;
+
+                    chPoolFree(&pdb_msg_pool, policy_engine_message);
+                    policy_engine_message = NULL;
+                    return PESinkTransitionSink;
+                } else {
+                    /* We don't support GiveBack, so send a Reject */
+                    chPoolFree(&pdb_msg_pool, policy_engine_message);
+                    policy_engine_message = NULL;
+                    return PESinkSendReject;
+                }
             /* Evaluate new Source_Capabilities */
             } else if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_SOURCE_CAPABILITIES
                     && PD_NUMOBJ_GET(policy_engine_message) > 0) {