I'm using an ESP32-C3 SuperMini with a single SPI interface. I have two peripheral modules with different clock requirements (10MHz vs 50MHz). While I understand maintaining a lower frequency would allow shared configuration, one module requires higher frequency for reliable operation. The SpiDevice constructor only accepts SpiBus and CS parameters - what's the proper approach to implement two SpiDevice instances with distinct clock configurations?

```
//region SpiDmaBus
cfg_if::cfg_if! {
    if #[cfg(any(feature = "esp32", feature = "esp32s2"))] {
        let dma_channel = peripherals.DMA_SPI2;
    } else {
        let dma_channel = peripherals.DMA_CH0;
    }
}

let (rx_buffer, rx_descriptors, tx_buffer, tx_descriptors) = dma_buffers!(4096);
let dma_rx_buf = DmaRxBuf::new(rx_descriptors, rx_buffer).unwrap();
let dma_tx_buf = DmaTxBuf::new(tx_descriptors, tx_buffer).unwrap();

let mfrc522_spi_config = SpiConfig::default()
    .with_frequency(Rate::from_mhz(10))
    .with_mode(SpiMode::_0);

let flash_spi_config = SpiConfig::default()
    .with_frequency(Rate::from_mhz(50))
    .with_mode(SpiMode::_0);

let spi_dma_bus = Spi::new(peripherals.SPI2, SpiConfig::default())
    .unwrap()
    .with_mosi(peripherals.GPIO6)
    .with_miso(peripherals.GPIO5)
    .with_sck(peripherals.GPIO4)
    .with_dma(dma_channel)
    .with_buffers(dma_rx_buf, dma_tx_buf)
    .into_async();

static SPI_BUS: StaticCell<Spi1Bus> = StaticCell::new();
let spi_bus = SPI_BUS.init(Mutex::new(spi_dma_bus));
//endregion

//region Mfrc522
let mfrc522_cs = Output::new(peripherals.GPIO7, Level::High, OutputConfig::default());
let mfrc522_spi_device = SpiDevice::new(spi_bus, mfrc522_cs);
let mfrc522 = Mfrc522Driver::new(mfrc522_spi_device);
//endregion
```