michaelh/zephyr
1
0
Fork 0
Code Releases Activity

tests: i2s: Update i2s_api test

Browse source 
1. Provide an option to loopback over separate I2S ports
2. Increase the buffer count in the loopback test to 4
3. Update test_i2s_transfer_rx_overrun test on how to
   handle RX overrun failures

Signed-off-by: Mahesh Mahadevan <mahesh.mahadevan@nxp.com>
This commit is contained in:
Mahesh Mahadevan 2020-11-13 07:04:31 -06:00 • committed by Maureen Helm
commit 3df8733276
6 changed files with 289 additions and 201 deletions
Download patch file Download diff file Expand all files Collapse all files

14
tests/drivers/i2s/i2s_api/Kconfig Normal file
View file

@ -0,0 +1,14 @@
#
# Copyright (c) 2021, NXP
#
# SPDX-License-Identifier: Apache-2.0
#
mainmenu "I2S Loopback Test"
source "Kconfig.zephyr"
config I2S_TEST_SEPARATE_DEVICES
bool "Use two separate I2S ports for loopback"
help
Use separate I2S ports for transmit and receive.

7
tests/drivers/i2s/i2s_api/boards/mimxrt685_evk_cm33.conf Normal file
View file

@ -0,0 +1,7 @@
#
# Copyright (c) 2021, NXP
#
# SPDX-License-Identifier: Apache-2.0
#
CONFIG_I2S_TEST_SEPARATE_DEVICES=y

7
tests/drivers/i2s/i2s_api/src/i2s_api_test.h
View file

