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

This reverts commit ff93e56.

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,37 +38,35 @@
 
 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);
@@ -93,21 +91,8 @@ class TwoWire : public Stream
 
     inline void onService(void);
 
-#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;
+  private:
+    SERCOM *sercom;
     uint8_t _uc_pinSDA;
     uint8_t _uc_pinSCL;
 
@@ -117,7 +102,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;
@@ -130,12 +115,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);
 
@@ -151,22 +136,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)
@@ -176,9 +161,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);
@@ -212,7 +197,7 @@ inline void TwoWire::onService(void)
         err = SercomWireError::LENGTH_ERROR;
       if (busState == 0x0)
         err = SercomWireError::BUS_STATE_UNKNOWN;
-
+      
       sercom->clearINTFLAG();
       sercom->deferStopWIRE(err);
       return;
@@ -221,9 +206,9 @@ inline void TwoWire::onService(void)
     bool isRead = (txn->config & I2C_CFG_READ);
 
     if (sercom->getTxnIndexWIRE() < sercom->getTxnLengthWIRE()) {
-      bool more = isRead ? sercom->readDataWIRE() : sercom->sendDataWIRE();
+      isRead ? sercom->readDataWIRE() : sercom->sendDataWIRE();
       awaitingAddressAck = false;
-      if (!isRead || more) return;
+      return;
     }
 
     if ((txn->config & I2C_CFG_STOP) && !isRead)
@@ -259,7 +244,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))
     {
@@ -268,23 +253,24 @@ 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
@@ -302,12 +288,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
     }
 
@@ -317,7 +303,7 @@ inline void TwoWire::onService(void)
       isMasterRead ? sercom->sendDataWIRE() : sercom->readDataWIRE();
 
       if (!isMasterRead)
-        rxLength = sercom->getTxnIndexWIRE();
+        rxLength = sercom->getTxnIndexWIRE();      
     }
   }
 }