Transition to Sink Standby during voltage changes

When there is a positive or negative transition of Vbus, we Shall reduce
our power consumption to no more than 2.5 W beforehand.  This can be
easily achieved in all cases by simply turning off the output. This was
implemented, so that's one fewer Shall we aren't doing.

In the process, I made some API changes for the Device Policy Manager.
No more output_on() and output_off(), now it's output_set(true) and
output_set(false), plus a special case output_default() used during a
hard reset.  This much better matches how these functions are used by
the policy engine.

src/device_policy_manager.c

 /* Whether or not the power supply is unconstrained */
 static bool dpm_unconstrained_power;
 
+/* The last explicitly or implicitly negotiated voltage in PDV */
+static int dpm_present_voltage = PD_MV2PDV(5000);
+
+/* The requested voltage */
+static int dpm_requested_voltage;
+
 bool pdb_dpm_evaluate_capability(const union pd_msg *capabilities, union pd_msg *request)
 {
     /* Get the current configuration */
                 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;
+
                 return true;
             }
         }
         | PD_RDO_FV_CURRENT_SET(10)
         | PD_RDO_NO_USB_SUSPEND | PD_RDO_CAP_MISMATCH
         | PD_RDO_OBJPOS_SET(1);
+
+    /* Update requested voltage */
+    dpm_requested_voltage = PD_MV2PDV(5000);
+
     return false;
 }
 
         cfg_set = true;
     }
 
+    /* We don't control the voltage anymore; it will always be 5 V. */
+    dpm_requested_voltage = PD_MV2PDV(5000);
+
     /* If we have no configuration or don't want 5 V, Type-C Current can't
      * possibly satisfy our needs */
     if (cfg == NULL || cfg->v != 100) {
     chEvtSignal(pdb_led_thread, PDB_EVT_LED_FAST_BLINK);
 }
 
-void pdb_dpm_output_on(void)
+void pdb_dpm_sink_standby(void)
+{
+    /* If the voltage is changing, enter Sink Standby */
+    if (dpm_requested_voltage != dpm_present_voltage) {
+        /* For the PD Buddy Sink, entering Sink Standby is equivalent to
+         * turning the output off.  However, we don't want to change the LED
+         * state for standby mode. */
+        palClearLine(LINE_OUT_CTRL);
+    }
+}
+
+void pdb_dpm_output_set(bool state)
 {
-    chEvtSignal(pdb_led_thread, PDB_EVT_LED_MEDIUM_BLINK_OFF);
-    palSetLine(LINE_OUT_CTRL);
+    /* Update the present voltage */
+    dpm_present_voltage = dpm_requested_voltage;
+
+    /* Set the power output */
+    if (state) {
+        /* Turn the output on */
+        chEvtSignal(pdb_led_thread, PDB_EVT_LED_MEDIUM_BLINK_OFF);
+        palSetLine(LINE_OUT_CTRL);
+    } else {
+        /* Turn the output off */
+        chEvtSignal(pdb_led_thread, PDB_EVT_LED_ON);
+        palClearLine(LINE_OUT_CTRL);
+    }
 }
 
-void pdb_dpm_output_off(void)
+void pdb_dpm_output_default(void)
 {
-    chEvtSignal(pdb_led_thread, PDB_EVT_LED_ON);
-    palClearLine(LINE_OUT_CTRL);
+    /* Pretend we requested 5 V */
+    dpm_requested_voltage = PD_MV2PDV(5000);
+    /* Turn the output off */
+    pdb_dpm_output_set(false);
 }

src/device_policy_manager.h

 void pdb_dpm_pd_start(void);
 
 /*
- * Turn on the power output, with LED indication.
+ * Transition to Sink Standby if necessary.
  */
-void pdb_dpm_output_on(void);
+void pdb_dpm_sink_standby(void);
 
 /*
- * Turn off the power output, with LED indication.
+ * Set the output state, with LED indication.
  */
-void pdb_dpm_output_off(void);
+void pdb_dpm_output_set(bool state);
+
+/*
+ * Transition the sink to default power.
+ */
+void pdb_dpm_output_default(void);
 
 
 #endif /* PDB_DEVICE_POLICY_MANAGER_H */

src/policy_engine.c

         /* If the source accepted our request, wait for the new power */
         if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_ACCEPT
                 && PD_NUMOBJ_GET(policy_engine_message) == 0) {
+            /* Transition to Sink Standby if necessary */
+            pdb_dpm_sink_standby();
+
             chPoolFree(&pdb_msg_pool, policy_engine_message);
             policy_engine_message = NULL;
             return PESinkTransitionSink;
             explicit_contract = true;
 
             /* Set the output appropriately */
-            if (capability_match) {
-                pdb_dpm_output_on();
-            } else {
-                pdb_dpm_output_off();
-            }
+            pdb_dpm_output_set(capability_match);
 
             chPoolFree(&pdb_msg_pool, policy_engine_message);
             policy_engine_message = NULL;
             /* Turn off the power output before this hard reset to make sure we
              * don't supply an incorrect voltage to the device we're powering.
              */
-            pdb_dpm_output_off();
+            pdb_dpm_output_set(false);
 
             chPoolFree(&pdb_msg_pool, policy_engine_message);
             policy_engine_message = NULL;
 {
     explicit_contract = false;
 
-    /* Tell the DPM to turn off the output */
-    pdb_dpm_output_off();
+    /* Tell the DPM to transition to default power */
+    pdb_dpm_output_default();
 
     /* There is no local hardware to reset. */
     /* Since we never change our data role from UFP, there is no reason to set
 
     /* If the last two readings are the same, set the output */
     if (old_tcc_match == tcc_match) {
-        if (tcc_match) {
-            pdb_dpm_output_on();
-        } else {
-            pdb_dpm_output_off();
-        }
+        pdb_dpm_output_set(tcc_match);
     }
 
     /* Remember whether or not the last measurement succeeded */