Let I2C blocking methods wait until STOP is sent.

This commit brings back the while-loop waiting at the end of the
blocking read/write methods on I2C. The while-loop waiting is necessary
to ensure that the I2C interface has become idle before returning from
the blocking read/write methods.

As an example, the following code might break without the while-loop
waiting. Assuming that `handle` is a DMA handle to an I2C interface.
After the first write method returns, without the while-loop waiting,
the I2C interface can be generating the stop condition when the code
reaches the second `write` method, which then fails the busy test
`self.busy_res()?` and causes the second `write` to return `WouldBlock`.

```
handle.write(addr, buf); // Ok(())
handle.write(addr, buf); // Err(WouldBlock)
```

The added while-loop affects only the blocking methods and will not
affect the non-blocking methods with DMA.

Author: zyma98

src/i2c.rs

@@ -285,7 +285,12 @@ impl<I2C: Instance> I2c<I2C> {
     /// Sends START and Address for writing
     #[inline(always)]
     fn prepare_write(&self, addr: u8) -> Result<(), Error> {
-        // Wait until a previous STOP condition finishes
+        // Wait until a previous STOP condition finishes. When the previous
+        // STOP was generated inside an ISR (e.g. DMA interrupt handler),
+        // the ISR returns without waiting for the STOP condition to finish.
+        // It is possible that the STOP condition is still being generated
+        // when we reach here, so we wait until it finishes before proceeding
+        // to start a new transaction.
         while self.i2c.cr1.read().stop().bit_is_set() {}
 
         // Send a START condition
@@ -330,7 +335,12 @@ impl<I2C: Instance> I2c<I2C> {
 
     /// Sends START and Address for reading
     fn prepare_read(&self, addr: u8) -> Result<(), Error> {
-        // Wait until a previous STOP condition finishes
+        // Wait until a previous STOP condition finishes. When the previous
+        // STOP was generated inside an ISR (e.g. DMA interrupt handler),
+        // the ISR returns without waiting for the STOP condition to finish.
+        // It is possible that the STOP condition is still being generated
+        // when we reach here, so we wait until it finishes before proceeding
+        // to start a new transaction.
         while self.i2c.cr1.read().stop().bit_is_set() {}
 
         // Send a START condition and set ACK bit
@@ -449,6 +459,13 @@ impl<I2C: Instance> I2c<I2C> {
             // Receive last byte
             *last = self.recv_byte()?;
 
+            // Wait for the STOP to be sent. Otherwise, the interface will still be
+            // busy for a while after this function returns. Immediate following
+            // operations through the DMA handle might thus encounter `WouldBlock`
+            // error. Instead, we should make sure that the interface becomes idle
+            // before returning.
+            while self.i2c.cr1.read().stop().bit_is_set() {}
+
             // Fallthrough is success
             Ok(())
         } else {
@@ -468,6 +485,13 @@ impl<I2C: Instance> I2c<I2C> {
         // Send a STOP condition
         self.i2c.cr1.modify(|_, w| w.stop().set_bit());
 
+        // Wait for the STOP to be sent. Otherwise, the interface will still be
+        // busy for a while after this function returns. Immediate following
+        // operations through the DMA handle might thus encounter `WouldBlock`
+        // error. Instead, we should make sure that the interface becomes idle
+        // before returning.
+        while self.i2c.cr1.read().stop().bit_is_set() {}
+
         // Fallthrough is success
         Ok(())
     }
@@ -482,6 +506,13 @@ impl<I2C: Instance> I2c<I2C> {
         // Send a STOP condition
         self.i2c.cr1.modify(|_, w| w.stop().set_bit());
 
+        // Wait for the STOP to be sent. Otherwise, the interface will still be
+        // busy for a while after this function returns. Immediate following
+        // operations through the DMA handle might thus encounter `WouldBlock`
+        // error. Instead, we should make sure that the interface becomes idle
+        // before returning.
+        while self.i2c.cr1.read().stop().bit_is_set() {}
+
         // Fallthrough is success
         Ok(())
     }