Reapply "allow readDataWIRE() to allow passing deferStopWIRE() on the final read."

This reverts commit 7f91df1.

Author: crabel99

libraries/Wire/Wire.h

@@ -27,7 +27,7 @@
 #include "RingBuffer.h"
 #include <stddef.h>
 
- // WIRE_HAS_END means Wire has end()
+// WIRE_HAS_END means Wire has end()
 #define WIRE_HAS_END 1
 
 // NOTE: SAMD21/SAMD51 silicon errata: when I2C master uses SCLSM=1, CTRLB.CMD
@@ -38,35 +38,37 @@
 
 class TwoWire : public Stream
 {
-  public:
-    TwoWire(SERCOM *s, uint8_t pinSDA, uint8_t pinSCL);
-    void begin();
-    void begin(uint8_t, bool enableGeneralCall = false);
-    void begin(uint16_t, bool enableGeneralCall, uint8_t speed = 0x0, bool enable10Bit = false);
-    void end();
-    void setClock(uint32_t);
-
-    void beginTransmission(uint8_t);
-    // If onComplete is nullptr, this blocks for legacy sync behavior.
-    // If onComplete is non-null, this enqueues and returns immediately (async).
-    uint8_t endTransmission(bool stopBit = true,
-                            void (*onComplete)(void *user, int status) = nullptr,
-                            void *user = nullptr);
-
-    // If onComplete is nullptr, this blocks for legacy sync behavior.
-    // If onComplete is non-null, this enqueues and returns immediately (async).
-    // If rxBuffer is nullptr, the internal buffer is used; otherwise rxBuffer is used.
-    uint8_t requestFrom(uint8_t address, size_t quantity, bool stopBit = true,
-                        uint8_t *rxBuffer = nullptr,
-                        void (*onComplete)(void *user, int status) = nullptr,
-                        void *user = nullptr);
-
-    size_t write(uint8_t data);
-    // 3-arg write: when setExternal=true, data is used directly (zero-copy) and
-    // quantity is treated as both length and capacity; subsequent write() calls return 0.
-    // For streaming > WIRE_BUFFER_LENGTH or async usage, call setTxBuffer() before write()
-    // on every transaction.
-    size_t write(const uint8_t *data, size_t quantity, bool setExternal = false);
+public:
+  TwoWire(SERCOM *s, uint8_t pinSDA, uint8_t pinSCL);
+  void begin();
+  void begin(uint8_t, bool enableGeneralCall = false);
+  void begin(uint16_t, bool enableGeneralCall, uint8_t speed = 0x0,
+             bool enable10Bit = false);
+  void end();
+  void setClock(uint32_t);
+
+  void beginTransmission(uint8_t);
+  // If onComplete is nullptr, this blocks for legacy sync behavior.
+  // If onComplete is non-null, this enqueues and returns immediately (async).
+  uint8_t endTransmission(bool stopBit = true,
+                          void (*onComplete)(void *user, int status) = nullptr,
+                          void *user = nullptr);
+
+  // If onComplete is nullptr, this blocks for legacy sync behavior.
+  // If onComplete is non-null, this enqueues and returns immediately (async).
+  // If rxBuffer is nullptr, the internal buffer is used; otherwise rxBuffer is
+  // used.
+  uint8_t requestFrom(uint8_t address, size_t quantity, bool stopBit = true,
+                      uint8_t *rxBuffer = nullptr,
+                      void (*onComplete)(void *user, int status) = nullptr,
+                      void *user = nullptr);
+
+  size_t write(uint8_t data);
+  // 3-arg write: when setExternal=true, data is used directly (zero-copy) and
+  // quantity is treated as both length and capacity; subsequent write() calls
+  // return 0. For streaming > WIRE_BUFFER_LENGTH or async usage, call
+  // setTxBuffer() before write() on every transaction.
+  size_t write(const uint8_t *data, size_t quantity, bool setExternal = false);
 
     virtual int available(void);
     virtual int read(void);
@@ -91,8 +93,21 @@ class TwoWire : public Stream
 
     inline void onService(void);
 
-  private:
-    SERCOM *sercom;
+#ifdef _DEBUG_
+  inline SercomTxn *getSlaveTxn(void) { return &slaveTxn; }
+  inline const SercomTxn *getSlaveTxn(void) const { return &slaveTxn; }
+  inline SercomTxn *getLoaderTxn(void) { return &loader; }
+  inline const SercomTxn *getLoaderTxn(void) const { return &loader; }
+  inline SercomTxn *getActiveTxn(void) {
+    return sercom ? sercom->getCurrentTxnWIRE() : nullptr;
+  }
+  inline const SercomTxn *getActiveTxn(void) const {
+    return sercom ? sercom->getCurrentTxnWIRE() : nullptr;
+  }
+#endif // _DEBUG_
+
+private:
+  SERCOM *sercom;
     uint8_t _uc_pinSDA;
     uint8_t _uc_pinSCL;
 
@@ -102,7 +117,7 @@ class TwoWire : public Stream
     static constexpr size_t WIRE_BUFFER_LENGTH = 255;
     uint8_t rxBuffer[WIRE_BUFFER_LENGTH];
     uint8_t txBuffer[WIRE_BUFFER_LENGTH];
-    uint8_t *rxBufferPtr;
+  uint8_t *rxBufferPtr;
     size_t rxBufferCapacity;
     size_t rxLength;
     size_t rxIndex;
@@ -115,12 +130,12 @@ class TwoWire : public Stream
     int pendingReceiveLength;
     SercomTxn slaveTxn;
     SercomTxn loader; // Staging area for building transactions
-    
+
     // Transaction pool for async operations (matches SERCOM queue depth)
     static constexpr size_t TXN_POOL_SIZE = 8;
     SercomTxn txnPool[TXN_POOL_SIZE];
     uint8_t txnPoolHead;
-    
+
     SercomTxn *allocateTxn();
     void freeTxn(SercomTxn *txn);
 
@@ -136,22 +151,22 @@ class TwoWire : public Stream
 };
 
 #if WIRE_INTERFACES_COUNT > 0