@ -40,7 +40,12 @@ extern struct k_mem_slab tx_1_mem_slab;
extern int16_t data_l[SAMPLE_NO];
extern int16_t data_r[SAMPLE_NO];
#define I2S_DEV_NAME "I2S_0"
#define I2S_DEV_NAME_RX "I2S_0"
#ifdef CONFIG_I2S_TEST_SEPARATE_DEVICES
#define I2S_DEV_NAME_TX "I2S_1"
#else
#define I2S_DEV_NAME_TX "I2S_0"
#endif
#define BLOCK_SIZE (2 * sizeof(data_l))
int rx_block_read_slab(const struct device *dev_i2s, int att,

14
tests/drivers/i2s/i2s_api/src/main.c
View file

@ -12,14 +12,20 @@
void test_main(void)
{
const struct device *dev_i2s;
const struct device *dev_i2s_rx;
const struct device *dev_i2s_tx;
k_thread_access_grant(k_current_get(),
&rx_0_mem_slab, &tx_0_mem_slab,
&rx_1_mem_slab, &tx_1_mem_slab);
dev_i2s = device_get_binding(I2S_DEV_NAME);
if (dev_i2s != NULL) {
k_object_access_grant(dev_i2s, k_current_get());
dev_i2s_rx = device_get_binding(I2S_DEV_NAME_RX);
if (dev_i2s_rx != NULL) {
k_object_access_grant(dev_i2s_rx, k_current_get());
}
dev_i2s_tx = device_get_binding(I2S_DEV_NAME_TX);
if (dev_i2s_tx != NULL) {
k_object_access_grant(dev_i2s_tx, k_current_get());
}
ztest_test_suite(i2s_loopback_test,

234
tests/drivers/i2s/i2s_api/src/test_i2s_loopback.c
View file

@ -10,8 +10,8 @@
#include <drivers/i2s.h>
#include "i2s_api_test.h"
#define NUM_RX_BLOCKS 2
#define NUM_TX_BLOCKS 2
#define NUM_RX_BLOCKS 4
#define NUM_TX_BLOCKS 4
K_MEM_SLAB_DEFINE(rx_0_mem_slab, BLOCK_SIZE, NUM_RX_BLOCKS, 32);
K_MEM_SLAB_DEFINE(tx_0_mem_slab, BLOCK_SIZE, NUM_TX_BLOCKS, 32);
@ -31,20 +31,21 @@ void test_i2s_tx_transfer_configure_0(void)
struct i2s_config i2s_cfg;
int ret;
dev_i2s = device_get_binding(I2S_DEV_NAME);
zassert_not_null(dev_i2s, "device " I2S_DEV_NAME " not found");
dev_i2s = device_get_binding(I2S_DEV_NAME_TX);
zassert_not_null(dev_i2s, "device " I2S_DEV_NAME_TX " not found");
/* Configure */
i2s_cfg.word_size = 16U;
i2s_cfg.channels = 2U;
i2s_cfg.format = I2S_FMT_DATA_FORMAT_I2S;
i2s_cfg.options = I2S_OPT_FRAME_CLK_SLAVE | I2S_OPT_BIT_CLK_SLAVE;
/* Configure the Transmit port as Master */
i2s_cfg.options = I2S_OPT_FRAME_CLK_MASTER | I2S_OPT_BIT_CLK_MASTER;
i2s_cfg.frame_clk_freq = FRAME_CLK_FREQ;
i2s_cfg.block_size = BLOCK_SIZE;
i2s_cfg.mem_slab = &tx_0_mem_slab;
i2s_cfg.timeout = TIMEOUT;
i2s_cfg.options = I2S_OPT_LOOPBACK;
i2s_cfg.options |= I2S_OPT_LOOPBACK;
ret = i2s_configure(dev_i2s, I2S_DIR_TX, &i2s_cfg);
zassert_equal(ret, 0, "Failed to configure I2S TX stream");
@ -57,20 +58,21 @@ void test_i2s_rx_transfer_configure_0(void)
struct i2s_config i2s_cfg;
int ret;
dev_i2s = device_get_binding(I2S_DEV_NAME);
zassert_not_null(dev_i2s, "device " I2S_DEV_NAME " not found");
dev_i2s = device_get_binding(I2S_DEV_NAME_RX);
zassert_not_null(dev_i2s, "device " I2S_DEV_NAME_RX " not found");
/* Configure */
i2s_cfg.word_size = 16U;
i2s_cfg.channels = 2U;
i2s_cfg.format = I2S_FMT_DATA_FORMAT_I2S;
/* Configure the Receive port as Slave */
i2s_cfg.options = I2S_OPT_FRAME_CLK_SLAVE | I2S_OPT_BIT_CLK_SLAVE;
i2s_cfg.frame_clk_freq = FRAME_CLK_FREQ;
i2s_cfg.block_size = BLOCK_SIZE;
i2s_cfg.mem_slab = &rx_0_mem_slab;
i2s_cfg.timeout = TIMEOUT;
i2s_cfg.options = I2S_OPT_LOOPBACK;
i2s_cfg.options |= I2S_OPT_LOOPBACK;
ret = i2s_configure(dev_i2s, I2S_DIR_RX, &i2s_cfg);
zassert_equal(ret, 0, "Failed to configure I2S RX stream");
@ -86,50 +88,54 @@ void test_i2s_rx_transfer_configure_0(void)
*/
void test_i2s_transfer_short(void)
{
const struct device *dev_i2s;
const struct device *dev_i2s_rx;
const struct device *dev_i2s_tx;
int ret;
dev_i2s = device_get_binding(I2S_DEV_NAME);
zassert_not_null(dev_i2s, "device " I2S_DEV_NAME " not found");
dev_i2s_rx = device_get_binding(I2S_DEV_NAME_RX);
zassert_not_null(dev_i2s_rx, "device " I2S_DEV_NAME_RX " not found");
dev_i2s_tx = device_get_binding(I2S_DEV_NAME_TX);
zassert_not_null(dev_i2s_tx, "device " I2S_DEV_NAME_TX " not found");
/* Prefill TX queue */
ret = tx_block_write(dev_i2s, 0, 0);
ret = tx_block_write(dev_i2s_tx, 0, 0);
zassert_equal(ret, TC_PASS, NULL);
TC_PRINT("%d->OK\n", 1);
ret = tx_block_write(dev_i2s, 1, 0);
ret = tx_block_write(dev_i2s_tx, 1, 0);
zassert_equal(ret, TC_PASS, NULL);
TC_PRINT("%d->OK\n", 2);
/* Start reception */
ret = i2s_trigger(dev_i2s, I2S_DIR_RX, I2S_TRIGGER_START);
ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_START);
zassert_equal(ret, 0, "RX START trigger failed");
/* Start transmission */
ret = i2s_trigger(dev_i2s, I2S_DIR_TX, I2S_TRIGGER_START);
ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_START);
zassert_equal(ret, 0, "TX START trigger failed");
ret = rx_block_read(dev_i2s, 0);
ret = rx_block_read(dev_i2s_rx, 0);
zassert_equal(ret, TC_PASS, NULL);
TC_PRINT("%d<-OK\n", 1);
ret = tx_block_write(dev_i2s, 2, 0);
ret = tx_block_write(dev_i2s_tx, 2, 0);
zassert_equal(ret, TC_PASS, NULL);
TC_PRINT("%d->OK\n", 3);
/* All data written, drain TX queue and stop the transmission */
ret = i2s_trigger(dev_i2s, I2S_DIR_TX, I2S_TRIGGER_DRAIN);
ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_DRAIN);
zassert_equal(ret, 0, "TX DRAIN trigger failed");
ret = rx_block_read(dev_i2s, 1);
ret = rx_block_read(dev_i2s_rx, 1);
zassert_equal(ret, TC_PASS, NULL);
TC_PRINT("%d<-OK\n", 2);
/* All but one data block read, stop reception */
ret = i2s_trigger(dev_i2s, I2S_DIR_RX, I2S_TRIGGER_STOP);
ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_STOP);
zassert_equal(ret, 0, "RX STOP trigger failed");
ret = rx_block_read(dev_i2s, 2);
ret = rx_block_read(dev_i2s_rx, 2);
zassert_equal(ret, TC_PASS, NULL);
TC_PRINT("%d<-OK\n", 3);
@ -150,41 +156,45 @@ void test_i2s_transfer_short(void)
*/
void test_i2s_transfer_long(void)
{
const struct device *dev_i2s;
const struct device *dev_i2s_rx;
const struct device *dev_i2s_tx;
int ret;
dev_i2s = device_get_binding(I2S_DEV_NAME);
zassert_not_null(dev_i2s, "device " I2S_DEV_NAME " not found");
dev_i2s_rx = device_get_binding(I2S_DEV_NAME_RX);
zassert_not_null(dev_i2s_rx, "device " I2S_DEV_NAME_RX " not found");
dev_i2s_tx = device_get_binding(I2S_DEV_NAME_TX);
zassert_not_null(dev_i2s_tx, "device " I2S_DEV_NAME_TX " not found");
/* Prefill TX queue */
ret = tx_block_write(dev_i2s, 0, 0);
ret = tx_block_write(dev_i2s_tx, 0, 0);
zassert_equal(ret, TC_PASS, NULL);
/* Start reception */
ret = i2s_trigger(dev_i2s, I2S_DIR_RX, I2S_TRIGGER_START);
ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_START);
zassert_equal(ret, 0, "RX START trigger failed");
/* Start transmission */
ret = i2s_trigger(dev_i2s, I2S_DIR_TX, I2S_TRIGGER_START);
ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_START);
zassert_equal(ret, 0, "TX START trigger failed");
for (int i = 0; i < TEST_I2S_TRANSFER_LONG_REPEAT_COUNT; i++) {
ret = tx_block_write(dev_i2s, 0, 0);
ret = tx_block_write(dev_i2s_tx, 0, 0);
zassert_equal(ret, TC_PASS, NULL);
ret = rx_block_read(dev_i2s, 0);
ret = rx_block_read(dev_i2s_rx, 0);
zassert_equal(ret, TC_PASS, NULL);
}
/* All data written, flush TX queue and stop the transmission */
ret = i2s_trigger(dev_i2s, I2S_DIR_TX, I2S_TRIGGER_DRAIN);
ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_DRAIN);
zassert_equal(ret, 0, "TX DRAIN trigger failed");
/* All but one data block read, stop reception */
ret = i2s_trigger(dev_i2s, I2S_DIR_RX, I2S_TRIGGER_STOP);
ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_STOP);
zassert_equal(ret, 0, "RX STOP trigger failed");
ret = rx_block_read(dev_i2s, 0);
ret = rx_block_read(dev_i2s_rx, 0);
zassert_equal(ret, TC_PASS, NULL);
/* TODO: Verify the interface is in READY state when i2s_state_get
@ -202,32 +212,36 @@ void test_i2s_transfer_long(void)
*/
void test_i2s_rx_sync_start(void)
{
const struct device *dev_i2s;
const struct device *dev_i2s_rx;
const struct device *dev_i2s_tx;
size_t rx_size;
int ret;
char buf[BLOCK_SIZE];
dev_i2s = device_get_binding(I2S_DEV_NAME);
zassert_not_null(dev_i2s, "device " I2S_DEV_NAME " not found");
dev_i2s_rx = device_get_binding(I2S_DEV_NAME_RX);
zassert_not_null(dev_i2s_rx, "device " I2S_DEV_NAME_RX " not found");
dev_i2s_tx = device_get_binding(I2S_DEV_NAME_TX);
zassert_not_null(dev_i2s_tx, "device " I2S_DEV_NAME_TX " not found");
/* Prefill TX queue */
for (int n = 0; n < NUM_TX_BLOCKS; n++) {
fill_buf_const((uint16_t *)buf, 1, 2);
ret = i2s_buf_write(dev_i2s, buf, BLOCK_SIZE);
ret = i2s_buf_write(dev_i2s_tx, buf, BLOCK_SIZE);
zassert_equal(ret, TC_PASS, NULL);
TC_PRINT("%d->OK\n", n);
}
/* Start transmission */
ret = i2s_trigger(dev_i2s, I2S_DIR_TX, I2S_TRIGGER_START);
ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_START);
zassert_equal(ret, 0, "TX START trigger failed");
k_busy_wait(75);
/* Start reception */
ret = i2s_trigger(dev_i2s, I2S_DIR_RX, I2S_TRIGGER_START);
ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_START);
zassert_equal(ret, 0, "RX START trigger failed");
ret = i2s_buf_read(dev_i2s, buf, &rx_size);
ret = i2s_buf_read(dev_i2s_rx, buf, &rx_size);
zassert_equal(ret, TC_PASS, NULL);
ret = verify_buf_const((uint16_t *)buf, 1, 2);
@ -235,10 +249,10 @@ void test_i2s_rx_sync_start(void)
TC_PRINT("%d<-OK\n", 1);
/* All data written, drop TX, RX queue and stop the transmission */
ret = i2s_trigger(dev_i2s, I2S_DIR_TX, I2S_TRIGGER_DROP);
ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_DROP);
zassert_equal(ret, 0, "TX DROP trigger failed");
ret = i2s_trigger(dev_i2s, I2S_DIR_RX, I2S_TRIGGER_DROP);
ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_DROP);
zassert_equal(ret, 0, "RX DROP trigger failed");
/* TODO: Verify the interface is in READY state when i2s_state_get
@ -257,8 +271,8 @@ void test_i2s_rx_empty_timeout(void)
int ret;
char buf[BLOCK_SIZE];
dev_i2s = device_get_binding(I2S_DEV_NAME);
zassert_not_null(dev_i2s, "device " I2S_DEV_NAME " not found");
dev_i2s = device_get_binding(I2S_DEV_NAME_RX);
zassert_not_null(dev_i2s, "device " I2S_DEV_NAME_RX " not found");
ret = i2s_buf_read(dev_i2s, buf, &rx_size);
zassert_equal(ret, -EAGAIN, "i2s_read did not timed out");
@ -272,38 +286,42 @@ void test_i2s_rx_empty_timeout(void)
*/
void test_i2s_transfer_restart(void)
{
const struct device *dev_i2s;
const struct device *dev_i2s_rx;
const struct device *dev_i2s_tx;
int ret;
dev_i2s = device_get_binding(I2S_DEV_NAME);
zassert_not_null(dev_i2s, "device " I2S_DEV_NAME " not found");
dev_i2s_rx = device_get_binding(I2S_DEV_NAME_RX);
zassert_not_null(dev_i2s_rx, "device " I2S_DEV_NAME_RX " not found");
dev_i2s_tx = device_get_binding(I2S_DEV_NAME_TX);
zassert_not_null(dev_i2s_tx, "device " I2S_DEV_NAME_TX " not found");
/* Prefill TX queue */
ret = tx_block_write(dev_i2s, 0, 0);
ret = tx_block_write(dev_i2s_tx, 0, 0);
zassert_equal(ret, TC_PASS, NULL);
TC_PRINT("%d->OK\n", 1);
ret = tx_block_write(dev_i2s, 1, 0);
ret = tx_block_write(dev_i2s_tx, 1, 0);
zassert_equal(ret, TC_PASS, NULL);
TC_PRINT("%d->OK\n", 2);
/* Start reception */
ret = i2s_trigger(dev_i2s, I2S_DIR_RX, I2S_TRIGGER_START);
ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_START);
zassert_equal(ret, 0, "RX START trigger failed");
/* Start transmission */
ret = i2s_trigger(dev_i2s, I2S_DIR_TX, I2S_TRIGGER_START);
ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_START);
zassert_equal(ret, 0, "TX START trigger failed");
/* Stop transmission */
ret = i2s_trigger(dev_i2s, I2S_DIR_TX, I2S_TRIGGER_STOP);
ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_STOP);
zassert_equal(ret, 0, "TX STOP trigger failed");
/* Stop reception */
ret = i2s_trigger(dev_i2s, I2S_DIR_RX, I2S_TRIGGER_STOP);
ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_STOP);
zassert_equal(ret, 0, "RX STOP trigger failed");
ret = rx_block_read(dev_i2s, 0);
ret = rx_block_read(dev_i2s_rx, 0);
zassert_equal(ret, TC_PASS, NULL);
TC_PRINT("%d<-OK\n", 1);
@ -315,38 +333,38 @@ void test_i2s_transfer_restart(void)
TC_PRINT("Start transmission\n");
/* Prefill TX queue */
ret = tx_block_write(dev_i2s, 2, 0);
ret = tx_block_write(dev_i2s_tx, 2, 0);
zassert_equal(ret, TC_PASS, NULL);
TC_PRINT("%d->OK\n", 3);
/* Start reception */
ret = i2s_trigger(dev_i2s, I2S_DIR_RX, I2S_TRIGGER_START);
ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_START);
zassert_equal(ret, 0, "RX START trigger failed");
/* Start transmission */
ret = i2s_trigger(dev_i2s, I2S_DIR_TX, I2S_TRIGGER_START);
ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_START);
zassert_equal(ret, 0, "TX START trigger failed");
/* All data written, drain TX queue and stop the transmission */
ret = i2s_trigger(dev_i2s, I2S_DIR_TX, I2S_TRIGGER_DRAIN);
ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_DRAIN);
zassert_equal(ret, 0, "TX DRAIN trigger failed");
ret = rx_block_read(dev_i2s, 1);
ret = rx_block_read(dev_i2s_rx, 1);
zassert_equal(ret, TC_PASS, NULL);
TC_PRINT("%d<-OK\n", 2);
/* All but one data block read, stop reception */
ret = i2s_trigger(dev_i2s, I2S_DIR_RX, I2S_TRIGGER_STOP);
ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_STOP);
zassert_equal(ret, 0, "RX STOP trigger failed");
ret = rx_block_read(dev_i2s, 2);
ret = rx_block_read(dev_i2s_rx, 2);
zassert_equal(ret, TC_PASS, NULL);
TC_PRINT("%d<-OK\n", 3);
}
/** @brief RX buffer overrun.
*
* - In case of RX buffer overrun it is possible to read out all RX data blocks
* - In case of RX buffer overrun it is possible to read out RX data blocks
* that are stored in the RX queue.
* - Reading from an empty RX queue when the RX buffer overrun occurred results
* in an error.
@ -355,64 +373,72 @@ void test_i2s_transfer_restart(void)
*/
void test_i2s_transfer_rx_overrun(void)
{
const struct device *dev_i2s;
const struct device *dev_i2s_rx;
const struct device *dev_i2s_tx;
size_t rx_size;
int ret;
char rx_buf[BLOCK_SIZE];
dev_i2s = device_get_binding(I2S_DEV_NAME);
zassert_not_null(dev_i2s, "device " I2S_DEV_NAME " not found");
dev_i2s_rx = device_get_binding(I2S_DEV_NAME_RX);
zassert_not_null(dev_i2s_rx, "device " I2S_DEV_NAME_RX " not found");
dev_i2s_tx = device_get_binding(I2S_DEV_NAME_TX);
zassert_not_null(dev_i2s_tx, "device " I2S_DEV_NAME_TX " not found");
/* Prefill TX queue */
ret = tx_block_write(dev_i2s, 0, 0);
ret = tx_block_write(dev_i2s_tx, 0, 0);
zassert_equal(ret, TC_PASS, NULL);
/* Start reception */
ret = i2s_trigger(dev_i2s, I2S_DIR_RX, I2S_TRIGGER_START);
ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_START);
zassert_equal(ret, 0, "RX START trigger failed");
/* Start transmission */
ret = i2s_trigger(dev_i2s, I2S_DIR_TX, I2S_TRIGGER_START);
ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_START);
zassert_equal(ret, 0, "TX START trigger failed");
for (int i = 0; i < NUM_RX_BLOCKS; i++) {
ret = tx_block_write(dev_i2s, 0, 0);
ret = tx_block_write(dev_i2s_tx, 0, 0);
zassert_equal(ret, TC_PASS, NULL);
}
/* All data written, flush TX queue and stop the transmission */
ret = i2s_trigger(dev_i2s, I2S_DIR_TX, I2S_TRIGGER_DRAIN);
ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_DRAIN);
zassert_equal(ret, 0, "TX DRAIN trigger failed");
/* Wait for transmission to finish */
k_sleep(K_MSEC(200));
/* Read all available data blocks in RX queue */
/* Read one data block, expect success even if RX queue is already in
* the error state.
*/
ret = rx_block_read(dev_i2s_rx, 0);
zassert_equal(ret, TC_PASS, NULL);
/* Attempt to read more data blocks than are available in the RX queue */
for (int i = 0; i < NUM_RX_BLOCKS; i++) {
ret = rx_block_read(dev_i2s, 0);
zassert_equal(ret, TC_PASS, NULL);
ret = i2s_buf_read(dev_i2s_rx, rx_buf, &rx_size);
if (ret != 0) {
break;
}
}
/* Attempt to read one more data block, expect an error */
ret = i2s_buf_read(dev_i2s, rx_buf, &rx_size);
zassert_equal(ret, -EIO, "RX overrun error not detected");
ret = i2s_trigger(dev_i2s, I2S_DIR_RX, I2S_TRIGGER_PREPARE);
ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_PREPARE);
zassert_equal(ret, 0, "RX PREPARE trigger failed");
/* Transmit and receive one more data block */
ret = tx_block_write(dev_i2s, 0, 0);
ret = tx_block_write(dev_i2s_tx, 0, 0);
zassert_equal(ret, TC_PASS, NULL);
ret = i2s_trigger(dev_i2s, I2S_DIR_RX, I2S_TRIGGER_START);
ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_START);
zassert_equal(ret, 0, "RX START trigger failed");
ret = i2s_trigger(dev_i2s, I2S_DIR_TX, I2S_TRIGGER_START);
ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_START);
zassert_equal(ret, 0, "TX START trigger failed");
ret = i2s_trigger(dev_i2s, I2S_DIR_TX, I2S_TRIGGER_DRAIN);
ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_DRAIN);
zassert_equal(ret, 0, "TX DRAIN trigger failed");
ret = i2s_trigger(dev_i2s, I2S_DIR_RX, I2S_TRIGGER_STOP);
ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_STOP);
zassert_equal(ret, 0, "RX STOP trigger failed");
ret = rx_block_read(dev_i2s, 0);
ret = rx_block_read(dev_i2s_rx, 0);
zassert_equal(ret, TC_PASS, NULL);
k_sleep(K_MSEC(200));
@ -427,58 +453,62 @@ void test_i2s_transfer_rx_overrun(void)
*/
void test_i2s_transfer_tx_underrun(void)
{
const struct device *dev_i2s;
const struct device *dev_i2s_rx;
const struct device *dev_i2s_tx;
int ret;
dev_i2s = device_get_binding(I2S_DEV_NAME);
zassert_not_null(dev_i2s, "device " I2S_DEV_NAME " not found");
dev_i2s_rx = device_get_binding(I2S_DEV_NAME_RX);
zassert_not_null(dev_i2s_rx, "device " I2S_DEV_NAME_RX " not found");
dev_i2s_tx = device_get_binding(I2S_DEV_NAME_TX);
zassert_not_null(dev_i2s_tx, "device " I2S_DEV_NAME_TX " not found");
/* Prefill TX queue */
ret = tx_block_write(dev_i2s, 0, 0);
ret = tx_block_write(dev_i2s_tx, 0, 0);
zassert_equal(ret, TC_PASS, NULL);
/* Start reception */
ret = i2s_trigger(dev_i2s, I2S_DIR_RX, I2S_TRIGGER_START);
ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_START);
zassert_equal(ret, 0, "RX START trigger failed");
/* Start transmission */
ret = i2s_trigger(dev_i2s, I2S_DIR_TX, I2S_TRIGGER_START);
ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_START);
zassert_equal(ret, 0, "TX START trigger failed");
/* Stop reception */
ret = i2s_trigger(dev_i2s, I2S_DIR_RX, I2S_TRIGGER_STOP);
ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_STOP);
zassert_equal(ret, 0, "RX STOP trigger failed");
ret = rx_block_read(dev_i2s, 0);
ret = rx_block_read(dev_i2s_rx, 0);
zassert_equal(ret, TC_PASS, NULL);
k_sleep(K_MSEC(200));
/* Write one more TX data block, expect an error */
ret = tx_block_write(dev_i2s, 2, -EIO);
ret = tx_block_write(dev_i2s_tx, 2, -EIO);
zassert_equal(ret, TC_PASS, NULL);
ret = i2s_trigger(dev_i2s, I2S_DIR_TX, I2S_TRIGGER_PREPARE);
ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_PREPARE);
zassert_equal(ret, 0, "TX PREPARE trigger failed");
k_sleep(K_MSEC(200));
/* Transmit and receive two more data blocks */
ret = tx_block_write(dev_i2s, 1, 0);
ret = tx_block_write(dev_i2s_tx, 1, 0);
zassert_equal(ret, TC_PASS, NULL);
ret = tx_block_write(dev_i2s, 1, 0);
ret = tx_block_write(dev_i2s_tx, 1, 0);
zassert_equal(ret, TC_PASS, NULL);
ret = i2s_trigger(dev_i2s, I2S_DIR_RX, I2S_TRIGGER_START);
ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_START);
zassert_equal(ret, 0, "RX START trigger failed");
ret = i2s_trigger(dev_i2s, I2S_DIR_TX, I2S_TRIGGER_START);
ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_START);
zassert_equal(ret, 0, "TX START trigger failed");
ret = rx_block_read(dev_i2s, 1);
ret = rx_block_read(dev_i2s_rx, 1);
zassert_equal(ret, TC_PASS, NULL);
ret = i2s_trigger(dev_i2s, I2S_DIR_TX, I2S_TRIGGER_DRAIN);
ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_DRAIN);
zassert_equal(ret, 0, "TX DRAIN trigger failed");
ret = i2s_trigger(dev_i2s, I2S_DIR_RX, I2S_TRIGGER_STOP);
ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_STOP);
zassert_equal(ret, 0, "RX STOP trigger failed");
ret = rx_block_read(dev_i2s, 1);
ret = rx_block_read(dev_i2s_rx, 1);
zassert_equal(ret, TC_PASS, NULL);
k_sleep(K_MSEC(200));

