Reference the PRLRX thread by the new struct

lib/src/hard_reset.c

 /*
  * PRL_HR_Reset_Layer state
  */
-static enum hardrst_state hardrst_reset_layer(void)
+static enum hardrst_state hardrst_reset_layer(struct pdb_config *cfg)
 {
     /* First, wait for the signal to run a hard reset. */
     eventmask_t evt = chEvtWaitAny(PDB_EVT_HARDRST_RESET
     pdb_prltx_messageidcounter = 0;
 
     /* Reset the Protocol RX machine */
-    chEvtSignal(pdb_prlrx_thread, PDB_EVT_PRLRX_RESET);
+    chEvtSignal(cfg->prl.rx_thread, PDB_EVT_PRLRX_RESET);
     chThdYield();
 
     /* Reset the Protocol TX machine */
     }
 }
 
-static enum hardrst_state hardrst_indicate_hard_reset(void)
+static enum hardrst_state hardrst_indicate_hard_reset(struct pdb_config *cfg)
 {
+    (void) cfg;
     /* Tell the PE that we're doing a hard reset */
     chEvtSignal(pdb_pe_thread, PDB_EVT_PE_RESET);
 
     return PRLHRWaitPE;
 }
 
-static enum hardrst_state hardrst_request_hard_reset(void)
+static enum hardrst_state hardrst_request_hard_reset(struct pdb_config *cfg)
 {
+    (void) cfg;
     /* Tell the PHY to send a hard reset */
     fusb_send_hardrst();
 
     return PRLHRWaitPHY;
 }
 
-static enum hardrst_state hardrst_wait_phy(void)
+static enum hardrst_state hardrst_wait_phy(struct pdb_config *cfg)
 {
+    (void) cfg;
     /* Wait for the PHY to tell us that it's done sending the hard reset */
     chEvtWaitAnyTimeout(PDB_EVT_HARDRST_I_HARDSENT, PD_T_HARD_RESET_COMPLETE);
 
     return PRLHRHardResetRequested;
 }
 
-static enum hardrst_state hardrst_hard_reset_requested(void)
+static enum hardrst_state hardrst_hard_reset_requested(struct pdb_config *cfg)
 {
+    (void) cfg;
     /* Tell the PE that the hard reset was sent */
     chEvtSignal(pdb_pe_thread, PDB_EVT_PE_HARD_SENT);
 
     return PRLHRWaitPE;
 }
 
-static enum hardrst_state hardrst_wait_pe(void)
+static enum hardrst_state hardrst_wait_pe(struct pdb_config *cfg)
 {
+    (void) cfg;
     /* Wait for the PE to tell us that it's done */
     chEvtWaitAny(PDB_EVT_HARDRST_DONE);
 
     return PRLHRComplete;
 }
 
