Time out on chunked extended messages

Now when a part of a chunked extended message is received, the
ChunkingNotSupportedTimer is run.  When it times out, we transition to
PE_SNK_Send_Not_Supported.  Just like the spec says.

lib/include/pd.h

 #define PD_NUMOBJ_GET(msg) (((msg)->hdr & PD_HDR_NUMOBJ) >> PD_HDR_NUMOBJ_SHIFT)
 
 
+/*
+ * PD Extended Message Header
+ */
+#define PD_EXTHDR_DATA_SIZE_SHIFT 0
+#define PD_EXTHDR_DATA_SIZE (0x1FF << PD_EXTHDR_DATA_SIZE_SHIFT)
+#define PD_EXTHDR_REQUEST_CHUNK_SHIFT 10
+#define PD_EXTHDR_REQUEST_CHUNK (1 << PD_EXTHDR_REQUEST_CHUNK_SHIFT)
+#define PD_EXTHDR_CHUNK_NUMBER_SHIFT 11
+#define PD_EXTHDR_CHUNK_NUMBER (0xF << PD_EXTHDR_CHUNK_NUMBER_SHIFT)
+#define PD_EXTHDR_CHUNKED_SHIFT 15
+#define PD_EXTHDR_CHUNKED (1 << PD_EXTHDR_CHUNKED_SHIFT)
+
+/* Data size */
+#define PD_DATA_SIZE(n) (((n) << PD_EXTHDR_DATA_SIZE_SHIFT) & PD_EXTHDR_DATA_SIZE)
+#define PD_DATA_SIZE_GET(msg) (((msg)->exthdr & PD_EXTHDR_DATA_SIZE) >> PD_EXTHDR_DATA_SIZE_SHIFT)
+
+/* Chunk number */
+#define PD_CHUNK_NUMBER(n) (((n) << PD_EXTHDR_CHUNK_NUMBER_SHIFT) & PD_EXTHDR_CHUNK_NUMBER)
+#define PD_CHUNK_NUMBER_GET(msg) (((msg)->exthdr & PD_EXTHDR_CHUNK_NUMBER) >> PD_EXTHDR_CHUNK_NUMBER_SHIFT)
+
+
 /*
  * PD Power Data Object
  */
  * Where a range is specified, the middle of the range (rounded down to the
  * nearest millisecond) is used.
  */
+#define PD_T_CHUNKING_NOT_SUPPORTED MS2ST(45)
 #define PD_T_HARD_RESET_COMPLETE MS2ST(4)
 #define PD_T_PS_TRANSITION MS2ST(500)
 #define PD_T_SENDER_RESPONSE MS2ST(27)
 #define PD_N_HARD_RESET_COUNT 2
 
 
+/*
+ * Value parameters
+ */
+#define PD_MAX_EXT_MSG_LEN 260
+#define PD_MAX_EXT_MSG_CHUNK_LEN 26
+#define PD_MAX_EXT_MSG_LEGACY_LEN 26
+
+
 /*
  * Unit conversions
  *

lib/include/pdb_msg.h

 /*
  * PD message union
  *
- * This can be safely read from or written to in either form without any
+ * This can be safely read from or written to in any form without any
  * transformations because everything in the system is little-endian.
  *
  * Two bytes of padding are required at the start to prevent problems due to
     struct {
         uint8_t _pad2[2];
         uint16_t hdr;
-        uint32_t obj[7];
+        union {
+            uint32_t obj[7];
+            struct {
+                uint16_t exthdr;
+                uint8_t data[26];
+            };
+        };
     } __attribute__((packed));
 };
 

lib/src/policy_engine.c

     PESinkSoftReset,
     PESinkSendSoftReset,
     PESinkSendNotSupported,
+    PESinkChunkReceived,
     PESinkSourceUnresponsive
 };
 
                 chPoolFree(&pdb_msg_pool, cfg->pe._message);
                 cfg->pe._message = NULL;
                 return PESinkSoftReset;
-            /* If we got an unknown message, send a soft reset */
+            /* PD 3.0 messges */
+            } else if ((cfg->pe.hdr_template & PD_HDR_SPECREV) == PD_SPECREV_3_0) {
+                /* If the message is a multi-chunk extended message, let it
+                 * time out. */
+                if ((cfg->pe._message->hdr & PD_HDR_EXT)
+                        && (PD_DATA_SIZE_GET(cfg->pe._message) > PD_MAX_EXT_MSG_LEGACY_LEN)) {
+                    chPoolFree(&pdb_msg_pool, cfg->pe._message);
+                    cfg->pe._message = NULL;
+                    return PESinkChunkReceived;
+                /* If we got an unknown message, send a soft reset */
+                } else {
+                    chPoolFree(&pdb_msg_pool, cfg->pe._message);
+                    cfg->pe._message = NULL;
+                    return PESinkSendSoftReset;
+                }
+            /* If we got an unknown message, send a soft reset
+             *
+             * XXX I don't like that this is duplicated. */
             } else {
                 chPoolFree(&pdb_msg_pool, cfg->pe._message);
                 cfg->pe._message = NULL;
     return PESinkReady;
 }
 
+static enum policy_engine_state pe_sink_chunk_received(struct pdb_config *cfg)
+{
+    (void) cfg;
+
+    /* Wait for tChunkingNotSupported */
+    eventmask_t evt = chEvtWaitAnyTimeout(PDB_EVT_PE_RESET,
+            PD_T_CHUNKING_NOT_SUPPORTED);
+    /* If we got reset signaling, transition to default */
+    if (evt & PDB_EVT_PE_RESET) {
+        return PESinkTransitionDefault;
+    }
+
+    return PESinkSendNotSupported;
+}
+
 /*
  * When Power Delivery is unresponsive, fall back to Type-C Current
  */
             case PESinkSendNotSupported:
                 state = pe_sink_send_not_supported(cfg);
                 break;
+            case PESinkChunkReceived:
+                state = pe_sink_chunk_received(cfg);
+                break;
             case PESinkSourceUnresponsive:
                 state = pe_sink_source_unresponsive(cfg);
                 break;