---

static bool trigger_command(const struct device *i2s_dev_rx,
    const struct device *i2s_dev_tx,
    enum i2s_trigger_cmd cmd)
{
    int ret;

    if (i2s_dev_rx == i2s_dev_tx)
    {
        ret = i2s_trigger(i2s_dev_rx, I2S_DIR_BOTH, cmd);
        if (ret == 0)
        {
            return true;
        }
        /* -ENOSYS means that commands for the RX and TX streams need
        * to be triggered separately.
        */
        if (ret != -ENOSYS)
        {
            printk("Failed to trigger command %d: %d\n", cmd, ret);
            return false;
        }
    }

    ret = i2s_trigger(i2s_dev_rx, I2S_DIR_RX, cmd);
    if (ret < 0)
    {
        printk("Failed to trigger command %d on RX: %d\n", cmd, ret);
        return false;
    }

    ret = i2s_trigger(i2s_dev_tx, I2S_DIR_TX, cmd);
    if (ret < 0)
    {
        printk("Failed to trigger command %d on TX: %d\n", cmd, ret);
        return false;
    }

    return true;
}

int zephyr_i2s_start(uint8_t audio_in)
{
printf("%s(%d) audio_in=%d\n",__FUNCTION__,__LINE__,audio_in);
    if((i2s_dev_rx == i2s_dev_tx) && audio_in)
        return 0;
    if(!audio_in)
    {
        if (!prepare_transfer(i2s_dev_rx, i2s_dev_tx))
        {
            return -1;
        }
    }

    if (!trigger_command(i2s_dev_rx, i2s_dev_tx, I2S_TRIGGER_START))
    {
        return -1;
    }
    start_stream = 1;
    return 0;
}

int zephyr_i2s_stop(uint8_t audio_in)
{
printf("%s(%d) start_stream=%d\n",__FUNCTION__,__LINE__,start_stream);
    if(start_stream)
    {
        start_stream = 0;
        if (!trigger_command(i2s_dev_rx, i2s_dev_tx, I2S_TRIGGER_DROP))
        {
            return -1;
        }
    }
    return 0;
}

int zephyr_i2s_open_stream(I2S_Stream **stream, uint8_t *buf, uint8_t audio_in)
{
    struct i2s_strm *i2s_stream;
    int ret = 0;

    i2s_stream = i2s_str_alloc();
    if (!i2s_stream) {
        printf("Cannot allocate i2s_strm\n");
        return -1;
    }
    i2s_stream->devid = (audio_in) ? 1 : 2;
    i2s_stream->i2s_buf = buf;
    i2s_stream->state = I2S_STREAM_RUNNING;
    *stream = i2s_stream;
    pthread_attr_init(&i2s_stream->threadAttr);
    pthread_attr_setstacksize(&i2s_stream->threadAttr, 1024);
    ret = pthread_create(&i2s_stream->i2s_thread, &i2s_stream->threadAttr, audio_in ? i2s_thread_in : i2s_thread_out, i2s_stream);
    if (ret != 0) {
        printf("i2s pthread_create failed ret=%d\n",ret);
        ret = -1;
    }
    else
        ret = 0;
    pthread_setschedprio(i2s_stream->i2s_thread, I2S_THREAD_PRIORITY);
    if(audio_in)
        pthread_setname_np(i2s_stream->i2s_thread, "i2s_thread_in");
    else
        pthread_setname_np(i2s_stream->i2s_thread, "i2s_thread_out");
    return ret;
}

int zephyr_i2s_close_stream(I2S_Stream *stream)
{
    struct i2s_strm *i2s_stream = stream;

    i2s_thread_wakeup(i2s_stream, I2S_STREAM_CLOSED);
    /* Wait until thread finished and only after that free the stream */
    pthread_join(i2s_stream->i2s_thread, NULL);
    pthread_attr_destroy(&i2s_stream->threadAttr);
    i2s_str_free(i2s_stream);

    return paNoError;
}

int zephyr_i2s_audio_init(void)
{
    struct i2s_config config;

#if DT_NODE_HAS_STATUS(DT_NODELABEL(audio_codec), okay)
    const struct device *const codec_dev = DEVICE_DT_GET(DT_NODELABEL(audio_codec));
    struct audio_codec_cfg audio_cfg;

    audio_cfg.dai_route = AUDIO_ROUTE_PLAYBACK_CAPTURE;
    audio_cfg.dai_type = AUDIO_DAI_TYPE_I2S;
    audio_cfg.dai_cfg.i2s.word_size = SAMPLE_BIT_WIDTH;
    audio_cfg.dai_cfg.i2s.channels = NUMBER_OF_CHANNELS;
    audio_cfg.dai_cfg.i2s.format = I2S_FMT_DATA_FORMAT_I2S;
    audio_cfg.dai_cfg.i2s.options = I2S_OPT_FRAME_CLK_MASTER;
    audio_cfg.dai_cfg.i2s.frame_clk_freq = SAMPLE_FREQUENCY;
    audio_cfg.dai_cfg.i2s.mem_slab = &mem_slab;
    audio_cfg.dai_cfg.i2s.block_size = ZEPHYR_AUDIO_BLOCK_SIZE;

    audio_codec_configure(codec_dev, &audio_cfg);
    k_msleep(1000);
#else
    printf("No found audio_codec int DTS!!! Error\n");
    return -1;
#endif

    if (!device_is_ready(i2s_dev_rx))
    {
        printk("%s is not ready\n", i2s_dev_rx->name);
        return -1;
    }

    if (i2s_dev_rx != i2s_dev_tx && !device_is_ready(i2s_dev_tx))
    {
        printk("%s is not ready\n", i2s_dev_tx->name);
        return -1;
    }
    config.word_size = SAMPLE_BIT_WIDTH;
    config.channels = NUMBER_OF_CHANNELS;
    config.format = I2S_FMT_DATA_FORMAT_I2S;
    config.options = I2S_OPT_BIT_CLK_MASTER | I2S_OPT_FRAME_CLK_MASTER;
    config.frame_clk_freq = SAMPLE_FREQUENCY;
    config.mem_slab = &mem_slab;
    config.block_size = ZEPHYR_AUDIO_BLOCK_SIZE;
    config.timeout = TIMEOUT;
    if (!configure_streams(i2s_dev_rx, i2s_dev_tx, &config))
    {
        return -1;
    }
    return 0;
}

int zephyr_i2s_get_rate(void)
{
    return SAMPLE_FREQUENCY;
}

Исправь остальной код