-static enum hardrst_state hardrst_complete(void)
+static enum hardrst_state hardrst_complete(struct pdb_config *cfg)
 {
+    (void) cfg;
     /* I'm not aware of anything we have to tell the FUSB302B, so just finish
      * the reset routine. */
     return PRLHRResetLayer;
  * Hard Reset state machine thread
  */
 static THD_FUNCTION(HardReset, cfg) {
-    (void) cfg;
     enum hardrst_state state = PRLHRResetLayer;
 
     while (true) {
         switch (state) {
             case PRLHRResetLayer:
-                state = hardrst_reset_layer();
+                state = hardrst_reset_layer(cfg);
                 break;
             case PRLHRIndicateHardReset:
-                state = hardrst_indicate_hard_reset();
+                state = hardrst_indicate_hard_reset(cfg);
                 break;
             case PRLHRRequestHardReset:
-                state = hardrst_request_hard_reset();
+                state = hardrst_request_hard_reset(cfg);
                 break;
             case PRLHRWaitPHY:
-                state = hardrst_wait_phy();
+                state = hardrst_wait_phy(cfg);
                 break;
             case PRLHRHardResetRequested:
-                state = hardrst_hard_reset_requested();
+                state = hardrst_hard_reset_requested(cfg);
                 break;
             case PRLHRWaitPE:
-                state = hardrst_wait_pe();
+                state = hardrst_wait_pe(cfg);
                 break;
             case PRLHRComplete:
-                state = hardrst_complete();
+                state = hardrst_complete(cfg);
                 break;
             default:
                 /* This is an error.  It really shouldn't happen.  We might

lib/src/int_n.c

 
             /* If the I_GCRCSENT flag is set, tell the Protocol RX thread */
             if (status.interruptb & FUSB_INTERRUPTB_I_GCRCSENT) {
-                chEvtSignal(pdb_prlrx_thread, PDB_EVT_PRLRX_I_GCRCSENT);
+                chEvtSignal(cfg->prl.rx_thread, PDB_EVT_PRLRX_I_GCRCSENT);
             }
 
             /* If the I_TXSENT or I_RETRYFAIL flag is set, tell the Protocol TX

lib/src/protocol_rx.c

 #include "pd.h"
 
 
-thread_t *pdb_prlrx_thread;
-
 /*
  * Protocol RX machine states
  *
 
 void pdb_prlrx_run(struct pdb_config *cfg)
 {
-    pdb_prlrx_thread = chThdCreateStatic(cfg->prl._rx_wa,
+    cfg->prl.rx_thread = chThdCreateStatic(cfg->prl._rx_wa,
             sizeof(cfg->prl._rx_wa), PDB_PRIO_PRL, ProtocolRX, cfg);
 }

lib/src/protocol_rx.h

 #define PDB_EVT_PRLRX_RESET EVENT_MASK(0)
 #define PDB_EVT_PRLRX_I_GCRCSENT EVENT_MASK(1)
 
-/* The Protocol RX thread object */
-extern thread_t *pdb_prlrx_thread;
-
 /* The last received MessageID */
 extern int8_t pdb_prlrx_messageid;
 

lib/src/protocol_tx.c

 /*
  * PRL_Tx_PHY_Layer_Reset state
  */
-static enum protocol_tx_state protocol_tx_phy_reset(void)
+static enum protocol_tx_state protocol_tx_phy_reset(struct pdb_config *cfg)
 {
+    (void) cfg;
     /* Reset the PHY */
     fusb_reset();
 
 /*
  * PRL_Tx_Wait_for_Message_Request state
  */
-static enum protocol_tx_state protocol_tx_wait_message(void)
+static enum protocol_tx_state protocol_tx_wait_message(struct pdb_config *cfg)
 {
+    (void) cfg;
     /* Wait for an event */
     eventmask_t evt = chEvtWaitAny(PDB_EVT_PRLTX_RESET | PDB_EVT_PRLTX_DISCARD
             | PDB_EVT_PRLTX_MSG_TX);
     return PRLTxDiscardMessage;
 }
 
-static enum protocol_tx_state protocol_tx_reset(void)
+static enum protocol_tx_state protocol_tx_reset(struct pdb_config *cfg)
 {
     /* Clear MessageIDCounter */
     pdb_prltx_messageidcounter = 0;
 
     /* Tell the Protocol RX thread to reset */
-    chEvtSignal(pdb_prlrx_thread, PDB_EVT_PRLRX_RESET);
+    chEvtSignal(cfg->prl.rx_thread, PDB_EVT_PRLRX_RESET);
     chThdYield();
 
     return PRLTxConstructMessage;
 /*
  * PRL_Tx_Construct_Message state
  */
-static enum protocol_tx_state protocol_tx_construct_message(void)
+static enum protocol_tx_state protocol_tx_construct_message(struct pdb_config *cfg)
 {
+    (void) cfg;
     /* Make sure nobody wants us to reset */
     eventmask_t evt = chEvtGetAndClearEvents(PDB_EVT_PRLTX_RESET | PDB_EVT_PRLTX_DISCARD);
 
 /*
  * PRL_Tx_Wait_for_PHY_Response state
  */
-static enum protocol_tx_state protocol_tx_wait_response(void)
+static enum protocol_tx_state protocol_tx_wait_response(struct pdb_config *cfg)
 {
+    (void) cfg;
     /* Wait for an event.  There is no need to run CRCReceiveTimer, since the
      * FUSB302B handles that as part of its retry mechanism. */
     eventmask_t evt = chEvtWaitAny(PDB_EVT_PRLTX_RESET | PDB_EVT_PRLTX_DISCARD
 /*
  * PRL_Tx_Match_MessageID state
  */
-static enum protocol_tx_state protocol_tx_match_messageid(void)
+static enum protocol_tx_state protocol_tx_match_messageid(struct pdb_config *cfg)
 {
+    (void) cfg;
     union pd_msg goodcrc;
 
     /* Read the GoodCRC */
     }
 }
 
-static enum protocol_tx_state protocol_tx_transmission_error(void)
+static enum protocol_tx_state protocol_tx_transmission_error(struct pdb_config *cfg)
 {
+    (void) cfg;
     /* Increment MessageIDCounter */
     pdb_prltx_messageidcounter = (pdb_prltx_messageidcounter + 1) % 8;
 
     return PRLTxWaitMessage;
 }
 
-static enum protocol_tx_state protocol_tx_message_sent(void)
+static enum protocol_tx_state protocol_tx_message_sent(struct pdb_config *cfg)
 {
+    (void) cfg;
     /* Increment MessageIDCounter */
     pdb_prltx_messageidcounter = (pdb_prltx_messageidcounter + 1) % 8;
 
     return PRLTxWaitMessage;
 }
 
-static enum protocol_tx_state protocol_tx_discard_message(void)
+static enum protocol_tx_state protocol_tx_discard_message(struct pdb_config *cfg)
 {
+    (void) cfg;
     /* If we were working on sending a message, increment MessageIDCounter */
     if (protocol_tx_message != NULL) {
         pdb_prltx_messageidcounter = (pdb_prltx_messageidcounter + 1) % 8;
  * Protocol layer TX state machine thread
  */
 static THD_FUNCTION(ProtocolTX, cfg) {
-    (void) cfg;
 
     enum protocol_tx_state state = PRLTxPHYReset;
 
     while (true) {
         switch (state) {
             case PRLTxPHYReset:
-                state = protocol_tx_phy_reset();
+                state = protocol_tx_phy_reset(cfg);
                 break;
             case PRLTxWaitMessage:
-                state = protocol_tx_wait_message();
+                state = protocol_tx_wait_message(cfg);
                 break;
             case PRLTxReset:
-                state = protocol_tx_reset();
+                state = protocol_tx_reset(cfg);
                 break;
             case PRLTxConstructMessage:
-                state = protocol_tx_construct_message();
+                state = protocol_tx_construct_message(cfg);
                 break;
             case PRLTxWaitResponse:
-                state = protocol_tx_wait_response();
+                state = protocol_tx_wait_response(cfg);
                 break;
             case PRLTxMatchMessageID:
-                state = protocol_tx_match_messageid();
+                state = protocol_tx_match_messageid(cfg);
                 break;
             case PRLTxTransmissionError:
-                state = protocol_tx_transmission_error();
+                state = protocol_tx_transmission_error(cfg);
                 break;
             case PRLTxMessageSent:
-                state = protocol_tx_message_sent();
+                state = protocol_tx_message_sent(cfg);
                 break;
             case PRLTxDiscardMessage:
-                state = protocol_tx_discard_message();
+                state = protocol_tx_discard_message(cfg);
                 break;
             default:
                 /* This is an error.  It really shouldn't happen.  We might