I2S Pio on kb2040

[WMXZ-EU]

I try to get the following program to work (on Arduino)
`
pin_size_t _pinDOUT =0;
pin_size_t _pinBCLK =1;

int _freq=48000;
int _bps=32;
int off=0;

PIOProgram *_i2s;
PIO _pio;
int _sm;

#include "hardware/pio.h"

#define pio_i2s_in_wrap_target 0
#define pio_i2s_in_wrap 7

static const uint16_t pio_i2s_in_program_instructions[] = {
// .wrap_target
0xa022, // 0: mov x, y side 0
0x4801, // 1: in pins, 1 side 1
0x0041, // 2: jmp x--, 1 side 0
0x5801, // 3: in pins, 1 side 3
0xb022, // 4: mov x, y side 2
0x5801, // 5: in pins, 1 side 3
0x1045, // 6: jmp x--, 5 side 2
0x4801, // 7: in pins, 1 side 1
// .wrap
};

static const struct pio_program pio_i2s_in_program = {
.instructions = pio_i2s_in_program_instructions,
.length = 8,
.origin = -1,
};

static inline pio_sm_config pio_i2s_in_program_get_default_config(uint offset) {
pio_sm_config c = pio_get_default_sm_config();
sm_config_set_wrap(&c, offset + pio_i2s_in_wrap_target, offset + pio_i2s_in_wrap);
sm_config_set_sideset(&c, 2, false, false);
return c;
}

static inline void pio_i2s_in_program_init(PIO pio, uint sm, uint offset, uint data_pin, uint clock_pin_base, uint bits) {
pio_gpio_init(pio, data_pin);
pio_gpio_init(pio, clock_pin_base);
pio_gpio_init(pio, clock_pin_base + 1);
pio_sm_config sm_config = pio_i2s_in_program_get_default_config(offset);
sm_config_set_in_pins(&sm_config, data_pin);
sm_config_set_sideset_pins(&sm_config, clock_pin_base);
sm_config_set_in_shift(&sm_config, false, true, (bits <= 16) ? 2 * bits : bits);
sm_config_set_fifo_join(&sm_config, PIO_FIFO_JOIN_RX);
pio_sm_init(pio, sm, offset, &sm_config);
uint pin_mask = 3u << clock_pin_base;
pio_sm_set_pindirs_with_mask(pio, sm, pin_mask, pin_mask);
pio_sm_set_pins(pio, sm, 0); // clear pins
pio_sm_exec(pio, sm, pio_encode_set(pio_y, bits - 2));
}

void setup() {
// put your setup code here, to run once:

float bitClk = _freq * _bps * 2.0 /* channels */ * 2.0 /* edges per clock */;

_i2s = new PIOProgram( &pio_i2s_in_program);
_i2s->prepare(&_pio, &_sm, &off);

pio_i2s_in_program_init(_pio, _sm, off, _pinDOUT, _pinBCLK, _bps);
pio_sm_set_clkdiv(_pio, _sm, (float)clock_get_hz(clk_sys) / bitClk);

pio_sm_set_enabled(_pio, _sm, true);

}

void loop() {
// put your main code here, to run repeatedly:

}
`
what I expect is to see on pin1 and pin2 I2S bitclock and framesync.
bitclock remains high and framsync low

The code is an extraction of the example I2S library and needless to say I2SInput is working (I can see clock and framesync)

Intention here is ONLY to get the pio running.
I most likely miss something here. Do I need the dma to get the pio running?

Later I will add dma to fetch data.

Edit: seems that DMA is necessary, but why?

[WMXZ-EU]

