Support Type-C Current as a fallback

Type-C Current is a mechanism defined in the USB Type-C spec for
indicating high-current modes at 5 V using nothing other than a voltage
on the CC line.  The FUSB302B maps the voltage to one of the four ranges
we care about, so it's easy to see if 1.5 A or 3 A is available at 5 V
even in systems that don't support PD.

Now, when the PD Buddy Sink is connected to a system without Power
Delivery support, after all attempts at PD communications fail, it falls
back to Type-C Current.  If the Sink is configured for 5 V, it will
monitor the CC line's voltage to see if enough Type-C Current is
available.  If so, the output is turned on.

src/device_policy_manager.c

 #include "led.h"
 #include "storage.h"
 #include "pd.h"
+#include "fusb302b.h"
 
 
 /* Whether or not the power supply is unconstrained */
         | PD_POWERROLE_SINK | PD_NUMOBJ(numobj);
 }
 
+bool pdb_dpm_evaluate_typec_current(void)
+{
+    /* Get the current configuration */
+    struct pdb_config *cfg = pdb_config_flash_read();
+
+    /* 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) {
+        return false;
+    }
+
+    /* Get the present Type-C Current advertisement */
+    enum fusb_typec_current tcc = fusb_get_typec_current();
+
+    /* If 1.5 A is available and we want no more than that, great. */
+    if (tcc == OnePointFiveAmps && cfg->i <= 150) {
+        return true;
+    }
+    /* If 3 A is available and we want no more than that, that's great too. */
+    if (tcc == ThreePointZeroAmps && cfg->i <= 300) {
+        return true;
+    }
+    /* We're overly cautious if USB default current is available, since that
+     * could mean different things depending on the port we're connected to,
+     * and since we're really supposed to enumerate in order to request more
+     * than 100 mA.  This could be changed in the future. */
+
+    return false;
+}
+
 void pdb_dpm_pd_start(void)
 {
     chEvtSignal(pdb_led_thread, PDB_EVT_LED_FAST_BLINK);

src/device_policy_manager.h

 /*
  * Create a Request message based on the given Source_Capabilities message.
  *
- * Returns false if sufficient power is not available, true if it is.
+ * Returns true if sufficient power is available, false otherwise.
  */
 bool pdb_dpm_evaluate_capability(const union pd_msg *capabilities, union pd_msg *request);
 
  */
 void pdb_dpm_get_sink_capability(union pd_msg *cap);
 
+/*
+ * Evaluate whether or not the currently offered Type-C Current can fulfill our
+ * power needs.
+ *
+ * Returns true if sufficient power is available, false otherwise.
+ */
+bool pdb_dpm_evaluate_typec_current(void);
+
 /*
  * Indicate that power negotiations are starting.
  */

src/fusb302b.c

     i2cReleaseBus(&I2CD2);
 }
 
+enum fusb_typec_current fusb_get_typec_current(void)
+{
+    i2cAcquireBus(&I2CD2);
+
+    /* Read the BC_LVL into a variable */
+    enum fusb_typec_current bc_lvl = fusb_read_byte(FUSB_STATUS0)
+        & FUSB_STATUS0_BC_LVL;
+
+    i2cReleaseBus(&I2CD2);
+
+    return bc_lvl;
+}
+
 void fusb_reset(void)
 {
     i2cAcquireBus(&I2CD2);

src/fusb302b.h

     };
 };
 
+/*
+ * FUSB Type-C Current level enum
+ */
+enum fusb_typec_current {
+    None = 0,
+    Default = 1,
+    OnePointFiveAmps = 2,
+    ThreePointZeroAmps = 3
+};
+
 
 /* FUSB functions */
 
  */
 void fusb_get_status(union fusb_status *status);
 
+/*
+ * Read the FUSB302B BC_LVL as an enum fusb_typec_current
+ */
+enum fusb_typec_current fusb_get_typec_current(void);
+
 /*
  * Initialization routine for the FUSB302B
  */

src/pd.h

 #define PD_T_PS_TRANSITION MS2ST(500)
 #define PD_T_SENDER_RESPONSE MS2ST(27)
 #define PD_T_TYPEC_SINK_WAIT_CAP MS2ST(465)
+/* This is actually a Type-C time value, not a Power Delivery time value, but
+ * who cares? */
+#define PD_T_PD_DEBOUNCE MS2ST(15)
 
 
 /*

src/policy_engine.c

     PESinkTransitionDefault,
     PESinkSoftReset,
     PESinkSendSoftReset,
-    PESinkSendReject
+    PESinkSendReject,
+    PESinkSourceUnresponsive
 };
 
 /* The received message we're currently working with */
 
 static enum policy_engine_state pe_sink_hard_reset(void)
 {
-    /* If we've already sent the maximum number of hard resets, give up */
+    /* If we've already sent the maximum number of hard resets, assume the
+     * source is unresponsive. */
     if (hard_reset_counter > PD_N_HARD_RESET_COUNT) {
-        pdb_dpm_output_off();
-        /* TODO: Fall back to Type-C Current if configured for 5 V. */
-        while (true) {
-            chThdSleepMilliseconds(1000);
-        }
+        return PESinkSourceUnresponsive;
     }
 
     /* Generate a hard reset signal */
     return PESinkReady;
 }
 
+/*
+ * When Power Delivery is unresponsive, fall back to Type-C Current
+ */
+static enum policy_engine_state pe_sink_source_unresponsive(void)
+{
+    static int old_tcc_match = -1;
+    int tcc_match = pdb_dpm_evaluate_typec_current();
+
+    /* 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();
+        }
+    }
+
+    /* Remember whether or not the last measurement succeeded */
+    old_tcc_match = tcc_match;
+
+    /* Wait tPDDebounce between measurements */
+    chThdSleep(PD_T_PD_DEBOUNCE);
+
+    return PESinkSourceUnresponsive;
+}
+
 /*
  * Policy Engine state machine thread
  */
             case PESinkSendReject:
                 state = pe_sink_send_reject();
                 break;
+            case PESinkSourceUnresponsive:
+                state = pe_sink_source_unresponsive();
+                break;
             default:
                 /* This is an error.  It really shouldn't happen.  We might
                  * want to handle it anyway, though. */