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

                 /* 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;
             }
         }
     }
-    /* 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

 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 */
             /* 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;
                 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;
             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;
 
 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) {
         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) {
                 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) {