Remove duplex type param

esp-hal/CHANGELOG.md

@@ -15,16 +15,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `AnyPin` now implements `From<GpioPin<N>>`. (#2326)
 - Added `AnySpi` and `AnySpiDmaChannel`. (#2334)
 - `Pins::steal()` to unsafely obtain GPIO. (#2335)
+- `Spi::half_duplex_read` and `Spi::half_duplex_write` (#2373)
 
 ### Changed
 
 - Peripheral type erasure for SPI (#2334)
+- The SPI driver has been rewritten to allow using half-duplex and full-duplex functionality on the same bus. See the migration guide for details. (#2373)
 
 ### Fixed
 
 ### Removed
 
 - The `i2s::{I2sWrite, I2sWriteDma, I2sRead, I2sReadDma, I2sWriteDmaAsync, I2sReadDmaAsync}` traits have been removed. (#2316)
+- The `spi::master::HalfDuplexReadWrite` trait has been removed. (#2373)
+- The `Spi::with_pins` methods have been removed. (#2373)
+- The `Spi::new_half_duplex` constructor have been removed. (#2373)
+- The `HalfDuplexMode` and `FullDuplexMode` parameters have been removed from `Spi`. (#2373)
 
 ## [0.21.1]
 

esp-hal/MIGRATING-0.21.md

@@ -45,3 +45,60 @@ the peripheral instance has been moved to the last generic parameter position.
 ```rust
 let spi: Spi<'static, FullDuplexMode, SPI2> = Spi::new_typed(peripherals.SPI2, 1.MHz(), SpiMode::Mode0);
 ```
+
+## Changes to half-duplex SPI
+
+The `HalfDuplexMode` and `FullDuplexMode` type parameters have been removed from SPI master and slave
+drivers. It is now possible to execute half-duplex and full-duplex operations on the same SPI bus.
+
+### Driver construction
+
+- The `Spi::new_half_duplex` constructor has been removed. Use `new` (or `new_typed`) instead.
+- The `with_pins` methods have been removed. Use the individual `with_*` functions instead.
+- The `with_mosi` and `with_miso` functions now take input-output peripheral signals to support half-duplex mode.
+  > TODO(danielb): this means they are currently only usable with GPIO pins, but upcoming GPIO changes should allow using any output signal.
+
+```diff
+- let mut spi = Spi::new_half_duplex(peripherals.SPI2, 100.kHz(), SpiMode::Mode0)
+-     .with_pins(sck, mosi, miso, sio2, sio3, cs);
++ let mut spi = Spi::new(peripherals.SPI2, 100.kHz(), SpiMode::Mode0)
++     .with_sck(sck)
++     .with_cs(cs)
++     .with_mosi(mosi)
++     .with_miso(miso)
++     .with_sio2(sio2)
++     .with_sio3(sio3);
+```
+
+### Transfer functions
+
+The `Spi<'_, SPI, HalfDuplexMode>::read` and `Spi<'_, SPI, HalfDuplexMode>::write` functions have been replaced by
+`half_duplex_read` and `half_duplex_write`.
+
+```diff
+ let mut data = [0u8; 2];
+ let transfer = spi
+-    .read(
++    .half_duplex_read(
+         SpiDataMode::Single,
+         Command::Command8(0x90, SpiDataMode::Single),
+         Address::Address24(0x000000, SpiDataMode::Single),
+         0,
+         &mut data,
+     )
+     .unwrap();
+
+ let transfer = spi
+-    .write(
++    .half_duplex_write(
+         SpiDataMode::Quad,
+         Command::Command8(write as u16, command_data_mode),
+         Address::Address24(
+             write as u32 | (write as u32) << 8 | (write as u32) << 16,
+             SpiDataMode::Quad,
+         ),
+         0,
+         dma_tx_buf,
+     )
+     .unwrap();
+```