STM32: SPI in slave mode with asynchronous API

[mczerski]

Hi everyone,

I don't know if it is a bug in STM32 SPI driver or I am missing something.
Does the spi_transceive_cb function should block ?

I have CONFIG_SPI_SLAVE=y and CONFIG_SPI_ASYNC=y, and example code below that blocks the main thread until first byte is received by the SPI peripheral. The call to spi_transceive_cb blocks in spi_ll_stm32.c in while loop while (!ret && spi_stm32_transfer_ongoing(data));. For me it looks like the driver does not support asynchronous mode properly.

#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/spi.h>

#define LED0_NODE DT_ALIAS(led0)

static const struct gpio_dt_spec led = GPIO_DT_SPEC_GET(LED0_NODE, gpios);

#define SPI_SLAVE  DT_ALIAS(spislave)
const struct device *const spi = DEVICE_DT_GET(SPI_SLAVE);

char rx_buf[4];
char tx_buf[4] = {0xDE, 0xAD, 0xBE, 0xEF};

struct spi_config config = {
    .frequency = 4000000,
    .operation = SPI_OP_MODE_SLAVE | SPI_MODE_CPHA 
    				| SPI_TRANSFER_MSB | SPI_WORD_SET(8) | SPI_LINES_SINGLE,
    .slave = 0,
};

struct spi_buf spi_rx_buf[] = {
    {
        .buf = rx_buf,
        .len = sizeof(rx_buf),
    },
};

struct spi_buf spi_tx_buf[] = {
    {
        .buf = tx_buf,
        .len = sizeof(tx_buf) / 2,
    },
    {
        .buf = tx_buf + sizeof(tx_buf) / 2,
        .len = sizeof(tx_buf) / 2,
    },
};

struct spi_buf_set rx_set = {
    .buffers = spi_rx_buf,
    .count = sizeof(spi_rx_buf) / sizeof(spi_rx_buf[0]),
};

struct spi_buf_set tx_set = {
    .buffers = spi_tx_buf,
    .count = sizeof(spi_tx_buf) / sizeof(spi_tx_buf[0]),
};

void spi_callback(const struct device *dev, int result, void *data) {
  //memcpy(tx_buf, rx_buf, sizeof(rx_buf));
  //gpio_pin_toggle_dt(&led);
}

int main(void) {
  printk("Hello World! %s\n", CONFIG_ARCH);

  if (!gpio_is_ready_dt(&led)) {
    printk("LED device not ready!\n");
    k_panic();
  }

  if (gpio_pin_configure_dt(&led, GPIO_OUTPUT_ACTIVE) < 0) {
    printk("LED configuration failed!\n");
    k_panic();
  }

  if(!device_is_ready(spi)) {
    printk("SPI slave device not ready!\n");
    k_panic();
  }

  spi_transceive_cb(spi, &config, &tx_set, &rx_set, spi_callback, NULL);
  while (1) {
    gpio_pin_toggle_dt(&led);
    k_sleep(K_MSEC(100));
  }
}

[mczerski]

It seems that this commit breaks asynchronous api. When using zephyr 4.0.0 there is no problem and async api do not block execution. In zephyr 4.1.0 async api block execution. And probably the issue does not affect only slave mode, but master mode also.
Cen someone confirm this is a bug before I report it ?

[AndrewCapon]

Hi @mczerski

I know this is bit old but did you get to the bottom of how to fix this behaviour?

Cheers

Andy

[gautierg-st]

Sorry for the (very) late reply, I have an on-going PR that should fix this: #103079, especially commit 9ad6e7a
Feel free to test and share your results.

[2ahunter]

My testing today suggests that it still isn't asynchronous. I toggle a gpio line before and after the call to spi_transceive_cb (blue trace) and show the clock for the spi (yellow) the call blocks until the spi transaction completes.
spi_async.pdf

[AndrewCapon]

Thanks for the info, no need to be sorry :)