-  extern TwoWire Wire;
+extern TwoWire Wire;
 #endif
 #if WIRE_INTERFACES_COUNT > 1
-  extern TwoWire Wire1;
+extern TwoWire Wire1;
 #endif
 #if WIRE_INTERFACES_COUNT > 2
-  extern TwoWire Wire2;
+extern TwoWire Wire2;
 #endif
 #if WIRE_INTERFACES_COUNT > 3
-  extern TwoWire Wire3;
+extern TwoWire Wire3;
 #endif
 #if WIRE_INTERFACES_COUNT > 4
-  extern TwoWire Wire4;
+extern TwoWire Wire4;
 #endif
 #if WIRE_INTERFACES_COUNT > 5
-  extern TwoWire Wire5;
+extern TwoWire Wire5;
 #endif
 
 inline void TwoWire::onService(void)
@@ -161,9 +176,9 @@ inline void TwoWire::onService(void)
   bool isMaster = sercom->isMasterWIRE();
 
   if ((!isMaster && !sercom->isSlaveWIRE()) || flags == 0) {
-      sercom->clearINTFLAG();
-      return;
-    }
+    sercom->clearINTFLAG();
+    return;
+  }
 
   if (status & SERCOM_I2CM_STATUS_RXNACK) {
     sercom->prepareCommandBitsWIRE(WIRE_MASTER_ACT_STOP);
@@ -197,7 +212,7 @@ inline void TwoWire::onService(void)
         err = SercomWireError::LENGTH_ERROR;
       if (busState == 0x0)
         err = SercomWireError::BUS_STATE_UNKNOWN;
-      
+
       sercom->clearINTFLAG();
       sercom->deferStopWIRE(err);
       return;
@@ -206,9 +221,9 @@ inline void TwoWire::onService(void)
     bool isRead = (txn->config & I2C_CFG_READ);
 
     if (sercom->getTxnIndexWIRE() < sercom->getTxnLengthWIRE()) {
-      isRead ? sercom->readDataWIRE() : sercom->sendDataWIRE();
+      bool more = isRead ? sercom->readDataWIRE() : sercom->sendDataWIRE();
       awaitingAddressAck = false;
-      return;
+      if (!isRead || more) return;
     }
 
     if ((txn->config & I2C_CFG_STOP) && !isRead)
@@ -244,7 +259,7 @@ inline void TwoWire::onService(void)
     bool prec = (flags & SERCOM_I2CS_INTFLAG_PREC);        // Stop detected
     bool amatch = (flags & SERCOM_I2CS_INTFLAG_AMATCH);    // Address Match detected
     bool drdy = (flags & SERCOM_I2CS_INTFLAG_DRDY);        // Data Ready detected
-        
+
     // Stop or Restart detected - defer receive callback
     if (prec || (amatch && sr && !isMasterRead))
     {
@@ -253,24 +268,23 @@ inline void TwoWire::onService(void)
       sercom->deferReceiveWIRE(pendingReceiveLength);
       return;
     }
-    
+
     // Address Match - setup transaction
     // AACKEN enabled: address ACK is automatic, no manual ACK/clear needed
-    else if (amatch)
-    {
+    else if (amatch) {
       if (isMasterRead) // Master Read / Slave TX
       {
         // onRequestCallback runs in ISR context here. Deferring to PendSV
         // would require stalling DRDY or returning 0xFF until the buffer is filled.
         // onRequestCallback is what will set TwoWire::slaveTxn for the transaction.
         if (onRequestCallback)
           onRequestCallback();
-        
+
         // Ensure callback actually set slaveTxn.length; if not, stall with 0-length txn
-        if (slaveTxn.length == 0) 
+        if (slaveTxn.length == 0)
           return;
 
-        if (!(slaveTxn.config & I2C_CFG_READ)) 
+        if (!(slaveTxn.config & I2C_CFG_READ))
           slaveTxn.config |= I2C_CFG_READ;
       }
       else // Master Write / Slave RX
@@ -288,12 +302,12 @@ inline void TwoWire::onService(void)
 
       // SCLSM=0 (Smart Mode disabled): AMATCH and DRDY never fire together
       //   → return now, DRDY will fire in next interrupt
-      // SCLSM=1 (Smart Mode enabled) + Master Read: AMATCH+DRDY fire together  
+      // SCLSM=1 (Smart Mode enabled) + Master Read: AMATCH+DRDY fire together
       //   → fall through to handle data immediately
       // SCLSM=1 + Master Write: DRDY not set yet
       //   → return now, DRDY fires later
       if (!drdy)
-          return;
+        return;
       // else: DRDY is set (SCLSM=1 Master Read case), fall through
     }
 
@@ -303,7 +317,7 @@ inline void TwoWire::onService(void)
       isMasterRead ? sercom->sendDataWIRE() : sercom->readDataWIRE();
 
       if (!isMasterRead)
-        rxLength = sercom->getTxnIndexWIRE();      
+        rxLength = sercom->getTxnIndexWIRE();
     }
   }
 }