214
tests/drivers/i2s/i2s_api/src/test_i2s_states.c
View file

@ -31,20 +31,21 @@ void test_i2s_tx_transfer_configure_1(void)
struct i2s_config i2s_cfg;
int ret;
dev_i2s = device_get_binding(I2S_DEV_NAME);
zassert_not_null(dev_i2s, "device " I2S_DEV_NAME " not found");
dev_i2s = device_get_binding(I2S_DEV_NAME_TX);
zassert_not_null(dev_i2s, "device " I2S_DEV_NAME_TX " not found");
/* Configure */
i2s_cfg.word_size = 16U;
i2s_cfg.channels = 2U;
i2s_cfg.format = I2S_FMT_DATA_FORMAT_I2S;
i2s_cfg.options = I2S_OPT_FRAME_CLK_SLAVE | I2S_OPT_BIT_CLK_SLAVE;
/* Configure the Transmit port as Master */
i2s_cfg.options = I2S_OPT_FRAME_CLK_MASTER | I2S_OPT_BIT_CLK_MASTER;
i2s_cfg.frame_clk_freq = FRAME_CLK_FREQ;
i2s_cfg.block_size = BLOCK_SIZE;
i2s_cfg.mem_slab = &tx_1_mem_slab;
i2s_cfg.timeout = TIMEOUT;
i2s_cfg.options = I2S_OPT_LOOPBACK;
i2s_cfg.options |= I2S_OPT_LOOPBACK;
ret = i2s_configure(dev_i2s, I2S_DIR_TX, &i2s_cfg);
zassert_equal(ret, 0, "Failed to configure I2S TX stream");
@ -57,20 +58,21 @@ void test_i2s_rx_transfer_configure_1(void)
struct i2s_config i2s_cfg;
int ret;
dev_i2s = device_get_binding(I2S_DEV_NAME);
zassert_not_null(dev_i2s, "device " I2S_DEV_NAME " not found");
dev_i2s = device_get_binding(I2S_DEV_NAME_RX);
zassert_not_null(dev_i2s, "device " I2S_DEV_NAME_RX " not found");
/* Configure */
i2s_cfg.word_size = 16U;
i2s_cfg.channels = 2U;
i2s_cfg.format = I2S_FMT_DATA_FORMAT_I2S;
/* Configure the Receive port as Slave */
i2s_cfg.options = I2S_OPT_FRAME_CLK_SLAVE | I2S_OPT_BIT_CLK_SLAVE;
i2s_cfg.frame_clk_freq = FRAME_CLK_FREQ;
i2s_cfg.block_size = BLOCK_SIZE;
i2s_cfg.mem_slab = &rx_1_mem_slab;
i2s_cfg.timeout = TIMEOUT;
i2s_cfg.options = I2S_OPT_LOOPBACK;
i2s_cfg.options |= I2S_OPT_LOOPBACK;
ret = i2s_configure(dev_i2s, I2S_DIR_RX, &i2s_cfg);
zassert_equal(ret, 0, "Failed to configure I2S RX stream");
@ -85,61 +87,65 @@ void test_i2s_rx_transfer_configure_1(void)
*/
void test_i2s_state_not_ready_neg(void)
{
const struct device *dev_i2s;
const struct device *dev_i2s_rx;
const struct device *dev_i2s_tx;
struct i2s_config i2s_cfg;
size_t rx_size;
int ret;
char rx_buf[BLOCK_SIZE];
dev_i2s = device_get_binding(I2S_DEV_NAME);
zassert_not_null(dev_i2s, "device " I2S_DEV_NAME " not found");
dev_i2s_rx = device_get_binding(I2S_DEV_NAME_RX);
zassert_not_null(dev_i2s_rx, "device " I2S_DEV_NAME_RX " not found");
dev_i2s_tx = device_get_binding(I2S_DEV_NAME_TX);
zassert_not_null(dev_i2s_tx, "device " I2S_DEV_NAME_TX " not found");
i2s_cfg.frame_clk_freq = 0U;
i2s_cfg.mem_slab = &rx_1_mem_slab;
ret = i2s_configure(dev_i2s, I2S_DIR_RX, &i2s_cfg);
ret = i2s_configure(dev_i2s_rx, I2S_DIR_RX, &i2s_cfg);
zassert_equal(ret, 0, "Failed to configure I2S RX stream");
ret = i2s_trigger(dev_i2s, I2S_DIR_RX, I2S_TRIGGER_START);
ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_START);
zassert_equal(ret, -EIO, NULL);
ret = i2s_trigger(dev_i2s, I2S_DIR_RX, I2S_TRIGGER_DRAIN);
ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_DRAIN);
zassert_equal(ret, -EIO, NULL);
ret = i2s_trigger(dev_i2s, I2S_DIR_RX, I2S_TRIGGER_STOP);
ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_STOP);
zassert_equal(ret, -EIO, NULL);
ret = i2s_trigger(dev_i2s, I2S_DIR_RX, I2S_TRIGGER_DROP);
ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_DROP);
zassert_equal(ret, -EIO, NULL);
ret = i2s_trigger(dev_i2s, I2S_DIR_RX, I2S_TRIGGER_PREPARE);
ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_PREPARE);
zassert_equal(ret, -EIO, NULL);
ret = i2s_buf_read(dev_i2s, rx_buf, &rx_size);
ret = i2s_buf_read(dev_i2s_rx, rx_buf, &rx_size);
zassert_equal(ret, -EIO, NULL);
i2s_cfg.frame_clk_freq = 0U;
i2s_cfg.mem_slab = &tx_1_mem_slab;
ret = i2s_configure(dev_i2s, I2S_DIR_TX, &i2s_cfg);
ret = i2s_configure(dev_i2s_tx, I2S_DIR_TX, &i2s_cfg);
zassert_equal(ret, 0, "Failed to configure I2S TX stream");
ret = i2s_trigger(dev_i2s, I2S_DIR_TX, I2S_TRIGGER_START);
ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_START);
zassert_equal(ret, -EIO, NULL);
ret = i2s_trigger(dev_i2s, I2S_DIR_TX, I2S_TRIGGER_DRAIN);
ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_DRAIN);
zassert_equal(ret, -EIO, NULL);
ret = i2s_trigger(dev_i2s, I2S_DIR_TX, I2S_TRIGGER_STOP);
ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_STOP);
zassert_equal(ret, -EIO, NULL);
ret = i2s_trigger(dev_i2s, I2S_DIR_TX, I2S_TRIGGER_DROP);
ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_DROP);
zassert_equal(ret, -EIO, NULL);
ret = i2s_trigger(dev_i2s, I2S_DIR_TX, I2S_TRIGGER_PREPARE);
ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_PREPARE);
zassert_equal(ret, -EIO, NULL);
ret = tx_block_write(dev_i2s, 2, -EIO);
ret = tx_block_write(dev_i2s_tx, 2, -EIO);
zassert_equal(ret, TC_PASS, NULL);
}
@ -149,55 +155,63 @@ void test_i2s_state_not_ready_neg(void)
*/
void test_i2s_state_ready_neg(void)
{
const struct device *dev_i2s;
const struct device *dev_i2s_rx;
const struct device *dev_i2s_tx;
struct i2s_config i2s_cfg;
int ret;
dev_i2s = device_get_binding(I2S_DEV_NAME);
zassert_not_null(dev_i2s, "device " I2S_DEV_NAME " not found");
dev_i2s_rx = device_get_binding(I2S_DEV_NAME_RX);
zassert_not_null(dev_i2s_rx, "device " I2S_DEV_NAME_RX " not found");
dev_i2s_tx = device_get_binding(I2S_DEV_NAME_TX);
zassert_not_null(dev_i2s_tx, "device " I2S_DEV_NAME_TX " not found");
/* Configure RX stream changing its state to READY */
i2s_cfg.word_size = 16U;
i2s_cfg.channels = 2U;
i2s_cfg.format = I2S_FMT_DATA_FORMAT_I2S;
/* Configure the Receive port as Slave */
i2s_cfg.options = I2S_OPT_FRAME_CLK_SLAVE | I2S_OPT_BIT_CLK_SLAVE;
i2s_cfg.frame_clk_freq = 8000U;
i2s_cfg.block_size = BLOCK_SIZE;
i2s_cfg.mem_slab = &rx_1_mem_slab;
i2s_cfg.timeout = TIMEOUT;
ret = i2s_configure(dev_i2s, I2S_DIR_RX, &i2s_cfg);
ret = i2s_configure(dev_i2s_rx, I2S_DIR_RX, &i2s_cfg);
zassert_equal(ret, 0, "Failed to configure I2S RX stream");
/* Send RX stream triggers */
ret = i2s_trigger(dev_i2s, I2S_DIR_RX, I2S_TRIGGER_DRAIN);
ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_DRAIN);
zassert_equal(ret, -EIO, NULL);
ret = i2s_trigger(dev_i2s, I2S_DIR_RX, I2S_TRIGGER_STOP);
ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_STOP);
zassert_equal(ret, -EIO, NULL);
ret = i2s_trigger(dev_i2s, I2S_DIR_RX, I2S_TRIGGER_PREPARE);
ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_PREPARE);
zassert_equal(ret, -EIO, NULL);
/* Configure TX stream changing its state to READY */
i2s_cfg.options = I2S_OPT_LOOPBACK;
/* Configure the Transmit port as Master */
i2s_cfg.options = I2S_OPT_FRAME_CLK_MASTER | I2S_OPT_BIT_CLK_MASTER;
i2s_cfg.options |= I2S_OPT_LOOPBACK;
i2s_cfg.mem_slab = &tx_1_mem_slab;
ret = i2s_configure(dev_i2s, I2S_DIR_TX, &i2s_cfg);
ret = i2s_configure(dev_i2s_tx, I2S_DIR_TX, &i2s_cfg);
zassert_equal(ret, 0, "Failed to configure I2S RX stream");
/* Send TX stream triggers */
ret = i2s_trigger(dev_i2s, I2S_DIR_TX, I2S_TRIGGER_DRAIN);
ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_DRAIN);
zassert_equal(ret, -EIO, NULL);
ret = i2s_trigger(dev_i2s, I2S_DIR_TX, I2S_TRIGGER_STOP);
ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_STOP);
zassert_equal(ret, -EIO, NULL);
ret = i2s_trigger(dev_i2s, I2S_DIR_TX, I2S_TRIGGER_PREPARE);
ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_PREPARE);
zassert_equal(ret, -EIO, NULL);
}
@ -209,51 +223,55 @@ void test_i2s_state_ready_neg(void)
*/
void test_i2s_state_running_neg(void)
{
const struct device *dev_i2s;
const struct device *dev_i2s_rx;
const struct device *dev_i2s_tx;
int ret;
dev_i2s = device_get_binding(I2S_DEV_NAME);
zassert_not_null(dev_i2s, "device " I2S_DEV_NAME " not found");
dev_i2s_rx = device_get_binding(I2S_DEV_NAME_RX);
zassert_not_null(dev_i2s_rx, "device " I2S_DEV_NAME_RX " not found");
dev_i2s_tx = device_get_binding(I2S_DEV_NAME_TX);
zassert_not_null(dev_i2s_tx, "device " I2S_DEV_NAME_TX " not found");
/* Prefill TX queue */
ret = tx_block_write(dev_i2s, 0, 0);
ret = tx_block_write(dev_i2s_tx, 0, 0);
zassert_equal(ret, TC_PASS, NULL);
/* Start reception */
ret = i2s_trigger(dev_i2s, I2S_DIR_RX, I2S_TRIGGER_START);
ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_START);
zassert_equal(ret, 0, "RX START trigger failed");
/* Start transmission */
ret = i2s_trigger(dev_i2s, I2S_DIR_TX, I2S_TRIGGER_START);
ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_START);
zassert_equal(ret, 0, "TX START trigger failed");
for (int i = 0; i < TEST_I2S_STATE_RUNNING_NEG_REPEAT_COUNT; i++) {
ret = tx_block_write(dev_i2s, 0, 0);
ret = tx_block_write(dev_i2s_tx, 0, 0);
zassert_equal(ret, TC_PASS, NULL);
ret = rx_block_read(dev_i2s, 0);
ret = rx_block_read(dev_i2s_rx, 0);
zassert_equal(ret, TC_PASS, NULL);
/* Send invalid triggers, expect failure */
ret = i2s_trigger(dev_i2s, I2S_DIR_TX, I2S_TRIGGER_START);
ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_START);
zassert_equal(ret, -EIO, NULL);
ret = i2s_trigger(dev_i2s, I2S_DIR_TX, I2S_TRIGGER_PREPARE);
ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_PREPARE);
zassert_equal(ret, -EIO, NULL);
ret = i2s_trigger(dev_i2s, I2S_DIR_RX, I2S_TRIGGER_START);
ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_START);
zassert_equal(ret, -EIO, NULL);
ret = i2s_trigger(dev_i2s, I2S_DIR_RX, I2S_TRIGGER_PREPARE);
ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_PREPARE);
zassert_equal(ret, -EIO, NULL);
}
/* All data written, flush TX queue and stop the transmission */
ret = i2s_trigger(dev_i2s, I2S_DIR_TX, I2S_TRIGGER_DRAIN);
ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_DRAIN);
zassert_equal(ret, 0, "TX DRAIN trigger failed");
/* All but one data block read, stop reception */
ret = i2s_trigger(dev_i2s, I2S_DIR_RX, I2S_TRIGGER_STOP);
ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_STOP);
zassert_equal(ret, 0, "RX STOP trigger failed");
ret = rx_block_read(dev_i2s, 0);
ret = rx_block_read(dev_i2s_rx, 0);
zassert_equal(ret, TC_PASS, NULL);
}
@ -264,59 +282,63 @@ void test_i2s_state_running_neg(void)
*/
void test_i2s_state_stopping_neg(void)
{
const struct device *dev_i2s;
const struct device *dev_i2s_rx;
const struct device *dev_i2s_tx;
int ret;
dev_i2s = device_get_binding(I2S_DEV_NAME);
zassert_not_null(dev_i2s, "device " I2S_DEV_NAME " not found");
dev_i2s_rx = device_get_binding(I2S_DEV_NAME_RX);
zassert_not_null(dev_i2s_rx, "device " I2S_DEV_NAME_RX " not found");
dev_i2s_tx = device_get_binding(I2S_DEV_NAME_TX);
zassert_not_null(dev_i2s_tx, "device " I2S_DEV_NAME_TX " not found");
/* Prefill TX queue */
ret = tx_block_write(dev_i2s, 0, 0);
ret = tx_block_write(dev_i2s_tx, 0, 0);
zassert_equal(ret, TC_PASS, NULL);
/* Start reception */
ret = i2s_trigger(dev_i2s, I2S_DIR_RX, I2S_TRIGGER_START);
ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_START);
zassert_equal(ret, 0, "RX START trigger failed");
/* Start transmission */
ret = i2s_trigger(dev_i2s, I2S_DIR_TX, I2S_TRIGGER_START);
ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_START);
zassert_equal(ret, 0, "TX START trigger failed");
ret = tx_block_write(dev_i2s, 0, 0);
ret = tx_block_write(dev_i2s_tx, 0, 0);
zassert_equal(ret, TC_PASS, NULL);
ret = rx_block_read(dev_i2s, 0);
ret = rx_block_read(dev_i2s_rx, 0);
zassert_equal(ret, TC_PASS, NULL);
/* All data written, flush TX queue and stop the transmission */
ret = i2s_trigger(dev_i2s, I2S_DIR_TX, I2S_TRIGGER_DRAIN);
ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_DRAIN);
zassert_equal(ret, 0, "TX DRAIN trigger failed");
/* Send invalid triggers, expect failure */
ret = i2s_trigger(dev_i2s, I2S_DIR_TX, I2S_TRIGGER_START);
ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_START);
zassert_equal(ret, -EIO, NULL);
ret = i2s_trigger(dev_i2s, I2S_DIR_TX, I2S_TRIGGER_STOP);
ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_STOP);
zassert_equal(ret, -EIO, NULL);
ret = i2s_trigger(dev_i2s, I2S_DIR_TX, I2S_TRIGGER_DRAIN);
ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_DRAIN);
zassert_equal(ret, -EIO, NULL);
ret = i2s_trigger(dev_i2s, I2S_DIR_TX, I2S_TRIGGER_PREPARE);
ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_PREPARE);
zassert_equal(ret, -EIO, NULL);
/* All but one data block read, stop reception */
ret = i2s_trigger(dev_i2s, I2S_DIR_RX, I2S_TRIGGER_STOP);
ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_STOP);
zassert_equal(ret, 0, "RX STOP trigger failed");
/* Send invalid triggers, expect failure */
ret = i2s_trigger(dev_i2s, I2S_DIR_RX, I2S_TRIGGER_START);
ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_START);
zassert_equal(ret, -EIO, NULL);
ret = i2s_trigger(dev_i2s, I2S_DIR_RX, I2S_TRIGGER_STOP);
ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_STOP);
zassert_equal(ret, -EIO, NULL);
ret = i2s_trigger(dev_i2s, I2S_DIR_RX, I2S_TRIGGER_DRAIN);
ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_DRAIN);
zassert_equal(ret, -EIO, NULL);
ret = i2s_trigger(dev_i2s, I2S_DIR_RX, I2S_TRIGGER_PREPARE);
ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_PREPARE);
zassert_equal(ret, -EIO, NULL);
ret = rx_block_read(dev_i2s, 0);
ret = rx_block_read(dev_i2s_rx, 0);
zassert_equal(ret, TC_PASS, NULL);
}
@ -326,28 +348,32 @@ void test_i2s_state_stopping_neg(void)
*/
void test_i2s_state_error_neg(void)
{
const struct device *dev_i2s;
const struct device *dev_i2s_rx;
const struct device *dev_i2s_tx;
size_t rx_size;
int ret;
char rx_buf[BLOCK_SIZE];
dev_i2s = device_get_binding(I2S_DEV_NAME);
zassert_not_null(dev_i2s, "device " I2S_DEV_NAME " not found");
dev_i2s_rx = device_get_binding(I2S_DEV_NAME_RX);
zassert_not_null(dev_i2s_rx, "device " I2S_DEV_NAME_RX " not found");
dev_i2s_tx = device_get_binding(I2S_DEV_NAME_TX);
zassert_not_null(dev_i2s_tx, "device " I2S_DEV_NAME_TX " not found");
/* Prefill TX queue */
ret = tx_block_write(dev_i2s, 0, 0);
ret = tx_block_write(dev_i2s_tx, 0, 0);
zassert_equal(ret, TC_PASS, NULL);
/* Start reception */
ret = i2s_trigger(dev_i2s, I2S_DIR_RX, I2S_TRIGGER_START);
ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_START);
zassert_equal(ret, 0, "RX START trigger failed");
/* Start transmission */
ret = i2s_trigger(dev_i2s, I2S_DIR_TX, I2S_TRIGGER_START);
ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_START);
zassert_equal(ret, 0, "TX START trigger failed");
for (int i = 0; i < NUM_RX_BLOCKS; i++) {
ret = tx_block_write(dev_i2s, 0, 0);
ret = tx_block_write(dev_i2s_tx, 0, 0);
zassert_equal(ret, TC_PASS, NULL);
}
@ -356,54 +382,54 @@ void test_i2s_state_error_neg(void)
/* Read all available data blocks in RX queue */
for (int i = 0; i < NUM_RX_BLOCKS; i++) {
ret = rx_block_read(dev_i2s, 0);
ret = rx_block_read(dev_i2s_rx, 0);
zassert_equal(ret, TC_PASS, NULL);
}
/* Attempt to read one more data block, expect an error */
ret = i2s_buf_read(dev_i2s, rx_buf, &rx_size);
ret = i2s_buf_read(dev_i2s_rx, rx_buf, &rx_size);
zassert_equal(ret, -EIO, "RX overrun error not detected");
/* Send invalid triggers, expect failure */
ret = i2s_trigger(dev_i2s, I2S_DIR_RX, I2S_TRIGGER_START);
ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_START);
zassert_equal(ret, -EIO, NULL);
ret = i2s_trigger(dev_i2s, I2S_DIR_RX, I2S_TRIGGER_STOP);
ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_STOP);
zassert_equal(ret, -EIO, NULL);
ret = i2s_trigger(dev_i2s, I2S_DIR_RX, I2S_TRIGGER_DRAIN);
ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_DRAIN);
zassert_equal(ret, -EIO, NULL);
/* Recover from ERROR state */
ret = i2s_trigger(dev_i2s, I2S_DIR_RX, I2S_TRIGGER_PREPARE);
ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_PREPARE);
zassert_equal(ret, 0, "RX PREPARE trigger failed");
/* Write one more TX data block, expect an error */
ret = tx_block_write(dev_i2s, 2, -EIO);
ret = tx_block_write(dev_i2s_tx, 2, -EIO);
zassert_equal(ret, TC_PASS, NULL);
/* Send invalid triggers, expect failure */
ret = i2s_trigger(dev_i2s, I2S_DIR_TX, I2S_TRIGGER_START);
ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_START);
zassert_equal(ret, -EIO, NULL);
ret = i2s_trigger(dev_i2s, I2S_DIR_TX, I2S_TRIGGER_STOP);
ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_STOP);
zassert_equal(ret, -EIO, NULL);
ret = i2s_trigger(dev_i2s, I2S_DIR_TX, I2S_TRIGGER_DRAIN);
ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_DRAIN);
zassert_equal(ret, -EIO, NULL);
/* Recover from ERROR state */
ret = i2s_trigger(dev_i2s, I2S_DIR_TX, I2S_TRIGGER_PREPARE);
ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_PREPARE);
zassert_equal(ret, 0, "TX PREPARE trigger failed");
/* Transmit and receive one more data block */
ret = tx_block_write(dev_i2s, 0, 0);
ret = tx_block_write(dev_i2s_tx, 0, 0);
zassert_equal(ret, TC_PASS, NULL);
ret = i2s_trigger(dev_i2s, I2S_DIR_RX, I2S_TRIGGER_START);
ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_START);
zassert_equal(ret, 0, "RX START trigger failed");
ret = i2s_trigger(dev_i2s, I2S_DIR_TX, I2S_TRIGGER_START);
ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_START);
zassert_equal(ret, 0, "TX START trigger failed");
ret = i2s_trigger(dev_i2s, I2S_DIR_TX, I2S_TRIGGER_DRAIN);
ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_DRAIN);
zassert_equal(ret, 0, "TX DRAIN trigger failed");
ret = i2s_trigger(dev_i2s, I2S_DIR_RX, I2S_TRIGGER_STOP);
ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_STOP);
zassert_equal(ret, 0, "RX STOP trigger failed");
ret = rx_block_read(dev_i2s, 0);
ret = rx_block_read(dev_i2s_rx, 0);
zassert_equal(ret, TC_PASS, NULL);
k_sleep(K_MSEC(200));