diff --git a/components/driver/test/test_spi_master.c b/components/driver/test/test_spi_master.c index fad766ee3..757229741 100644 --- a/components/driver/test/test_spi_master.c +++ b/components/driver/test/test_spi_master.c @@ -390,7 +390,7 @@ TEST_CASE("SPI Master DMA test, TX and RX in different regions", "[spi]") trans[4].rxlength = 8*4; trans[4].tx_buffer = data_drom; trans[4].flags = SPI_TRANS_USE_RXDATA; - + trans[5].length = 8*4; trans[5].flags = SPI_TRANS_USE_RXDATA | SPI_TRANS_USE_TXDATA; @@ -412,7 +412,7 @@ TEST_CASE("SPI Master DMA test, TX and RX in different regions", "[spi]") } -static inline void int_connect( uint32_t gpio, uint32_t sigo, uint32_t sigi ) +static inline void int_connect( uint32_t gpio, uint32_t sigo, uint32_t sigi ) { gpio_matrix_out( gpio, sigo, false, false ); gpio_matrix_in( gpio, sigi, false ); @@ -430,7 +430,7 @@ TEST_CASE("SPI Master DMA test: length, start, not aligned", "[spi]") esp_err_t ret; spi_device_handle_t spi; spi_bus_config_t buscfg={ - .miso_io_num=PIN_NUM_MISO, + .miso_io_num=PIN_NUM_MISO, .mosi_io_num=PIN_NUM_MOSI, .sclk_io_num=PIN_NUM_CLK, .quadwp_io_num=-1, @@ -441,7 +441,7 @@ TEST_CASE("SPI Master DMA test: length, start, not aligned", "[spi]") .mode=0, //SPI mode 0 .spics_io_num=PIN_NUM_CS, //CS pin .queue_size=7, //We want to be able to queue 7 transactions at a time - .pre_cb=NULL, + .pre_cb=NULL, }; //Initialize the SPI bus ret=spi_bus_initialize(HSPI_HOST, &buscfg, 1); @@ -454,14 +454,14 @@ TEST_CASE("SPI Master DMA test: length, start, not aligned", "[spi]") int_connect( PIN_NUM_MOSI, HSPID_OUT_IDX, HSPIQ_IN_IDX ); memset(rx_buf, 0x66, 320); - + for ( int i = 0; i < 8; i ++ ) { memset( rx_buf, 0x66, sizeof(rx_buf)); spi_transaction_t t = {}; t.length = 8*(i+1); t.rxlength = 0; - t.tx_buffer = tx_buf+2*i; + t.tx_buffer = tx_buf+2*i; t.rx_buffer = rx_buf + i; if ( i == 1 ) { @@ -470,7 +470,7 @@ TEST_CASE("SPI Master DMA test: length, start, not aligned", "[spi]") } else if ( i == 2 ) { //test rx length != tx_length t.rxlength = t.length - 8; - } + } spi_device_transmit( spi, &t ); for( int i = 0; i < 16; i ++ ) { @@ -486,7 +486,7 @@ TEST_CASE("SPI Master DMA test: length, start, not aligned", "[spi]") } else { //normal check TEST_ASSERT( memcmp(t.tx_buffer, t.rx_buffer, t.length/8)==0 ); - } + } } TEST_ASSERT(spi_bus_remove_device(spi) == ESP_OK); @@ -495,14 +495,15 @@ TEST_CASE("SPI Master DMA test: length, start, not aligned", "[spi]") static const char MASTER_TAG[] = "test_master"; static const char SLAVE_TAG[] = "test_slave"; -DRAM_ATTR static uint8_t master_send[] = {0x93, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0xaa, 0xcc, 0xff, 0xee, 0x55, 0x77, 0x88, 0x43}; +//DRAM_ATTR static uint8_t master_send[] = {0x93, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0xaa, 0xcc, 0xff, 0xee, 0x55, 0x77, 0x88, 0x43}; DRAM_ATTR static uint8_t slave_send[] = { 0xaa, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10, 0x13, 0x57, 0x9b, 0xdf, 0x24, 0x68, 0xac, 0xe0 }; +/* static void master_init( spi_device_handle_t* spi, int mode, uint32_t speed) { esp_err_t ret; spi_bus_config_t buscfg={ - .miso_io_num=PIN_NUM_MISO, + .miso_io_num=PIN_NUM_MISO, .mosi_io_num=PIN_NUM_MOSI, .sclk_io_num=PIN_NUM_CLK, .quadwp_io_num=-1, @@ -513,7 +514,7 @@ static void master_init( spi_device_handle_t* spi, int mode, uint32_t speed) .mode=mode, //SPI mode 0 .spics_io_num=PIN_NUM_CS, //CS pin .queue_size=16, //We want to be able to queue 7 transactions at a time - .pre_cb=NULL, + .pre_cb=NULL, .cs_ena_pretrans = 0, }; //Initialize the SPI bus @@ -546,6 +547,7 @@ static void slave_init(int mode, int dma_chan) //Initialize SPI slave interface TEST_ESP_OK( spi_slave_initialize(VSPI_HOST, &buscfg, &slvcfg, dma_chan) ); } +*/ typedef struct { uint32_t len; @@ -604,6 +606,7 @@ static void task_slave(void* arg) t.tx_buffer = txdata.start; t.rx_buffer = recvbuf+4; //loop until trans_len != 0 to skip glitches + memset(recvbuf, 0x66, sizeof(recvbuf)); do { TEST_ESP_OK( spi_slave_transmit( VSPI_HOST, &t, portMAX_DELAY ) ); } while ( t.trans_len == 0 ); @@ -613,118 +616,177 @@ static void task_slave(void* arg) } } -TEST_CASE("SPI master variable cmd & addr test","[spi]") +#define TEST_SPI_HOST HSPI_HOST +#define TEST_SLAVE_HOST VSPI_HOST + +static uint8_t bitswap(uint8_t in) { - uint8_t *tx_buf=master_send; - uint8_t rx_buf[320]; - uint8_t *rx_buf_ptr = rx_buf; + uint8_t out = 0; + for (int i = 0; i < 8; i++) { + out = out >> 1; + if (in&0x80) out |= 0x80; + in = in << 1; + } + return out; +} - spi_slave_task_context_t slave_context = {}; - esp_err_t err = init_slave_context( &slave_context ); - TEST_ASSERT( err == ESP_OK ); +#define SPI_BUS_TEST_DEFAULT_CONFIG() {\ + .miso_io_num=PIN_NUM_MISO, \ + .mosi_io_num=PIN_NUM_MOSI,\ + .sclk_io_num=PIN_NUM_CLK,\ + .quadwp_io_num=-1,\ + .quadhd_io_num=-1\ + } +#define SPI_DEVICE_TEST_DEFAULT_CONFIG() {\ + .clock_speed_hz=10*1000*1000,\ + .mode=0,\ + .spics_io_num=PIN_NUM_CS,\ + .queue_size=16,\ + .pre_cb=NULL, \ + .cs_ena_pretrans = 0,\ + .cs_ena_posttrans = 0,\ + } + +#define SPI_SLAVE_TEST_DEFAULT_CONFIG() {\ + .mode=0,\ + .spics_io_num=PIN_NUM_CS,\ + .queue_size=3,\ + .flags=0,\ + } + +void test_cmd_addr(spi_slave_task_context_t *slave_context, bool lsb_first) +{ spi_device_handle_t spi; - //initial master, mode 0, 1MHz - master_init( &spi, 0, 1*1000*1000 ); - //initial slave, mode 0, no dma - slave_init(0, 0); + ESP_LOGI(MASTER_TAG, ">>>>>>>>> TEST %s FIRST <<<<<<<<<<<", lsb_first?"LSB":"MSB"); - //do internal connection + //initial master, mode 0, 1MHz + spi_bus_config_t buscfg=SPI_BUS_TEST_DEFAULT_CONFIG(); + TEST_ESP_OK(spi_bus_initialize(TEST_SPI_HOST, &buscfg, 1)); + spi_device_interface_config_t devcfg=SPI_DEVICE_TEST_DEFAULT_CONFIG(); + devcfg.clock_speed_hz = 1*1000*1000; + if (lsb_first) devcfg.flags |= SPI_DEVICE_BIT_LSBFIRST; + TEST_ESP_OK(spi_bus_add_device(TEST_SPI_HOST, &devcfg, &spi)); + + //connecting pins to two peripherals breaks the output, fix it. int_connect( PIN_NUM_MOSI, HSPID_OUT_IDX, VSPIQ_IN_IDX ); int_connect( PIN_NUM_MISO, VSPIQ_OUT_IDX, HSPID_IN_IDX ); int_connect( PIN_NUM_CS, HSPICS0_OUT_IDX, VSPICS0_IN_IDX ); int_connect( PIN_NUM_CLK, HSPICLK_OUT_IDX, VSPICLK_IN_IDX ); + for (int i= 0; i < 8; i++) { + //prepare slave tx data + slave_txdata_t slave_txdata = (slave_txdata_t) { + .start = slave_send, + .len = 256, + }; + xQueueSend(slave_context->data_to_send, &slave_txdata, portMAX_DELAY); + + vTaskDelay(50); + //prepare master tx data + int cmd_bits = (i+1)*2; + int addr_bits = 56-8*i; + int round_up = (cmd_bits+addr_bits+7)/8*8; + addr_bits = round_up - cmd_bits; + + spi_transaction_ext_t trans = (spi_transaction_ext_t) { + .base = { + .flags = SPI_TRANS_VARIABLE_CMD | SPI_TRANS_VARIABLE_ADDR, + .addr = 0x456789abcdef0123, + .cmd = 0xcdef, + }, + .command_bits = cmd_bits, + .address_bits = addr_bits, + }; + + ESP_LOGI( MASTER_TAG, "===== test%d =====", i ); + ESP_LOGI(MASTER_TAG, "cmd_bits： %d, addr_bits: %d", cmd_bits, addr_bits); + TEST_ESP_OK(spi_device_transmit(spi, (spi_transaction_t*)&trans)); + //wait for both master and slave end + + size_t rcv_len; + slave_rxdata_t *rcv_data = xRingbufferReceive(slave_context->data_received, &rcv_len, portMAX_DELAY); + rcv_len-=4; + uint8_t *buffer = rcv_data->data; + + ESP_LOGI(SLAVE_TAG, "trans_len: %d", rcv_len); + TEST_ASSERT_EQUAL(rcv_len, (rcv_data->len+7)/8); + TEST_ASSERT_EQUAL(rcv_data->len, cmd_bits+addr_bits); + ESP_LOG_BUFFER_HEX("slave rx", buffer, rcv_len); + + uint16_t cmd_expected = trans.base.cmd & (BIT(cmd_bits) - 1); + uint64_t addr_expected = trans.base.addr & ((1ULL<> (16-cmd_bits); + int remain_bits = cmd_bits % 8; + + uint64_t addr_got = *(uint64_t*)data_ptr; + data_ptr += 8; + addr_got = __builtin_bswap64(addr_got); + addr_got = (addr_got << remain_bits); + addr_got |= (*data_ptr >> (8-remain_bits)); + addr_got = addr_got >> (64-addr_bits); + + if (lsb_first) { + cmd_got = __builtin_bswap16(cmd_got); + addr_got = __builtin_bswap64(addr_got); + + uint8_t *swap_ptr = (uint8_t*)&cmd_got; + swap_ptr[0] = bitswap(swap_ptr[0]); + swap_ptr[1] = bitswap(swap_ptr[1]); + cmd_got = cmd_got >> (16-cmd_bits); + + swap_ptr = (uint8_t*)&addr_got; + for (int j = 0; j < 8; j++) swap_ptr[j] = bitswap(swap_ptr[j]); + addr_got = addr_got >> (64-addr_bits); + } + + ESP_LOGI(SLAVE_TAG, "cmd_got: %04X, addr_got: %08X%08X", cmd_got, (uint32_t)(addr_got>>32), (uint32_t)addr_got); + + TEST_ASSERT_EQUAL_HEX16(cmd_expected, cmd_got); + if (addr_bits > 0) { + TEST_ASSERT_EQUAL_HEX32(addr_expected, addr_got); + TEST_ASSERT_EQUAL_HEX32(addr_expected >> 8, addr_got >> 8); + } + + //clean + vRingbufferReturnItem(slave_context->data_received, buffer); + } + + TEST_ASSERT(spi_bus_remove_device(spi) == ESP_OK); + TEST_ASSERT(spi_bus_free(TEST_SPI_HOST) == ESP_OK); +} + +TEST_CASE("SPI master variable cmd & addr test","[spi]") +{ + spi_slave_task_context_t slave_context = {}; + esp_err_t err = init_slave_context( &slave_context ); + TEST_ASSERT( err == ESP_OK ); TaskHandle_t handle_slave; xTaskCreate( task_slave, "spi_slave", 4096, &slave_context, 0, &handle_slave); - slave_txdata_t slave_txdata[16]; - spi_transaction_ext_t trans[16]; - for( int i= 0; i < 16; i ++ ) { - //prepare slave tx data - slave_txdata[i] = (slave_txdata_t) { - .start = slave_send + 4*(i%3), - .len = 256, - }; - xQueueSend( slave_context.data_to_send, &slave_txdata[i], portMAX_DELAY ); - //prepare master tx data - trans[i] = (spi_transaction_ext_t) { - .base = { - .flags = SPI_TRANS_VARIABLE_CMD | SPI_TRANS_VARIABLE_ADDR, - .addr = 0x456789ab, - .cmd = 0xcdef, + //initial slave, mode 0, no dma + int dma_chan = 0; + int slave_mode = 0; + spi_bus_config_t slv_buscfg=SPI_BUS_TEST_DEFAULT_CONFIG(); + spi_slave_interface_config_t slvcfg=SPI_SLAVE_TEST_DEFAULT_CONFIG(); + slvcfg.mode = slave_mode; + //Initialize SPI slave interface + TEST_ESP_OK( spi_slave_initialize(TEST_SLAVE_HOST, &slv_buscfg, &slvcfg, dma_chan) ); - .length = 8*i, - .tx_buffer = tx_buf+i, - .rx_buffer = rx_buf_ptr, - }, - .command_bits = ((i+1)%3) * 8, - .address_bits = ((i/3)%5) * 8, - }; - if ( trans[i].base.length == 0 ) { - trans[i].base.tx_buffer = NULL; - trans[i].base.rx_buffer = NULL; - } else { - rx_buf_ptr += (trans[i].base.length + 31)/32*4; - } - } - - vTaskDelay(10); - - for ( int i = 0; i < 16; i ++ ) { - TEST_ESP_OK (spi_device_queue_trans( spi, (spi_transaction_t*)&trans[i], portMAX_DELAY ) ); - vTaskDelay(10); - } - - for( int i= 0; i < 16; i ++ ) { - //wait for both master and slave end - ESP_LOGI( MASTER_TAG, "===== test%d =====", i ); - spi_transaction_ext_t *t; - size_t rcv_len; - spi_device_get_trans_result( spi, (spi_transaction_t**)&t, portMAX_DELAY ); - TEST_ASSERT( t == &trans[i] ); - if ( trans[i].base.length != 0 ) { - ESP_LOG_BUFFER_HEX( "master tx", trans[i].base.tx_buffer, trans[i].base.length/8 ); - ESP_LOG_BUFFER_HEX( "master rx", trans[i].base.rx_buffer, trans[i].base.length/8 ); - } else { - ESP_LOGI( "master tx", "no data" ); - ESP_LOGI( "master rx", "no data" ); - } - - slave_rxdata_t *rcv_data = xRingbufferReceive( slave_context.data_received, &rcv_len, portMAX_DELAY ); - uint8_t *buffer = rcv_data->data; - rcv_len = rcv_data->len; - ESP_LOGI(SLAVE_TAG, "trans_len: %d", rcv_len); - ESP_LOG_BUFFER_HEX( "slave tx", slave_txdata[i].start, (rcv_len+7)/8); - ESP_LOG_BUFFER_HEX( "slave rx", buffer, (rcv_len+7)/8); - //check result - uint8_t *ptr_addr = (uint8_t*)&t->base.addr; - uint8_t *ptr_cmd = (uint8_t*)&t->base.cmd; - for ( int j = 0; j < t->command_bits/8; j ++ ) { - TEST_ASSERT_EQUAL( buffer[j], ptr_cmd[t->command_bits/8-j-1] ); - } - for ( int j = 0; j < t->address_bits/8; j ++ ) { - TEST_ASSERT_EQUAL( buffer[t->command_bits/8+j], ptr_addr[t->address_bits/8-j-1] ); - } - if ( t->base.length != 0) { - TEST_ASSERT_EQUAL_HEX8_ARRAY(t->base.tx_buffer, buffer + (t->command_bits + t->address_bits)/8, t->base.length/8); - TEST_ASSERT_EQUAL_HEX8_ARRAY(slave_txdata[i].start + (t->command_bits + t->address_bits)/8, t->base.rx_buffer, t->base.length/8); - } - TEST_ASSERT_EQUAL( t->base.length + t->command_bits + t->address_bits, rcv_len ); - - //clean - vRingbufferReturnItem( slave_context.data_received, buffer ); - } + test_cmd_addr(&slave_context, false); + test_cmd_addr(&slave_context, true); vTaskDelete( handle_slave ); handle_slave = 0; deinit_slave_context(&slave_context); - - TEST_ASSERT(spi_slave_free(VSPI_HOST) == ESP_OK); - TEST_ASSERT(spi_bus_remove_device(spi) == ESP_OK); - TEST_ASSERT(spi_bus_free(HSPI_HOST) == ESP_OK); + TEST_ASSERT(spi_slave_free(TEST_SLAVE_HOST) == ESP_OK); ESP_LOGI(MASTER_TAG, "test passed."); }