For sake of completeness, here is the code that is running on kb2040
`
pin_size_t _pinDOUT =0;
pin_size_t _pinBCLK =1;

int _freq=48000;
int _bps=32;
int off=0;

PIOProgram *_i2s;
PIO _pio;
int _sm;

#include "hardware/pio.h"

#define pio_i2s_in_wrap_target 0
#define pio_i2s_in_wrap 7

static const uint16_t pio_i2s_in_program_instructions[] = {
// .wrap_target
0xa022, // 0: mov x, y side 0
0x4801, // 1: in pins, 1 side 1
0x0041, // 2: jmp x--, 1 side 0
0x5801, // 3: in pins, 1 side 3
0xb022, // 4: mov x, y side 2
0x5801, // 5: in pins, 1 side 3
0x1045, // 6: jmp x--, 5 side 2
0x4801, // 7: in pins, 1 side 1
// .wrap
};

static const struct pio_program pio_i2s_in_program = {
.instructions = pio_i2s_in_program_instructions,
.length = 8,
.origin = -1,
};

static inline pio_sm_config pio_i2s_in_program_get_default_config(uint offset) {
pio_sm_config c = pio_get_default_sm_config();
sm_config_set_wrap(&c, offset + pio_i2s_in_wrap_target, offset + pio_i2s_in_wrap);
sm_config_set_sideset(&c, 2, false, false);
return c;
}

static inline void pio_i2s_in_program_init(PIO pio, uint sm, uint offset, uint data_pin, uint clock_pin_base, uint bits) {
pio_gpio_init(pio, data_pin);
pio_gpio_init(pio, clock_pin_base);
pio_gpio_init(pio, clock_pin_base + 1);
pio_sm_config sm_config = pio_i2s_in_program_get_default_config(offset);
sm_config_set_in_pins(&sm_config, data_pin);
sm_config_set_sideset_pins(&sm_config, clock_pin_base);
sm_config_set_in_shift(&sm_config, false, true, (bits <= 16) ? 2 * bits : bits);
sm_config_set_fifo_join(&sm_config, PIO_FIFO_JOIN_RX);
pio_sm_init(pio, sm, offset, &sm_config);
uint pin_mask = 3u << clock_pin_base;
pio_sm_set_pindirs_with_mask(pio, sm, pin_mask, pin_mask);
pio_sm_set_pins(pio, sm, 0); // clear pins
pio_sm_exec(pio, sm, pio_encode_set(pio_y, bits - 2));
}

void i2s_setup(void)
{
float bitClk = _freq * _bps * 2.0 /* channels / * 2.0 / edges per clock */;

_i2s = new PIOProgram( &pio_i2s_in_program);
_i2s->prepare(&_pio, &_sm, &off);

pio_i2s_in_program_init(_pio, _sm, off, _pinDOUT, _pinBCLK, _bps);
pio_sm_set_clkdiv(_pio, _sm, (float)clock_get_hz(clk_sys) / bitClk);

pio_sm_set_enabled(_pio, _sm, true);
}
/***************************************************************************/
#include "hardware/dma.h"

#define NBUF 16
uint32_t i2s_buffer[2][NBUF];
int _channelDMA[2];
int _wordsPerBuffer=NBUF;

static void dma_irq(void)
{
for(int ii=0; ii<2; ii++)
if(dma_channel_get_irq0_status(_channelDMA[ii]))
{
dma_channel_set_write_addr(_channelDMA[ii], i2s_buffer[ii], false);
dma_channel_set_trans_count(_channelDMA[ii], _wordsPerBuffer, false);
dma_channel_acknowledge_irq0(_channelDMA[ii]);
}
}

void dma_setup(void)
{
for (auto ii = 0; ii < 2; ii++) _channelDMA[ii] = dma_claim_unused_channel(true);

int dreq = pio_get_dreq(_pio, _sm, false);
volatile void *pioFIFOAddr =(volatile void*)&_pio->rxf[_sm];

for (auto ii = 0; ii < 2; ii++) 
{  
  dma_channel_config c = dma_channel_get_default_config(_channelDMA[ii]);
  channel_config_set_transfer_data_size(&c, DMA_SIZE_32); // 16b/32b transfers into PIO FIFO
  channel_config_set_read_increment(&c, false); // Reading same FIFO address
  channel_config_set_write_increment(&c, true); // Writing to incrememting buffers

  channel_config_set_dreq(&c, dreq); // Wait for the PIO TX FIFO specified
  channel_config_set_chain_to(&c, _channelDMA[ii ^ 1]); // Start other channel when done
  channel_config_set_irq_quiet(&c, false); // Need IRQs

  dma_channel_configure(_channelDMA[ii], &c, i2s_buffer[ii], pioFIFOAddr, _wordsPerBuffer , false);

  dma_channel_set_irq0_enabled(_channelDMA[ii], true);
}

irq_add_shared_handler(DMA_IRQ_0, dma_irq, PICO_SHARED_IRQ_HANDLER_DEFAULT_ORDER_PRIORITY);
irq_set_enabled(DMA_IRQ_0, true);

dma_channel_start(_channelDMA[0]);

}
/***************************************************************************/

void setup() {
// put your setup code here, to run once:

while(!Serial);

i2s_setup();

dma_setup();
}

void loop() {
// put your main code here, to run repeatedly:
static uint32_t loopCount=0;
Serial.println(loopCount++);
delay(1000);
}
`

[earlephilhower]

One very simple reason would be the DMA not working. The I2S code does a PULL which will halt until there is data in the PIO TX FIFO. So if there's no FIFO data, there's no PIO progress and no waveforms output.

[WMXZ-EU]

Yes, I figured out , one needs DMA to free the FIFO (BTW, my code is RX no TX).