static char* test_ram2() { // -------------- // Setup // -------------- CircularBuffer* pc_input = cbuffer_new(); CircularBuffer* pc_output = cbuffer_new(); CircularBuffer* orsc_input = cbuffer_new(); CircularBuffer* orsc_output = cbuffer_new(); VMEStream *pc_stream = vmestream_initialize_heap(pc_input, pc_output, 2); VMEStream *orsc_stream = malloc(sizeof(VMEStream)); orsc_stream->input = orsc_input; orsc_stream->output = orsc_output; orsc_stream->local_send_size = pc_stream->remote_send_size; orsc_stream->local_recv_size = pc_stream->remote_recv_size; orsc_stream->remote_send_size = pc_stream->local_send_size; orsc_stream->remote_recv_size = pc_stream->local_recv_size; orsc_stream->recv_data = pc_stream->send_data; orsc_stream->send_data = pc_stream->recv_data; orsc_stream->MAXRAM = pc_stream->MAXRAM; cbuffer_push_back(pc_input, 0xDEADBEEF); cbuffer_push_back(orsc_input, 0xBEEFCAFE); vmestream_transfer_data(pc_stream); vmestream_transfer_data(orsc_stream); vmestream_transfer_data(pc_stream); mu_assert("Error: pc_input not empty", cbuffer_size(pc_input) == 0); mu_assert("Error: orsc_input not empty", cbuffer_size(orsc_input) == 0); mu_assert("Error: orsc_output.pop != DEADBEEF", cbuffer_pop_front(orsc_output)); mu_assert("Error: pc_output.pop != BEEFCAFE", cbuffer_pop_front(pc_output)); mu_assert("Error: pc_output not empty", cbuffer_size(pc_output) == 0); mu_assert("Error: orsc_output not empty", cbuffer_size(orsc_output) == 0); // -------------- // Tear-Down // -------------- vmestream_destroy_heap(pc_stream); free(orsc_stream); cbuffer_free(pc_input); cbuffer_free(orsc_input); cbuffer_free(pc_output); cbuffer_free(orsc_output); return 0; }
/** * Push less data to the buffers than we have RAM available */ static char *test_ram2() { // local application buffers CircularBuffer *tx1 = cbuffer_new(); CircularBuffer *rx1 = cbuffer_new(); CircularBuffer *tx2 = cbuffer_new(); CircularBuffer *rx2 = cbuffer_new(); VMEStream *test1 = vmestream_initialize(tx1, rx1, 2); VMEStream *test2 = malloc(sizeof(VMEStream)); test2->input = tx2; test2->output = rx2; test2->rx_size = test1->tx_size; test2->tx_size = test1->rx_size; test2->rx_data = test1->tx_data; test2->tx_data = test1->rx_data; test2->MAXRAM = test1->MAXRAM; // place only one word on the buffers cbuffer_push_back(tx1, 0xDEADBEEF); // put some output data on host #2 cbuffer_push_back(tx2, 0xBEEFCAFE); vmestream_transfer_data(test1); vmestream_transfer_data(test2); vmestream_transfer_data(test1); mu_assert("Error: tx1 not empty", 0 == cbuffer_size(tx1)); mu_assert("Error: tx2 not empty", 0 == cbuffer_size(tx2)); mu_assert("Error: 0xDEADBEEF != rx2.pop", 0xDEADBEEF == cbuffer_pop_front(rx2)); mu_assert("Error: 0xBEEFCAFE != rx1.pop", 0xBEEFCAFE == cbuffer_pop_front(rx1)); mu_assert("Error: rx2 not empty", 0 == cbuffer_size(rx2)); mu_assert("Error: rx1 not empty", 0 == cbuffer_size(rx1)); // free memory vmestream_destroy(test1); free(test2); cbuffer_free(tx1); cbuffer_free(rx1); cbuffer_free(tx2); cbuffer_free(rx2); return 0; }
static char* test_cbuffer_transfer_data(void) { CircularBuffer* src = cbuffer_new(); CircularBuffer* dst = cbuffer_new(); for (int i = 0; i < 200; ++i) { cbuffer_push_back(src, i); } mu_assert_eq("Src buffer size", cbuffer_size(src), 200); mu_assert_eq("Dst buffer size", cbuffer_size(dst), 0); // transfer data from src -> dst cbuffer_transfer_data(src, dst); mu_assert_eq("Src buffer size post transfer", cbuffer_size(src), 0); mu_assert_eq("Dst buffer size post transfer", cbuffer_size(dst), 200); // check content for (int i = 0; i < 200; ++i) { mu_assert_eq("Dst content", cbuffer_pop_front(dst), i); } cbuffer_free(src); cbuffer_free(dst); return 0; }
int main() { xil_printf("Master SPI oRSC echo test\n"); // initialize stdout. init_platform(); tx_buffer = cbuffer_new(); rx_buffer = cbuffer_new(); vme_stream = vmestream_initialize_mem( rx_buffer, tx_buffer, (uint32_t*)ORSC_2_PC_SIZE, (uint32_t*)PC_2_ORSC_SIZE, (uint32_t*)ORSC_2_PC_DATA, (uint32_t*)PC_2_ORSC_DATA, VMERAMSIZE); //printf("Master SPI oRSC echo test\n"); while (1) { // transfer data vmestream_transfer_data(vme_stream); // now echo the data while (cbuffer_size(rx_buffer) && cbuffer_freespace(tx_buffer)) { cbuffer_push_back(tx_buffer, cbuffer_pop_front(rx_buffer)); } } return 0; }
static char* test_cbuffer_pop_front(void) { CircularBuffer* mybuf = cbuffer_new(); // put us at the end of the buffer mybuf->pos = IO_BUFFER_SIZE - 5; mybuf->tail = IO_BUFFER_SIZE - 5; uint32_t test_data[11] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; cbuffer_append(mybuf, test_data, 11); for (int i = 0; i < 11; i++) { mu_assert_eq("pre-pop size", cbuffer_size(mybuf), 11 - i); uint32_t value = cbuffer_pop_front(mybuf); mu_assert_eq("popped_content", (int)value, i); } // if we pop an empty collection, we get dead beef. uint32_t empty = cbuffer_pop_front(mybuf); mu_assert_eq("empty", empty, 0xDEADBEEF); cbuffer_free(mybuf); return 0; }
/* * Make sure cbuffer_fd_read handles the edge case where cbuffer->tail returns * to the front of buffer->data */ static char* test_cbuffer_fd_read_edge(void) { int pipefd[2]; pipe(pipefd); fcntl(pipefd[0], F_SETFL, fcntl(pipefd[0], F_GETFL) | O_NONBLOCK); int in = pipefd[1]; int out = pipefd[0]; CircularBuffer* mybuf = cbuffer_new(); // completely fill buffer while (cbuffer_freespace(mybuf) > 0) { mu_assert_eq("mybuf overflow", cbuffer_push_back(mybuf, 0xDEADBEEF), 0); } mu_assert_eq("mybuf still has free space", cbuffer_freespace(mybuf), 0); // clear a single space in the cbuffer // free space should be at the front of cbuffer->data cbuffer_deletefront(mybuf, 1); uint32_t inbuf[] = {0xCAFEBABE}; write(in, inbuf, sizeof(uint32_t)); // read a single word into the free slot in the buffer mu_assert_eq("Could not read data", cbuffer_read_fd(mybuf, out, 1), 1); // check the content of the cbuffer while (cbuffer_size(mybuf) > 1) { mu_assert_eq("Content should be 0xDEADBEEF", cbuffer_pop_front(mybuf), 0xDEADBEEF); } mu_assert_eq("Content should be 0xCAFEBABE", cbuffer_pop_front(mybuf), 0xCAFEBABE); cbuffer_free(mybuf); return 0; }
/** * Overload buffer test */ static char *test_buf() { // local application buffers CircularBuffer *tx1 = cbuffer_new(); CircularBuffer *rx1 = cbuffer_new(); CircularBuffer *tx2 = cbuffer_new(); CircularBuffer *rx2 = cbuffer_new(); VMEStream *test1 = vmestream_initialize(tx1, rx1, 32); VMEStream *test2 = malloc(sizeof(VMEStream)); test2->input = tx2; test2->output = rx2; test2->rx_size = test1->tx_size; test2->tx_size = test1->rx_size; test2->rx_data = test1->tx_data; test2->tx_data = test1->rx_data; test2->MAXRAM = test1->MAXRAM; cbuffer_push_back(rx2, 0xDEADBEEF); for (int i = 0; i < 510; i++) { cbuffer_push_back(rx2, 0xBEEFCAFE); } cbuffer_push_back(tx1, 0xBEEFCAFE + 1); cbuffer_push_back(tx1, 0xBEEFCAFE + 2); cbuffer_push_back(tx1, 0xBEEFCAFE + 3); cbuffer_push_back(tx1, 0xBEEFCAFE + 4); mu_assert("Error: rx2 should have no space left", cbuffer_freespace(rx2) == 0); // sanity check mu_assert_eq("Error: output size != 4", cbuffer_size(tx1), 4); // do several transfers vmestream_transfer_data(test1); vmestream_transfer_data(test2); vmestream_transfer_data(test1); vmestream_transfer_data(test2); // no data should have been transferred mu_assert_eq("Error: tx_size != 4", *(test1->tx_size), 4); mu_assert("Error: rx2.pop != 0xDEADBEEF", 0xDEADBEEF == cbuffer_pop_front(rx2)); cbuffer_pop_front(rx2); cbuffer_pop_front(rx2); // popping off rx2 should have freed 3 words, but not enough to transfer all // four vmestream_transfer_data(test1); vmestream_transfer_data(test2); mu_assert_eq("Error: tx_size != 4", *(test1->tx_size), 4); mu_assert("Errrr: rx2.pop not 0xBEEFCAFE", 0xBEEFCAFE == cbuffer_pop_front(rx2)); cbuffer_pop_front(rx2); // now there is enough room for all the limbo data to be transferred to rx2 vmestream_transfer_data(test1); vmestream_transfer_data(test2); mu_assert("Error: tx_size != 0", *(test1->tx_size) == 0); mu_assert("Error: tx1 not empty", 0 == cbuffer_size(tx1)); for (int i = 0; i < 4; ++i) { mu_assert_eq("Unexpected data transferred", cbuffer_value_at(rx2, cbuffer_size(rx2) - 4 + i), 0xBEEFCAFE + i + 1); } // free memory vmestream_destroy(test1); free(test2); cbuffer_free(tx1); cbuffer_free(rx1); cbuffer_free(tx2); cbuffer_free(rx2); return 0; }
static char *test_ram1() { // local application buffers CircularBuffer *tx1 = cbuffer_new(); CircularBuffer *rx1 = cbuffer_new(); CircularBuffer *tx2 = cbuffer_new(); CircularBuffer *rx2 = cbuffer_new(); VMEStream *test1 = vmestream_initialize(tx1, rx1, 1); VMEStream *test2 = malloc(sizeof(VMEStream)); test2->input = tx2; test2->output = rx2; test2->rx_size = test1->tx_size; test2->tx_size = test1->rx_size; test2->rx_data = test1->tx_data; test2->tx_data = test1->rx_data; test2->MAXRAM = test1->MAXRAM; for (unsigned int i = 0; i < 20; ++i) { // put some output data on host #1 cbuffer_push_back(tx1, 0xDEADBEEF + i); // put some output data on host #2 cbuffer_push_back(tx2, 0xBEEFCAFE + i); } // do a transfer vmestream_transfer_data(test1); // step 1 vmestream_transfer_data(test2); // step 2 // host #2 has received data, since host #1 filled it's TX buffer in step 1 // and host #2 can read it out in step 2 mu_assert("Error: 0xDEADBEEF != rx2.pop", 0xDEADBEEF == cbuffer_pop_front(rx2)); vmestream_transfer_data(test1); // step 3 // now host #1 can read the data loaded by host #2 in step 2 mu_assert("Error: 0xBEEFCAFE != rx1.pop", 0xBEEFCAFE == cbuffer_pop_front(rx1)); // do another transfer vmestream_transfer_data(test2); vmestream_transfer_data(test1); mu_assert("Error: 0xBEEFCAFE+1 != rx1.pop", 0xBEEFCAFE + 1 == cbuffer_pop_front(rx1)); mu_assert("Error: 0xDEADBEEF+1 != rx2.pop", 0xDEADBEEF + 1 == cbuffer_pop_front(rx2)); // We have consumed all received data (via pop). There is a word of // data in limbo for host #1 mu_assert("Error: 0 != rx1.size", 0 == cbuffer_size(rx1)); mu_assert("Error: 0 != rx2.size", 0 == cbuffer_size(rx2)); mu_assert("Error: 17 != tx1.size", 17 == cbuffer_size(tx1)); mu_assert("Error: 18 != tx2.size", 18 == cbuffer_size(tx2)); // call transfer on #1 twice in a row. Since it's still waiting for // #2 to read the data, nothing happens. vmestream_transfer_data(test1); mu_assert("Error: 0 != rx1.size", 0 == cbuffer_size(rx1)); mu_assert("Error: 0 != rx2.size", 0 == cbuffer_size(rx2)); mu_assert("Error: 17 != tx1.size", 17 == cbuffer_size(tx1)); mu_assert("Error: 18 != tx2.size", 18 == cbuffer_size(tx2)); // #2 receives limbo data, puts one of it's words in limbo. vmestream_transfer_data(test2); mu_assert("Error: 0 != rx1.size", 0 == cbuffer_size(rx1)); mu_assert("Error: 1 != rx2.size", 1 == cbuffer_size(rx2)); mu_assert("Error: 17 != tx1.size", 17 == cbuffer_size(tx1)); mu_assert("Error: 17 != tx2.size", 17 == cbuffer_size(tx2)); // free memory vmestream_destroy(test1); free(test2); cbuffer_free(tx1); cbuffer_free(rx1); cbuffer_free(tx2); cbuffer_free(rx2); return 0; }
static char* test_ram1() { CircularBuffer* pc_input = cbuffer_new(); CircularBuffer* pc_output = cbuffer_new(); CircularBuffer* orsc_input = cbuffer_new(); CircularBuffer* orsc_output = cbuffer_new(); VMEStream *pc_stream = vmestream_initialize_heap(pc_input, pc_output, 1); VMEStream *orsc_stream = malloc(sizeof(VMEStream)); orsc_stream->input = orsc_input; orsc_stream->output = orsc_output; orsc_stream->local_send_size = pc_stream->remote_send_size; orsc_stream->local_recv_size = pc_stream->remote_recv_size; orsc_stream->remote_send_size = pc_stream->local_send_size; orsc_stream->remote_recv_size = pc_stream->local_recv_size; orsc_stream->recv_data = pc_stream->send_data; orsc_stream->send_data = pc_stream->recv_data; orsc_stream->MAXRAM = pc_stream->MAXRAM; for (uint32_t i = 0; i < 20; ++i) { cbuffer_push_back(pc_input, 0xDEADBEEF + i); cbuffer_push_back(orsc_input, 0xBEEFCAFE + i); } // initial transfer vmestream_transfer_data(pc_stream); // transfer data vmestream_transfer_data(orsc_stream); vmestream_transfer_data(pc_stream); mu_assert("Error: orsc_output.pop != DEADBEEF", cbuffer_pop_front(orsc_output) == 0xDEADBEEF); mu_assert("Error: pc_output.pop != BEEFCAFE", cbuffer_pop_front(pc_output) == 0xBEEFCAFE); // extra transfer is needed to reset the size registers // to zero to prepare for another transfer vmestream_transfer_data(orsc_stream); vmestream_transfer_data(pc_stream); // transfer data vmestream_transfer_data(orsc_stream); vmestream_transfer_data(pc_stream); mu_assert("Error: orsc_output.pop != DEADBEEF + 1", cbuffer_pop_front(orsc_output) == 0xDEADBEEF + 1); mu_assert("Error: pc_output.pop != BEEFCAFE + 1", cbuffer_pop_front(pc_output) == 0xBEEFCAFE + 1); /* printf("pc_output.size: %d\n", cbuffer_size(pc_output)); printf("orsc_output.size: %d\n", cbuffer_size(orsc_output)); printf("pc_input.size: %d\n", cbuffer_size(pc_input)); printf("orsc_input.size: %d\n", cbuffer_size(orsc_input)); */ mu_assert("Error: pc_output.size != 0", cbuffer_size(pc_output) == 0); mu_assert("Error: orsc_output.size != 0", cbuffer_size(orsc_output) == 0); mu_assert("Error: pc_input.size != 18", cbuffer_size(pc_input) == 18); mu_assert("Error: orsc_input.size != 18", cbuffer_size(orsc_input) == 18); // transfer on pc_stream 2x in a row. Nothing should happen. vmestream_transfer_data(pc_stream); mu_assert("Error: pc_output.size != 0", cbuffer_size(pc_output) == 0); mu_assert("Error: orsc_output.size != 0", cbuffer_size(orsc_output) == 0); mu_assert("Error: pc_input.size != 18", cbuffer_size(pc_input) == 18); mu_assert("Error: orsc_input.size != 18", cbuffer_size(orsc_input) == 18); // reset vmestream_transfer_data(orsc_stream); vmestream_transfer_data(pc_stream); vmestream_transfer_data(orsc_stream); mu_assert("Error: pc_output.size != 0", cbuffer_size(pc_output) == 0); mu_assert("Error: orsc_output.size != 1", cbuffer_size(orsc_output) == 1); mu_assert("Error: pc_input.size != 17", cbuffer_size(pc_input) == 17); mu_assert("Error: orsc_input.size != 17", cbuffer_size(orsc_input) == 17); vmestream_destroy_heap(pc_stream); free(orsc_stream); cbuffer_free(pc_input); cbuffer_free(orsc_input); cbuffer_free(pc_output); cbuffer_free(orsc_output); return 0; }
int main(void) { LOG_INFO("UART CTP FE echo test\n"); init_platform(); tx_buffer = cbuffer_new(); rx_buffer = cbuffer_new(); int Status; u16 DeviceId = UARTLITE_DEVICE_ID; /* * Initialize the UartLite driver so that it's ready to use. */ Status = XUartLite_Initialize(&UartLite, DeviceId); if (Status != XST_SUCCESS) { LOG_ERROR ("Error: could not initialize UART\n"); return XST_FAILURE; } XUartLite_ResetFifos(&UartLite); /* * Perform a self-test to ensure that the hardware was built correctly. */ Status = XUartLite_SelfTest(&UartLite); if (Status != XST_SUCCESS) { LOG_ERROR ("Error: self test failed\n"); return XST_FAILURE; } /* * Connect the UartLite to the interrupt subsystem such that interrupts can * occur. This function is application specific. */ Status = SetupInterruptSystem(&UartLite); if (Status != XST_SUCCESS) { LOG_ERROR ("Error: could not setup interrupts\n"); return XST_FAILURE; } /* * Setup the handlers for the UartLite that will be called from the * interrupt context when data has been sent and received, specify a * pointer to the UartLite driver instance as the callback reference so * that the handlers are able to access the instance data. */ XUartLite_SetSendHandler(&UartLite, SendHandler, &UartLite); XUartLite_SetRecvHandler(&UartLite, RecvHandler, &UartLite); /* * Enable the interrupt of the UartLite so that interrupts will occur. */ XUartLite_EnableInterrupt(&UartLite); // bootstrap the READ LOG_DEBUG("Bootstrapping READ\n"); XUartLite_Recv(&UartLite, (u8*)&rx_tmp_buffer, sizeof(uint32_t)); LOG_INFO("Starting loop\n"); /* LOG_DEBUG("Sending 'wtf!'\n"); currently_sending = 1; char help[4] = "wtf!"; unsigned int ret = XUartLite_Send(&UartLite, (u8*)help, 4); LOG_DEBUG("WTF send complete return: %x\n", ret); */ /* echo received data forever */ unsigned int heartbeat = 0; while (1) { if (heartbeat++ % (1 << 8)) { //LOG_DEBUG("bump %x\n", heartbeat); } while (cbuffer_size(rx_buffer) && cbuffer_freespace(tx_buffer)) { uint32_t data = cbuffer_pop_front(rx_buffer); //LOG_DEBUG("Echoing data word %x\n", data); cbuffer_push_back(tx_buffer, data); } if (!currently_sending && cbuffer_size(tx_buffer)) { LOG_DEBUG("\nREINT SEND\n"); currently_sending = 1; /* if (XUartLite_IsSending(&UartLite)) { LOG_DEBUG("UART STAT: sending\n"); } else { LOG_DEBUG("UART STAT: idle\n"); } */ unsigned int to_send = cbuffer_contiguous_data_size(tx_buffer) * sizeof(uint32_t); u8* output_ptr = (u8*)&(tx_buffer->data[tx_buffer->pos]); //LOG_DEBUG("REINIT %x\n", to_send); //LOG_DEBUG("SENDADDR %x\n", output_ptr); XUartLite_Send(&UartLite, output_ptr, to_send); } } }