diff options
Diffstat (limited to 'usrp/host/lib')
31 files changed, 5576 insertions, 329 deletions
diff --git a/usrp/host/lib/inband/Makefile.am b/usrp/host/lib/inband/Makefile.am index 017c5c489..76e769fbe 100644 --- a/usrp/host/lib/inband/Makefile.am +++ b/usrp/host/lib/inband/Makefile.am @@ -22,46 +22,74 @@ include $(top_srcdir)/Makefile.common INCLUDES = \ $(DEFINES) $(OMNITHREAD_INCLUDES) $(PMT_INCLUDES) $(MBLOCK_INCLUDES) \ - $(USRP_INCLUDES) $(BOOST_CFLAGS) $(CPPUNIT_INCLUDES) + $(USRP_INCLUDES) $(BOOST_CFLAGS) $(CPPUNIT_INCLUDES) \ + -I$(srcdir)/../../apps TESTS = test_inband EXTRA_DIST = \ - usrp_server.mbh + usrp_server.mbh \ + usrp_interface.mbh + lib_LTLIBRARIES = \ libusrp_inband.la \ - libusrp_inband-qa.la + libusrp_inband-qa.la # ------------------------------------------------------------------------ # Build the inband library BUILT_SOURCES = \ - usrp_server_mbh.cc + usrp_server_mbh.cc \ + usrp_interface_mbh.cc usrp_server_mbh.cc : usrp_server.mbh $(COMPILE_MBH) $(srcdir)/usrp_server.mbh usrp_server_mbh.cc +usrp_interface_mbh.cc : usrp_interface.mbh + $(COMPILE_MBH) usrp_interface.mbh usrp_interface_mbh.cc + libusrp_inband_la_SOURCES = \ $(BUILT_SOURCES) \ - usrp_server.cc + ../../apps/ui_sincos.c \ + usrp_inband_usb_packet.cc \ + usrp_rx.cc \ + usrp_rx_stub.cc \ + usrp_server.cc \ + usrp_tx.cc \ + usrp_tx_stub.cc \ + usrp_usb_interface.cc libusrp_inband_la_LDFLAGS = $(NO_UNDEFINED) -version-info 0:0:0 libusrp_inband_la_LIBADD = \ $(MBLOCK_LA) \ + ../legacy/libusrp.la \ -lstdc++ - include_HEADERS = \ - usrp_server.h + usrp_inband_usb_packet.h \ + usrp_rx.h \ + usrp_rx_stub.h \ + usrp_server.h \ + usrp_tx.h \ + usrp_tx_stub.h \ + usrp_usb_interface.h noinst_HEADERS = \ + fake_usrp.h \ qa_inband.h \ qa_inband_packet_prims.h \ qa_inband_usrp_server.h \ - usrp_inband_usb_packet.h + symbols_usrp_channel.h \ + symbols_usrp_interface_cs.h \ + symbols_usrp_low_level_cs.h \ + symbols_usrp_rx.h \ + symbols_usrp_rx_cs.h \ + symbols_usrp_server_cs.h \ + symbols_usrp_tx.h \ + symbols_usrp_tx_cs.h # ------------------------------------------------------------------------ @@ -79,17 +107,22 @@ libusrp_inband_qa_la_LDFLAGS = $(NO_UNDEFINED) -avoid-version libusrp_inband_qa_la_LIBADD = \ libusrp_inband.la \ $(CPPUNIT_LIBS) \ + ../legacy/libusrp.la \ + libusrp_inband.la \ -lstdc++ # ------------------------------------------------------------------------ noinst_PROGRAMS = \ - test_inband + test_inband \ + test_usrp_inband test_inband_SOURCES = test_inband.cc test_inband_LDADD = libusrp_inband-qa.la +test_usrp_inband_SOURCES = test_usrp_inband.cc +test_usrp_inband_LDADD = libusrp_inband-qa.la + MOSTLYCLEANFILES = \ $(BUILT_SOURCES) *~ *.pyc - diff --git a/usrp/host/lib/inband/fake_usrp.cc b/usrp/host/lib/inband/fake_usrp.cc new file mode 100644 index 000000000..8a66d5c18 --- /dev/null +++ b/usrp/host/lib/inband/fake_usrp.cc @@ -0,0 +1,135 @@ +/* -*- c++ -*- */ +/* + * Copyright 2007 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * GNU Radio is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3, or (at your option) + * any later version. + * + * GNU Radio is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif +#include <fake_usrp.h> +#include <iostream> +#include <usrp_inband_usb_packet.h> +#include <mb_class_registry.h> +#include <vector> + +typedef usrp_inband_usb_packet transport_pkt; // makes conversion to gigabit easy + +fake_usrp::fake_usrp() +{ + std::cout << "[fake_usrp] Initializing...\n"; +} + +fake_usrp::~fake_usrp() {} + +long +fake_usrp::write_bus(transport_pkt *pkts, long n_bytes) +{ + std::cout << "[fake_usrp] Bytes over bus: " << n_bytes << "\n"; + + // I'm assuming that a control packet cannot exist in a burst of data packets, + // therefore i read only the first packet's channel in the current burst + if(pkts[0].chan() == 0x1f) { + return control_block(pkts, n_bytes); + } else { + return data_block(pkts, n_bytes); + } + +} + +long +fake_usrp::data_block(transport_pkt *pkts, long n_bytes) +{ + std::cout << "[fake_usrp] Entering data block\n"; + + // Infer the number of packets from the byte count to do logical tests + long n_pkts = static_cast<long>(std::ceil(n_bytes / (double)transport_pkt::max_pkt_size())); + + std::cout << "[fake_usrp] Number of packets: " << n_pkts << "\n"; + + // The first packet should have the start of burst, and the last packet should have end of burst + if(pkts[0].start_of_burst() && pkts[n_pkts-1].end_of_burst()) { + std::cout << "[fake_usrp] Correct burst flags set\n"; + } else { + std::cout << "[fake_usrp] Incorrect burst flags set!\n"; + return 0; + } + + // All other flags should be set to 0 (e.g., overrun should not be set yet) on ALL packets + for(int i=0; i < n_pkts; i++) { + if(pkts[i].overrun()) { + std::cout << "[fake_usrp] Incorrect set of overrun flag on transmit\n"; + return 0; + } else if(pkts[i].underrun()) { + std::cout << "[fake_usrp] Incorrect set of underrun flag on transmit\n"; + return 0; + } else if(pkts[i].dropped()) { + std::cout << "[fake_usrp] Incorrect set of drop flag on transmit\n"; + return 0; + } + } + std::cout << "[fake_usrp] Correct overrun, underrun, and drop flags on transmit (initialized to 0)\n"; + + // The first packet should have a timestamp, other packets should have "NOW" + if(pkts[0].timestamp() != 0xffffffff) { + std::cout << "[fake_usrp] Correct timestamp on first packet\n"; + } else { + std::cout << "[fake_usrp] Initial packet should not have the 0xffffffff timestamp\n"; + return 0; + } + + // Check that all of the other packets include the NOW timestamp + int check_stamps=1; + for(int i=1; i < n_pkts; i++) // start at 1 to skip the first packet + if(pkts[i].timestamp() != 0xffffffff) + check_stamps=0; + + if(check_stamps) { + std::cout << "[fake_usrp] Correct NOW timestamps (0xffffffff) on intermediate burst packets\n"; + } else { + std::cout << "[fake_usrp] Incorrect timestamps on intermediate burst packets\n"; + return 0; + } + + // Since we are being transparent about samples, we do not ensure the payload is correct, however + // it should be the case that if there are >1 packets, all packets except the last packet should + // have a full payload size + if(n_pkts > 1) { + int check_size=1; + for(int i=0; i < n_pkts-1; i++) + if(pkts[i].payload_len() != transport_pkt::max_payload()) + check_size=0; + + if(check_size) { + std::cout << "[fake_usrp] Correct payload size sanity check on packets\n"; + } else { + std::cout << "[fake_usrp] Failed payload size sanity check\n"; + return 0; + } + } + + return 1; +} + +long +fake_usrp::control_block(transport_pkt *pkts, long n_bytes) +{ + std::cout << "[fake_usrp] Entering control block\n"; + + return 1; +} diff --git a/usrp/host/lib/inband/fake_usrp.h b/usrp/host/lib/inband/fake_usrp.h new file mode 100644 index 000000000..818c5a506 --- /dev/null +++ b/usrp/host/lib/inband/fake_usrp.h @@ -0,0 +1,43 @@ +/* -*- c++ -*- */ +/* + * Copyright 2007 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * GNU Radio is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3, or (at your option) + * any later version. + * + * GNU Radio is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ +#ifndef INCLUDED_FAKE_USRP_H +#define INCLUDED_FAKE_USRP_H + +#include <usrp_inband_usb_packet.h> +typedef usrp_inband_usb_packet transport_pkt; + +/*! + * \brief Implements a fake USRP for testing without hardware + */ +class fake_usrp +{ + public: + fake_usrp(); + ~fake_usrp(); + long write_bus(transport_pkt *pkts, long n_bytes); + + protected: + long data_block(transport_pkt *pkts, long n_bytes); + long control_block(transport_pkt *pkts, long n_bytes); +}; + +#endif /* INCLUDED_FAKE_USRP_H */ + diff --git a/usrp/host/lib/inband/gen_test_packets.py b/usrp/host/lib/inband/gen_test_packets.py index 1e22722d2..2ee646384 100755 --- a/usrp/host/lib/inband/gen_test_packets.py +++ b/usrp/host/lib/inband/gen_test_packets.py @@ -70,7 +70,7 @@ def gen_all_valid_packet_lengths_2_channels(output_file): lengths = gen_shuffled_lengths() npkts = len(lengths) # number of packets we'll generator on each stream pkt_gen_0 = packet_sequence_generator(0, lengths) - pkt_gen_1 = packet_sequence_generator(1, gen_shuffled_lengths()) + pkt_gen_1 = packet_sequence_generator(0x1f, gen_shuffled_lengths()) pkt_gen = (pkt_gen_0, pkt_gen_1) which_gen = (npkts * [0]) + (npkts * [1]) @@ -83,5 +83,6 @@ def gen_all_valid_packet_lengths_2_channels(output_file): assert pkt_gen_1.next() == 16002 # 2*sum(1, 2, ..., 126) == 126 * 127 if __name__ == '__main__': + random.seed(0) gen_all_valid_packet_lengths_1_channel(open("all_valid_packet_lengths_1_channel.dat", "w")) gen_all_valid_packet_lengths_2_channels(open("all_valid_packet_lengths_2_channels.dat", "w")) diff --git a/usrp/host/lib/inband/qa_inband_usrp_server.cc b/usrp/host/lib/inband/qa_inband_usrp_server.cc index 324d9ee11..b01e74e00 100644 --- a/usrp/host/lib/inband/qa_inband_usrp_server.cc +++ b/usrp/host/lib/inband/qa_inband_usrp_server.cc @@ -23,6 +23,7 @@ #include <config.h> #endif +#include <usrp_inband_usb_packet.h> #include <qa_inband_usrp_server.h> #include <cppunit/TestAssert.h> #include <stdio.h> @@ -33,22 +34,17 @@ #include <mb_class_registry.h> #include <vector> #include <iostream> +#include <pmt.h> -static pmt_t s_cmd_allocate_channel = pmt_intern("cmd-allocate-channel"); -static pmt_t s_response_allocate_channel = pmt_intern("response-allocate-channel"); -static pmt_t s_send_allocate_channel = pmt_intern("send-allocate-channel"); -static pmt_t s_cmd_deallocate_channel = pmt_intern("cmd-deallocate-channel"); -static pmt_t s_response_deallocate_channel = pmt_intern("response-deallocate-channel"); -static pmt_t s_send_deallocate_channel = pmt_intern("send-deallocate-channel"); -static pmt_t s_cmd_max_capacity = pmt_intern("cmd-max-capacity"); -static pmt_t s_response_max_capacity = pmt_intern("response-max-capacity"); -static pmt_t s_cmd_ntx_chan = pmt_intern("cmd-ntx-chan"); -static pmt_t s_cmd_nrx_chan = pmt_intern("cmd-nrx-chan"); -static pmt_t s_response_ntx_chan = pmt_intern("response-ntx-chan"); -static pmt_t s_response_nrx_chan = pmt_intern("response-nrx-chan"); -static pmt_t s_cmd_current_capacity_allocation = pmt_intern("cmd-current-capacity-allocation"); -static pmt_t s_response_current_capacity_allocation = pmt_intern("response-current-capacity-allocation"); +#include <symbols_usrp_server_cs.h> +#include <symbols_usrp_tx.h> +#include <symbols_usrp_rx.h> +#include <symbols_usrp_channel.h> +#include <symbols_usrp_low_level_cs.h> +typedef usrp_inband_usb_packet transport_pkt; // makes conversion to gigabit easy + +static bool verbose = false; // ---------------------------------------------------------------------------------------------- @@ -82,16 +78,20 @@ qa_alloc_top::qa_alloc_top(mb_runtime *runtime, const std::string &instance_name : mb_mblock(runtime, instance_name, user_arg) { d_nrecvd=0; - d_nmsgs_to_recv = 7; + d_nmsgs_to_recv = 6; d_nstatus=0; - d_nstatus_to_recv = 3; + d_nstatus_to_recv = 50; d_rx = define_port("rx0", "usrp-rx", false, mb_port::INTERNAL); d_tx = define_port("tx0", "usrp-tx", false, mb_port::INTERNAL); d_cs = define_port("cs", "usrp-server-cs", false, mb_port::INTERNAL); + + // Use the stub with the usrp_server + pmt_t usrp_server_dict = pmt_make_dict(); + pmt_dict_set(usrp_server_dict, pmt_intern("fake-usrp"),PMT_T); // Test the TX side - define_component("server", "usrp_server", PMT_F); + define_component("server", "usrp_server", usrp_server_dict); connect("self", "tx0", "server", "tx0"); connect("self", "rx0", "server", "rx0"); connect("self", "cs", "server", "cs"); @@ -103,42 +103,86 @@ qa_alloc_top::~qa_alloc_top(){} void qa_alloc_top::initial_transition() { + // Allocations should fail before open + d_tx->send(s_cmd_allocate_channel, + pmt_list2(pmt_list2(s_response_allocate_channel, + s_err_usrp_not_opened), + pmt_from_long(1))); + + d_rx->send(s_cmd_allocate_channel, + pmt_list2(pmt_list2(s_response_allocate_channel, + s_err_usrp_not_opened), + pmt_from_long(1))); + // Retrieve information about the USRP, then run tests - d_cs->send(s_cmd_max_capacity, pmt_list1(PMT_F)); - d_cs->send(s_cmd_ntx_chan, pmt_list1(PMT_F)); - d_cs->send(s_cmd_nrx_chan, pmt_list1(PMT_F)); + d_cs->send(s_cmd_open, + pmt_list2(pmt_list2(s_response_open, PMT_T), + pmt_from_long(0))); + + d_cs->send(s_cmd_max_capacity, + pmt_list1(pmt_list2(s_response_max_capacity, PMT_T))); + + d_cs->send(s_cmd_ntx_chan, + pmt_list1(pmt_list2(s_response_ntx_chan, PMT_T))); + + d_cs->send(s_cmd_nrx_chan, + pmt_list1(pmt_list2(s_response_nrx_chan,PMT_T))); } void qa_alloc_top::run_tests() { - std::cout << "[qa_alloc_top] Starting tests...\n"; + if(verbose) + std::cout << "[qa_alloc_top] Starting tests...\n"; + // should be able to allocate 1 byte - d_tx->send(s_cmd_allocate_channel, pmt_list2(PMT_T, pmt_from_long(1))); + d_tx->send(s_cmd_allocate_channel, + pmt_list2(PMT_T, pmt_from_long(1))); // should not be able to allocate max capacity after 100 bytes were allocated - d_tx->send(s_cmd_allocate_channel, pmt_list2(pmt_from_long(usrp_server::RQSTD_CAPACITY_UNAVAIL), pmt_from_long(d_max_capacity))); + d_tx->send(s_cmd_allocate_channel, + pmt_list2(s_err_requested_capacity_unavailable, + pmt_from_long(d_max_capacity))); - // keep allocating a little more until all of the channels are used and test the error response - // we start at 1 since we've already allocated 1 channel + // keep allocating a little more until all of the channels are used and test + // the error response we start at 1 since we've already allocated 1 channel for(int i=1; i < d_ntx_chan; i++) { + + if(verbose) + std::cout << "[qa_alloc_top] Sent allocation request...\n"; + d_tx->send(s_cmd_allocate_channel, pmt_list2(PMT_T, pmt_from_long(1))); + d_nmsgs_to_recv++; } - d_tx->send(s_cmd_allocate_channel, pmt_list2(pmt_from_long(usrp_server::CHANNEL_UNAVAIL), pmt_from_long(1))); + + // No more channels after allocating all of them is expected + d_tx->send(s_cmd_allocate_channel, + pmt_list2(s_err_channel_unavailable, + pmt_from_long(1))); // test out the same on the RX side d_rx->send(s_cmd_allocate_channel, pmt_list2(PMT_T, pmt_from_long(1))); - d_rx->send(s_cmd_allocate_channel, pmt_list2(pmt_from_long(usrp_server::RQSTD_CAPACITY_UNAVAIL), pmt_from_long(d_max_capacity))); + + d_rx->send(s_cmd_allocate_channel, + pmt_list2(s_err_requested_capacity_unavailable, + pmt_from_long(d_max_capacity))); for(int i=1; i < d_nrx_chan; i++) { + d_rx->send(s_cmd_allocate_channel, pmt_list2(PMT_T, pmt_from_long(1))); + d_nmsgs_to_recv++; } - d_rx->send(s_cmd_allocate_channel, pmt_list2(pmt_from_long(usrp_server::CHANNEL_UNAVAIL), pmt_from_long(1))); - // when all is said and done, there should be d_ntx_chan+d_ntx_chan bytes allocated - d_cs->send(s_cmd_current_capacity_allocation, pmt_list1(pmt_from_long(d_ntx_chan+d_nrx_chan))); + d_rx->send(s_cmd_allocate_channel, + pmt_list2(s_err_channel_unavailable, + pmt_from_long(1))); + + // when all is said and done, there should be d_ntx_chan+d_ntx_chan bytes + // allocated + d_cs->send(s_cmd_current_capacity_allocation, + pmt_list1(pmt_from_long(d_ntx_chan+d_nrx_chan))); } void @@ -154,16 +198,22 @@ qa_alloc_top::handle_message(mb_message_sptr msg) if (pmt_eq(msg->port_id(), d_cs->port_symbol())) { if(pmt_eq(msg->signal(), s_response_max_capacity)) { - d_max_capacity = pmt_to_long(pmt_nth(1, data)); - std::cout << "[qa_alloc_top] USRP has max capacity of " << d_max_capacity << "\n"; + d_max_capacity = pmt_to_long(pmt_nth(2, data)); + if(verbose) + std::cout << "[qa_alloc_top] USRP has max capacity of " + << d_max_capacity << "\n"; } else if(pmt_eq(msg->signal(), s_response_ntx_chan)) { - d_ntx_chan = pmt_to_long(pmt_nth(1, data)); - std::cout << "[qa_alloc_top] USRP tx channels: " << d_ntx_chan << "\n"; + d_ntx_chan = pmt_to_long(pmt_nth(2, data)); + if(verbose) + std::cout << "[qa_alloc_top] USRP tx channels: " + << d_ntx_chan << "\n"; } else if(pmt_eq(msg->signal(), s_response_nrx_chan)) { - d_nrx_chan = pmt_to_long(pmt_nth(1, data)); - std::cout << "[qa_alloc_top] USRP rx channels: " << d_nrx_chan << "\n"; + d_nrx_chan = pmt_to_long(pmt_nth(2, data)); + if(verbose) + std::cout << "[qa_alloc_top] USRP rx channels: " + << d_nrx_chan << "\n"; } else if(pmt_eq(msg->signal(), s_response_current_capacity_allocation)) { check_message(msg); @@ -171,6 +221,8 @@ qa_alloc_top::handle_message(mb_message_sptr msg) d_nstatus++; + check_message(msg); + if(d_nstatus==d_nstatus_to_recv) run_tests(); } @@ -180,18 +232,26 @@ void qa_alloc_top::check_message(mb_message_sptr msg) { pmt_t data = msg->data(); + pmt_t event = msg->signal(); + + pmt_t expected = pmt_nth(0, data); + pmt_t status = pmt_nth(1, data); - pmt_t expected_result = pmt_nth(0, data); - pmt_t result = pmt_nth(1, data); + pmt_t e_event = pmt_nth(0, expected); + pmt_t e_status = pmt_nth(1, expected); d_nrecvd++; - if(!pmt_eqv(expected_result, result)) { - std::cout << "Got: " << result << " Expected: " << expected_result << "\n"; + if(!pmt_eqv(e_status, status) || !pmt_eqv(e_event, event)) { + if(verbose) + std::cout << "Got: " << status << " Expected: " << e_status << "\n"; shutdown_all(PMT_F); + return; } else { - std::cout << "[qa_alloc_top] Received expected response for message " << d_nrecvd << "\n"; + if(verbose) + std::cout << "[qa_alloc_top] Received expected response for message " + << d_nrecvd << " (" << event << ")\n"; } if(d_nrecvd == d_nmsgs_to_recv) @@ -242,16 +302,20 @@ qa_dealloc_top::qa_dealloc_top(mb_runtime *runtime, const std::string &instance_ d_ndealloc_recvd=0; d_ndealloc_to_recv = 0; d_nalloc_recvd=0; - d_nalloc_to_recv = 0; + d_nalloc_to_recv = 0; // auto-set d_nstatus=0; - d_nstatus_to_recv = 3; + d_nstatus_to_recv = 4; d_rx = define_port("rx0", "usrp-rx", false, mb_port::INTERNAL); d_tx = define_port("tx0", "usrp-tx", false, mb_port::INTERNAL); d_cs = define_port("cs", "usrp-server-cs", false, mb_port::INTERNAL); + // Use the stub with the usrp_server + pmt_t usrp_server_dict = pmt_make_dict(); + pmt_dict_set(usrp_server_dict, pmt_intern("fake-usrp"),PMT_T); + // Test the TX side - define_component("server", "usrp_server", PMT_F); + define_component("server", "usrp_server", usrp_server_dict); connect("self", "tx0", "server", "tx0"); connect("self", "rx0", "server", "rx0"); connect("self", "cs", "server", "cs"); @@ -262,26 +326,46 @@ qa_dealloc_top::~qa_dealloc_top(){} void qa_dealloc_top::initial_transition() { + + if(verbose) + std::cout << "[qa_dealloc_top] Initializing...\n"; + // Retrieve information about the USRP, then run tests - d_cs->send(s_cmd_max_capacity, pmt_list1(PMT_F)); - d_cs->send(s_cmd_ntx_chan, pmt_list1(PMT_F)); - d_cs->send(s_cmd_nrx_chan, pmt_list1(PMT_F)); + d_cs->send(s_cmd_open, + pmt_list2(pmt_list2(s_response_open,PMT_T), + pmt_from_long(0))); + + d_cs->send(s_cmd_max_capacity, + pmt_list1(pmt_list2(s_response_max_capacity,PMT_T))); + + d_cs->send(s_cmd_ntx_chan, + pmt_list1(pmt_list2(s_response_ntx_chan,PMT_T))); + + d_cs->send(s_cmd_nrx_chan, + pmt_list1(pmt_list2(s_response_nrx_chan,PMT_T))); } void qa_dealloc_top::allocate_max() { - std::cout << "[qa_dealloc_top] Max allocating...\n"; // Keep allocating until we hit the maximum number of channels for(int i=0; i < d_ntx_chan; i++) { - d_tx->send(s_cmd_allocate_channel, pmt_list2(PMT_T, pmt_from_long(1))); + d_tx->send(s_cmd_allocate_channel, + pmt_list2(pmt_list2(s_response_allocate_channel,PMT_T), + pmt_from_long(1))); // 1 byte is good enough + d_nalloc_to_recv++; } + for(int i=0; i < d_nrx_chan; i++) { - d_rx->send(s_cmd_allocate_channel, pmt_list2(PMT_T, pmt_from_long(1))); + d_rx->send(s_cmd_allocate_channel, + pmt_list2(pmt_list2(s_response_allocate_channel,PMT_T), + pmt_from_long(1))); + d_nalloc_to_recv++; } + } void @@ -289,40 +373,103 @@ qa_dealloc_top::deallocate_all() { // Deallocate all of the channels that were allocated from allocate_max() for(int i=0; i < (int)d_tx_chans.size(); i++) { - d_tx->send(s_cmd_deallocate_channel, pmt_list2(PMT_T, pmt_from_long(d_tx_chans[i]))); + + if(verbose) + std::cout << "[qa_dealloc_top] Trying to dealloc TX " + << d_tx_chans[i] << std::endl; + + d_tx->send(s_cmd_deallocate_channel, + pmt_list2(pmt_list2(s_response_deallocate_channel,PMT_T), + pmt_from_long(d_tx_chans[i]))); + d_ndealloc_to_recv++; } + + // Deallocate the RX side now for(int i=0; i < (int)d_rx_chans.size(); i++) { - d_rx->send(s_cmd_deallocate_channel, pmt_list2(PMT_T, pmt_from_long(d_rx_chans[i]))); + + if(verbose) + std::cout << "[qa_dealloc_top] Trying to dealloc RX " + << d_tx_chans[i] << std::endl; + + d_rx->send(s_cmd_deallocate_channel, + pmt_list2(pmt_list2(s_response_deallocate_channel,PMT_T), + pmt_from_long(d_rx_chans[i]))); + d_ndealloc_to_recv++; } - // Should get permission denied errors trying to re-dealloc the channels, as we no - // longer have permission to them after deallocating + // Should get permission denied errors trying to re-dealloc the channels, as + // we no longer have permission to them after deallocating for(int i=0; i < (int)d_tx_chans.size(); i++) { - d_tx->send(s_cmd_deallocate_channel, pmt_list2(pmt_from_long(usrp_server::PERMISSION_DENIED), pmt_from_long(d_tx_chans[i]))); + + d_tx->send(s_cmd_deallocate_channel, + pmt_list2(pmt_list2(s_response_deallocate_channel, + s_err_channel_permission_denied), + pmt_from_long(d_tx_chans[i]))); + d_ndealloc_to_recv++; } + + // Same for RX for(int i=0; i < (int)d_rx_chans.size(); i++) { - d_rx->send(s_cmd_deallocate_channel, pmt_list2(pmt_from_long(usrp_server::PERMISSION_DENIED), pmt_from_long(d_rx_chans[i]))); + + d_rx->send(s_cmd_deallocate_channel, + pmt_list2(pmt_list2(s_response_deallocate_channel, + s_err_channel_permission_denied), + pmt_from_long(d_rx_chans[i]))); + d_ndealloc_to_recv++; } - // Try to deallocate a channel that doesn't exist on both sides, the last element in the vectors - // is the highest channel number, so we take that plus 1 + // Try to deallocate a channel that doesn't exist on both sides, the last + // element in the vectors is the highest channel number, so we take that plus + // 1 d_ndealloc_to_recv+=2; - d_tx->send(s_cmd_deallocate_channel, pmt_list2(pmt_from_long(usrp_server::CHANNEL_INVALID), pmt_from_long(d_rx_chans.back()+1))); - d_rx->send(s_cmd_deallocate_channel, pmt_list2(pmt_from_long(usrp_server::CHANNEL_INVALID), pmt_from_long(d_rx_chans.back()+1))); + d_tx->send(s_cmd_deallocate_channel, + pmt_list2(pmt_list2(s_response_deallocate_channel, + s_err_channel_invalid), + pmt_from_long(d_rx_chans.back()+1))); + + d_rx->send(s_cmd_deallocate_channel, + pmt_list2(pmt_list2(s_response_deallocate_channel, + s_err_channel_invalid), + pmt_from_long(d_rx_chans.back()+1))); // The used capacity should be back to 0 now that we've deallocated everything - d_cs->send(s_cmd_current_capacity_allocation, pmt_list1(pmt_from_long(0))); + d_cs->send(s_cmd_current_capacity_allocation, + pmt_list1(pmt_list2(s_response_current_capacity_allocation, + PMT_T))); } void qa_dealloc_top::handle_message(mb_message_sptr msg) { pmt_t data = msg->data(); + pmt_t event = msg->signal(); + + if(pmt_eq(event, pmt_intern("%shutdown"))) + return; + + pmt_t expected = pmt_nth(0, data); + pmt_t status = pmt_nth(1, data); + + pmt_t e_event = pmt_nth(0, expected); + pmt_t e_status = pmt_nth(1, expected); + + if(!pmt_eqv(e_status, status) || !pmt_eqv(e_event, event)) { + if(verbose) + std::cout << "Got: " << status << " Expected: " << e_status << "\n"; + shutdown_all(PMT_F); + return; + } else { + if(verbose) + std::cout << "[qa_alloc_top] Received expected response for message " + << d_ndealloc_recvd + << " (" << event << ")\n"; + } + if (pmt_eq(msg->port_id(), d_tx->port_symbol()) || pmt_eq(msg->port_id(), d_rx->port_symbol())) { @@ -330,34 +477,32 @@ qa_dealloc_top::handle_message(mb_message_sptr msg) check_allocation(msg); } - if(pmt_eq(msg->signal(), s_response_deallocate_channel)){ - check_deallocation(msg); - } } if (pmt_eq(msg->port_id(), d_cs->port_symbol())) { if(pmt_eq(msg->signal(), s_response_max_capacity)) { - d_max_capacity = pmt_to_long(pmt_nth(1, data)); - std::cout << "[qa_dealloc_top] USRP has max capacity of " << d_max_capacity << "\n"; + d_max_capacity = pmt_to_long(pmt_nth(2, data)); } else if(pmt_eq(msg->signal(), s_response_ntx_chan)) { - d_ntx_chan = pmt_to_long(pmt_nth(1, data)); - std::cout << "[qa_dealloc_top] USRP tx channels: " << d_ntx_chan << "\n"; + d_ntx_chan = pmt_to_long(pmt_nth(2, data)); } else if(pmt_eq(msg->signal(), s_response_nrx_chan)) { - d_nrx_chan = pmt_to_long(pmt_nth(1, data)); - std::cout << "[qa_dealloc_top] USRP rx channels: " << d_nrx_chan << "\n"; + d_nrx_chan = pmt_to_long(pmt_nth(2, data)); } else if(pmt_eq(msg->signal(), s_response_current_capacity_allocation)) { - // the final command is a capacity check which should be 0, then we shutdown - pmt_t expected_result = pmt_nth(0, data); - pmt_t result = pmt_nth(1, data); + // the final command is a capacity check which should be 0, then we + // shutdown + pmt_t expected_result = pmt_from_long(0); + pmt_t result = pmt_nth(2, data); - if(pmt_eqv(expected_result, result)) + if(pmt_eqv(expected_result, result)) { shutdown_all(PMT_T); - else + return; + } else { shutdown_all(PMT_F); + return; + } } d_nstatus++; @@ -367,72 +512,833 @@ qa_dealloc_top::handle_message(mb_message_sptr msg) } } + void -qa_dealloc_top::check_deallocation(mb_message_sptr msg) +qa_dealloc_top::check_allocation(mb_message_sptr msg) { pmt_t data = msg->data(); + pmt_t event = msg->signal(); - pmt_t expected_result = pmt_nth(0, data); - pmt_t result = pmt_nth(1, data); + pmt_t expected = pmt_nth(0, data); + pmt_t status = pmt_nth(1, data); + pmt_t channel = pmt_nth(2, data); - d_ndealloc_recvd++; + d_nalloc_recvd++; - if(!pmt_eqv(expected_result, result)) { - std::cout << "Got: " << result << " Expected: " << expected_result << "\n"; + if(!pmt_eqv(status, PMT_T)) { shutdown_all(PMT_F); + return; } else { - std::cout << "[qa_dealloc_top] Received expected deallocation response for message " << d_ndealloc_recvd << "\n"; + // store all of the allocate channel numbers + if(pmt_eq(msg->port_id(), d_tx->port_symbol())) + d_tx_chans.push_back(pmt_to_long(channel)); + if(pmt_eq(msg->port_id(), d_rx->port_symbol())) + d_rx_chans.push_back(pmt_to_long(channel)); } + + if(d_nalloc_recvd == d_nalloc_to_recv) { + + if(verbose) { + std::cout << "[qa_dealloc_top] Allocated TX channels: "; + for(int i=0; i < (int)d_tx_chans.size(); i++) + std::cout << d_tx_chans[i] << " "; + + std::cout << "\n[qa_dealloc_top] Allocated RX channels: "; + for(int i=0; i < (int)d_rx_chans.size(); i++) + std::cout << d_rx_chans[i] << " "; + std::cout << "\n"; + } + + deallocate_all(); // once we've allocated all of our channels, try to + // dealloc them + } +} + +REGISTER_MBLOCK_CLASS(qa_dealloc_top); + +// ---------------------------------------------------------------------------------------------- + +class qa_open_close_top : public mb_mblock +{ + mb_port_sptr d_cs; + + long d_max_capacity; + + long d_nmsg_to_recv; + long d_nmsg_recvd; + + public: + qa_open_close_top(mb_runtime *runtime, const std::string &instance_name, pmt_t user_arg); + ~qa_open_close_top(); + void initial_transition(); + void handle_message(mb_message_sptr msg); + + protected: + void check_cs(mb_message_sptr msg); + void run_tests(); +}; + +qa_open_close_top::qa_open_close_top(mb_runtime *runtime, const std::string &instance_name, pmt_t user_arg) + : mb_mblock(runtime, instance_name, user_arg) +{ + + d_nmsg_to_recv=7; + d_nmsg_recvd=0; + + d_cs = define_port("cs", "usrp-server-cs", false, mb_port::INTERNAL); + + // Use the stub with the usrp_server + pmt_t usrp_server_dict = pmt_make_dict(); + pmt_dict_set(usrp_server_dict, pmt_intern("fake-usrp"),PMT_T); + + // Test the TX side + define_component("server", "usrp_server", usrp_server_dict); + connect("self", "cs", "server", "cs"); } +qa_open_close_top::~qa_open_close_top(){} + void -qa_dealloc_top::check_allocation(mb_message_sptr msg) +qa_open_close_top::initial_transition() +{ + run_tests(); +} + +void +qa_open_close_top::run_tests() +{ + // std::cout << "[qa_open_close_top] Starting tests\n"; + + // A close before an open should fail + d_cs->send(s_cmd_close, pmt_list1(pmt_list2(s_response_close, + s_err_usrp_already_closed))); + + // Perform an open, and a second open which should fail + d_cs->send(s_cmd_open, + pmt_list2(pmt_list2(s_response_open,PMT_T), + pmt_from_long(0))); + + d_cs->send(s_cmd_open, + pmt_list2(pmt_list2(s_response_open, + s_err_usrp_already_opened), + pmt_from_long(0))); + + // A close should now be successful since the interface is open + d_cs->send(s_cmd_close, pmt_list1(pmt_list2(s_response_close,PMT_T))); + + // But, a second close should fail + d_cs->send(s_cmd_close, pmt_list1(pmt_list2(s_response_close, + s_err_usrp_already_closed))); + + // Just to be thorough, try an open and close again + d_cs->send(s_cmd_open, + pmt_list2(pmt_list2(s_response_open,PMT_T), + pmt_from_long(0))); + + d_cs->send(s_cmd_close, pmt_list1(pmt_list2(s_response_close,PMT_T))); + +} + + +void +qa_open_close_top::handle_message(mb_message_sptr msg) { pmt_t data = msg->data(); - pmt_t invocation_handle = pmt_nth(0, data); + if (pmt_eq(msg->port_id(), d_cs->port_symbol())) { + check_cs(msg); + } + + d_nmsg_recvd++; + + if(d_nmsg_to_recv == d_nmsg_recvd) + shutdown_all(PMT_T); +} + +void +qa_open_close_top::check_cs(mb_message_sptr msg) +{ + pmt_t data = msg->data(); + pmt_t event = msg->signal(); + + pmt_t expected = pmt_nth(0, data); pmt_t status = pmt_nth(1, data); - pmt_t channel = pmt_nth(2, data); + + pmt_t e_event = pmt_nth(0, expected); + pmt_t e_status = pmt_nth(1, expected); + + if(!pmt_eqv(e_status, status) || !pmt_eqv(e_event, event)) { + + if(verbose) + std::cout << "[qa_open_close_top] FAILED check_cs... Got: " << status + << " Expected: " << e_status + << " for event " << event << "\n"; + + shutdown_all(PMT_F); + } else { + if(verbose) + std::cout << "[qa_open_close_top] Received expected CS response (" + << event << ")\n"; + } + +} + +REGISTER_MBLOCK_CLASS(qa_open_close_top); + +// ---------------------------------------------------------------------------------------------- + +class qa_tx_top : public mb_mblock +{ + mb_port_sptr d_tx; + mb_port_sptr d_rx; + mb_port_sptr d_cs; - d_nalloc_recvd++; + long d_max_capacity; + long d_ntx_chan, d_nrx_chan; + + long d_tx_chan; + long d_rx_chan; + + long d_nmsg_to_recv; + long d_nmsg_recvd; + + public: + qa_tx_top(mb_runtime *runtime, const std::string &instance_name, pmt_t user_arg); + ~qa_tx_top(); + void initial_transition(); + void handle_message(mb_message_sptr msg); + + protected: + void check_allocation(mb_message_sptr msg); + void check_deallocation(mb_message_sptr msg); + void check_xmit(mb_message_sptr msg); + void check_cs(mb_message_sptr msg); + void run_tests(); +}; - if(pmt_eqv(status, PMT_F)) { - std::cout << "[qa_dealloc_top] Unexpected error response when allocating channels\n"; +qa_tx_top::qa_tx_top(mb_runtime *runtime, const std::string &instance_name, pmt_t user_arg) + : mb_mblock(runtime, instance_name, user_arg) +{ + + d_nmsg_to_recv=10; + d_nmsg_recvd=0; + + d_rx = define_port("rx0", "usrp-rx", false, mb_port::INTERNAL); + d_tx = define_port("tx0", "usrp-tx", false, mb_port::INTERNAL); + d_cs = define_port("cs", "usrp-server-cs", false, mb_port::INTERNAL); + + // Use the stub with the usrp_server + pmt_t usrp_server_dict = pmt_make_dict(); + pmt_dict_set(usrp_server_dict, pmt_intern("fake-usrp"),PMT_T); + + // Test the TX side + define_component("server", "usrp_server", usrp_server_dict); + connect("self", "tx0", "server", "tx0"); + connect("self", "rx0", "server", "rx0"); + connect("self", "cs", "server", "cs"); +} + +qa_tx_top::~qa_tx_top(){} + +void +qa_tx_top::initial_transition() +{ + run_tests(); +} + +void +qa_tx_top::run_tests() +{ + if(verbose) + std::cout << "[qa_tx_top] Starting tests\n"; + + // A transmit before an open should fail + d_tx->send(s_cmd_xmit_raw_frame, + pmt_list4(pmt_list2(s_response_xmit_raw_frame, + s_err_usrp_not_opened), + pmt_from_long(0), + pmt_make_u32vector(transport_pkt::max_payload()/4, 0), + pmt_from_long(0))); + + // Now open + d_cs->send(s_cmd_open, + pmt_list2(pmt_list2(s_response_open,PMT_T), + pmt_from_long(0))); + + // Try to transmit on a channel that we have no allocation for + d_tx->send(s_cmd_xmit_raw_frame, + pmt_list4(pmt_list2(s_response_xmit_raw_frame, + s_err_channel_permission_denied), + pmt_from_long(0), + pmt_make_u32vector(transport_pkt::max_payload()/4, 0), + pmt_from_long(0))); + + // Get a channel allocation and send on it, we assume 0 (FIXME) until 'defer' + // is implemented for simplicity + d_tx->send(s_cmd_allocate_channel, + pmt_list2(pmt_list2(s_response_allocate_channel, PMT_T), + pmt_from_long(1))); + + d_tx->send(s_cmd_xmit_raw_frame, + pmt_list4(pmt_list2(s_response_xmit_raw_frame, PMT_T), + pmt_from_long(0), + pmt_make_u32vector(transport_pkt::max_payload()/4, 0), + pmt_from_long(0))); + + // Close should be successful + d_cs->send(s_cmd_close, pmt_list1(pmt_list2(s_response_close,PMT_T))); + + // After closing, a new transmit raw frame should fail again + d_tx->send(s_cmd_xmit_raw_frame, + pmt_list4(pmt_list2(s_response_xmit_raw_frame, + s_err_usrp_not_opened), + pmt_from_long(0), + pmt_make_u32vector(transport_pkt::max_payload()/4, 0), + pmt_from_long(0))); + + // Reopen and retry before getting an allocation, the first xmit should fail, + // after we allocate it should work again + d_cs->send(s_cmd_open, + pmt_list2(pmt_list2(s_response_open, PMT_T), + pmt_from_long(0))); + + d_tx->send(s_cmd_xmit_raw_frame, + pmt_list4(pmt_list2(s_response_xmit_raw_frame, + s_err_channel_permission_denied), + pmt_from_long(0), + pmt_make_u32vector(transport_pkt::max_payload()/4, 0), + pmt_from_long(0))); + + d_tx->send(s_cmd_allocate_channel, + pmt_list2(pmt_list2(s_response_allocate_channel, PMT_T), + pmt_from_long(1))); + + d_tx->send(s_cmd_xmit_raw_frame, + pmt_list4(pmt_list2(s_response_xmit_raw_frame,PMT_T), + pmt_from_long(0), + pmt_make_u32vector(transport_pkt::max_payload()/4, 0), + pmt_from_long(0))); + + // A final close which should be successful + d_cs->send(s_cmd_close, pmt_list1(pmt_list2(s_response_close,PMT_T))); + +} + + +void +qa_tx_top::handle_message(mb_message_sptr msg) +{ + pmt_t data = msg->data(); + pmt_t event = msg->signal(); + + if(pmt_eq(event, pmt_intern("%shutdown"))) + return; + + pmt_t expected = pmt_nth(0, data); + pmt_t status = pmt_nth(1, data); + + pmt_t e_event = pmt_nth(0, expected); + pmt_t e_status = pmt_nth(1, expected); + + if(!pmt_eqv(e_status, status) || !pmt_eqv(e_event, event)) { + if(verbose) + std::cout << "[qa_xmit_top] Got: " << status + << " Expected: " << e_status + << "For signal: " << event << "\n"; shutdown_all(PMT_F); + return; } else { + if(verbose) + std::cout << "[qa_xmit_top] Received expected response for message " + << d_nmsg_recvd + << " (" << event << ")\n"; + } + + if (pmt_eq(msg->port_id(), d_tx->port_symbol()) + || pmt_eq(msg->port_id(), d_rx->port_symbol())) { + + if(pmt_eq(msg->signal(), s_response_allocate_channel)) + check_allocation(msg); + + } + + d_nmsg_recvd++; + + if(d_nmsg_to_recv == d_nmsg_recvd){ + shutdown_all(PMT_T); + return; + } +} + +void +qa_tx_top::check_allocation(mb_message_sptr msg) +{ + pmt_t data = msg->data(); + pmt_t event = msg->signal(); + + pmt_t expected = pmt_nth(0, data); + pmt_t status = pmt_nth(1, data); + pmt_t channel = pmt_nth(2, data); + + if(pmt_eqv(status, PMT_T)) { // store all of the allocate channel numbers if(pmt_eq(msg->port_id(), d_tx->port_symbol())) - d_tx_chans.push_back(pmt_to_long(channel)); + d_tx_chan = pmt_to_long(channel); if(pmt_eq(msg->port_id(), d_rx->port_symbol())) - d_rx_chans.push_back(pmt_to_long(channel)); + d_rx_chan = pmt_to_long(channel); } +} - if(d_nalloc_recvd == d_nalloc_to_recv) { +REGISTER_MBLOCK_CLASS(qa_tx_top); + +// ---------------------------------------------------------------------------------------------- + +class qa_rx_top : public mb_mblock +{ + mb_port_sptr d_rx; + mb_port_sptr d_cs; + + long d_max_capacity; + long d_ntx_chan, d_nrx_chan; + + long d_rx_chan; + + long d_got_response_recv; + + long d_nmsg_to_recv; + long d_nmsg_recvd; + + public: + qa_rx_top(mb_runtime *runtime, const std::string &instance_name, pmt_t user_arg); + ~qa_rx_top(); + void initial_transition(); + void handle_message(mb_message_sptr msg); + + protected: + void check_allocation(mb_message_sptr msg); + void check_deallocation(mb_message_sptr msg); + void check_xmit(mb_message_sptr msg); + void check_cs(mb_message_sptr msg); + void run_tests(); +}; + +qa_rx_top::qa_rx_top(mb_runtime *runtime, const std::string &instance_name, pmt_t user_arg) + : mb_mblock(runtime, instance_name, user_arg), + d_got_response_recv(false) +{ + + d_nmsg_to_recv=12; + d_nmsg_recvd=0; + + d_rx = define_port("rx0", "usrp-rx", false, mb_port::INTERNAL); + d_cs = define_port("cs", "usrp-server-cs", false, mb_port::INTERNAL); + + // Use the stub with the usrp_server + pmt_t usrp_server_dict = pmt_make_dict(); + pmt_dict_set(usrp_server_dict, pmt_intern("fake-usrp"), PMT_T); + + // Test the TX side + define_component("server", "usrp_server", usrp_server_dict); + connect("self", "rx0", "server", "rx0"); + connect("self", "cs", "server", "cs"); +} + +qa_rx_top::~qa_rx_top(){} + +void +qa_rx_top::initial_transition() +{ + run_tests(); +} + +void +qa_rx_top::run_tests() +{ + if(verbose) + std::cout << "[qa_rx_top] Starting tests\n"; + + d_cs->send(s_cmd_open, pmt_list2(pmt_list2(s_response_open,PMT_T), pmt_from_long(0))); + + d_rx->send(s_cmd_allocate_channel, + pmt_list2(pmt_list2(s_response_allocate_channel,PMT_T), + pmt_from_long(1))); + + d_rx->send(s_cmd_start_recv_raw_samples, + pmt_list2(PMT_NIL, + pmt_from_long(0))); + + // A small sleep is used to ensure, if working properly, a recv + // response comes through successfully before the close gets + // through + usleep(1000); + + d_rx->send(s_cmd_stop_recv_raw_samples, + pmt_list2(PMT_NIL, + pmt_from_long(0))); + + d_cs->send(s_cmd_close, pmt_list1(pmt_list2(s_response_close,PMT_T))); + +} + + +void +qa_rx_top::handle_message(mb_message_sptr msg) +{ + pmt_t data = msg->data(); + pmt_t event = msg->signal(); + + if(pmt_eq(event, pmt_intern("%shutdown"))) + return; + + pmt_t expected = pmt_nth(0, data); + pmt_t status = pmt_nth(1, data); + + // For testing RX, an invocation handle is not generated by the stub, + // therefore the same approach for testing is not used. We simply + // expect all responses to be true. + if(pmt_eq(event, s_response_recv_raw_samples)) { + if(!pmt_eqv(status, PMT_T)) { + if(verbose) + std::cout << "Got: " << status << " Expected: " << PMT_T << "\n"; + shutdown_all(PMT_F); + return; + } + else { + if(verbose) + std::cout << "[qa_rx_top] Received expected response for message " + << d_nmsg_recvd + << " (" << event << ")\n"; + + // All we want is 1 response receive! Can't guarantee exact numbers + d_got_response_recv = true; + } + return; + } + + pmt_t e_event = pmt_nth(0, expected); + pmt_t e_status = pmt_nth(1, expected); + + if(!pmt_eqv(e_status, status) || !pmt_eqv(e_event, event)) { + if(verbose) + std::cout << "Got: " << status << " Expected: " << e_status << "\n"; + shutdown_all(PMT_F); + return; + } else { + if(verbose) + std::cout << "[qa_rx_top] Received expected response for message " + << d_nmsg_recvd + << " (" << event << ")\n"; + } + + if (pmt_eq(msg->port_id(), d_rx->port_symbol())) { + + if(pmt_eq(msg->signal(), s_response_allocate_channel)) + check_allocation(msg); + + } + + // We stop when we get a close, we are successful if we + // got a response from recv, fail if we never got a recv response + if(pmt_eq(msg->signal(), s_response_close)) { - std::cout << "[qa_dealloc_top] Allocated TX channels: "; - for(int i=0; i < (int)d_tx_chans.size(); i++) - std::cout << d_tx_chans[i] << " "; + if(d_got_response_recv) { + shutdown_all(PMT_T); + return; + } + else { + shutdown_all(PMT_F); + if(verbose) + std::cout << "[qa_rx_top] No response message before close\n"; + return; + } + + } + + + d_nmsg_recvd++; + +} - std::cout << "\n[qa_dealloc_top] Allocated RX channels: "; - for(int i=0; i < (int)d_rx_chans.size(); i++) - std::cout << d_rx_chans[i] << " "; - std::cout << "\n"; - deallocate_all(); // once we've allocated all of our channels, try to dealloc them +void +qa_rx_top::check_allocation(mb_message_sptr msg) +{ + pmt_t data = msg->data(); + pmt_t event = msg->signal(); + + pmt_t expected = pmt_nth(0, data); + pmt_t status = pmt_nth(1, data); + pmt_t channel = pmt_nth(2, data); + + if(pmt_eqv(status, PMT_T)) { + // store all of the allocate channel numbers + if(pmt_eq(msg->port_id(), d_rx->port_symbol())) + d_rx_chan = pmt_to_long(channel); } } -REGISTER_MBLOCK_CLASS(qa_dealloc_top); +REGISTER_MBLOCK_CLASS(qa_rx_top); + + +// ---------------------------------------------------------------------------------------------- + +class qa_cs_top : public mb_mblock +{ + mb_port_sptr d_tx; + mb_port_sptr d_rx; + mb_port_sptr d_cs; + + long d_nmsgs_to_recv; + long d_nrecvd; + + long d_max_capacity; + long d_ntx_chan, d_nrx_chan; + + long d_nstatus; + long d_nstatus_to_recv; + + public: + qa_cs_top(mb_runtime *runtime, const std::string &instance_name, pmt_t user_arg); + ~qa_cs_top(); + void initial_transition(); + void handle_message(mb_message_sptr msg); + + protected: + void check_message(mb_message_sptr msg); + void run_tests(); +}; + +qa_cs_top::qa_cs_top(mb_runtime *runtime, const std::string &instance_name, pmt_t user_arg) + : mb_mblock(runtime, instance_name, user_arg) +{ + d_nrecvd=0; + d_nmsgs_to_recv = 8; + d_nstatus=0; + d_nstatus_to_recv = 50; + + d_rx = define_port("rx0", "usrp-rx", false, mb_port::INTERNAL); + d_tx = define_port("tx0", "usrp-tx", false, mb_port::INTERNAL); + d_cs = define_port("cs", "usrp-server-cs", false, mb_port::INTERNAL); + + // Use the stub with the usrp_server + pmt_t usrp_server_dict = pmt_make_dict(); + pmt_dict_set(usrp_server_dict, pmt_intern("fake-usrp"),PMT_T); + + // Test the TX side + define_component("server", "usrp_server", usrp_server_dict); + connect("self", "tx0", "server", "tx0"); + connect("self", "rx0", "server", "rx0"); + connect("self", "cs", "server", "cs"); + +} + +qa_cs_top::~qa_cs_top(){} + +void +qa_cs_top::initial_transition() +{ + run_tests(); +} + +void +qa_cs_top::run_tests() +{ + if(verbose) + std::cout << "[qa_cs_top] Starting tests...\n"; + + // Retrieve information about the USRP, then run tests + d_cs->send(s_cmd_open, + pmt_list2(pmt_list2(s_response_open, PMT_T), + pmt_from_long(0))); + + // should be able to allocate 1 byte + d_tx->send(s_cmd_allocate_channel, + pmt_list2(pmt_list2(s_response_allocate_channel, PMT_T), + pmt_from_long(1))); + + d_rx->send(s_cmd_allocate_channel, + pmt_list2(pmt_list2(s_response_allocate_channel, PMT_T), + pmt_from_long(1))); + + // Need to start receiving to read from the USRP to get C/S responses + d_rx->send(s_cmd_start_recv_raw_samples, + pmt_list2(PMT_NIL, + pmt_from_long(0))); + + d_tx->send(s_cmd_to_control_channel, + pmt_list2(pmt_list2(s_response_from_control_channel, PMT_T), + pmt_list1( + pmt_list2(s_op_ping_fixed, + pmt_list2(pmt_from_long(3), + pmt_from_long(0)))))); + + d_tx->send(s_cmd_to_control_channel, + pmt_list2(pmt_list2(s_response_from_control_channel, PMT_T), + pmt_list1( + pmt_list2(s_op_write_reg, + pmt_list2( + pmt_from_long(0x3), + pmt_from_long(0x4)))))); + + d_tx->send(s_cmd_to_control_channel, + pmt_list2(pmt_list2(s_response_from_control_channel, PMT_T), + pmt_list1( + pmt_list2(s_op_write_reg_masked, + pmt_list3( + pmt_from_long(0x3), + pmt_from_long(0x4), + pmt_from_long(0x5)))))); + + d_tx->send(s_cmd_to_control_channel, + pmt_list2(pmt_list2(s_response_from_control_channel, PMT_T), + pmt_list1( + pmt_list2(s_op_read_reg, + pmt_list2(pmt_from_long(0), + pmt_from_long(0x6)))))); + + d_tx->send(s_cmd_to_control_channel, + pmt_list2(pmt_list2(s_response_from_control_channel, PMT_T), + pmt_list1( + pmt_list2(s_op_delay, + pmt_list1(pmt_from_long(0x7)))))); + + pmt_t subpackets = pmt_list5( + pmt_list2(s_op_ping_fixed, pmt_list2(pmt_from_long(0), pmt_from_long(0))), + pmt_list2(s_op_delay, pmt_list1(pmt_from_long(0x7))), + pmt_list2(s_op_write_reg_masked, pmt_list3(pmt_from_long(3), + pmt_from_long(4), + pmt_from_long(5))), + pmt_list2(s_op_write_reg, pmt_list2(pmt_from_long(3), + pmt_from_long(4))), + pmt_list2(s_op_read_reg, pmt_list2(pmt_from_long(0), + pmt_from_long(6))) + ); + + d_tx->send(s_cmd_to_control_channel, + pmt_list2(pmt_list2(s_response_from_control_channel, PMT_T), + subpackets)); + + pmt_t i2c_data = pmt_make_u8vector(8, 0xff); + + subpackets = pmt_list2( + pmt_list2(s_op_i2c_write, + pmt_list2(pmt_from_long(8), i2c_data)), + pmt_list2(s_op_i2c_read, + pmt_list3(pmt_from_long(0), pmt_from_long(9), pmt_from_long(1))) + + ); + + d_tx->send(s_cmd_to_control_channel, + pmt_list2(pmt_list2(s_response_from_control_channel, PMT_T), + subpackets)); + +} + +void +qa_cs_top::handle_message(mb_message_sptr msg) +{ + pmt_t data = msg->data(); + + if ((pmt_eq(msg->port_id(), d_tx->port_symbol()) + || pmt_eq(msg->port_id(), d_rx->port_symbol())) + && pmt_eq(msg->signal(), s_response_allocate_channel)) + check_message(msg); + + if (pmt_eq(msg->port_id(), d_tx->port_symbol()) + && pmt_eq(msg->signal(), s_response_from_control_channel)) + check_message(msg); + + if (pmt_eq(msg->port_id(), d_cs->port_symbol())) { + + if(pmt_eq(msg->signal(), s_response_max_capacity)) { + d_max_capacity = pmt_to_long(pmt_nth(2, data)); + if(verbose) + std::cout << "[qa_cs_top] USRP has max capacity of " + << d_max_capacity << "\n"; + } + else if(pmt_eq(msg->signal(), s_response_ntx_chan)) { + d_ntx_chan = pmt_to_long(pmt_nth(2, data)); + if(verbose) + std::cout << "[qa_cs_top] USRP tx channels: " + << d_ntx_chan << "\n"; + } + else if(pmt_eq(msg->signal(), s_response_nrx_chan)) { + d_nrx_chan = pmt_to_long(pmt_nth(2, data)); + if(verbose) + std::cout << "[qa_cs_top] USRP rx channels: " + << d_nrx_chan << "\n"; + } + else if(pmt_eq(msg->signal(), s_response_current_capacity_allocation)) { + check_message(msg); + } + + d_nstatus++; + + check_message(msg); + + if(d_nstatus==d_nstatus_to_recv) + run_tests(); + } +} + +void +qa_cs_top::check_message(mb_message_sptr msg) +{ + pmt_t data = msg->data(); + pmt_t event = msg->signal(); + + pmt_t expected = pmt_nth(0, data); + pmt_t status = pmt_nth(1, data); + + pmt_t e_event = pmt_nth(0, expected); + pmt_t e_status = pmt_nth(1, expected); + + d_nrecvd++; + + + if(!pmt_eqv(e_status, status) || !pmt_eqv(e_event, event)) { + if(verbose) + std::cout << "[qa_cs_top] Got: " << status << " Expected: " << e_status << "\n"; + shutdown_all(PMT_F); + return; + } else { + if(verbose) + std::cout << "[qa_cs_top] Received expected response for message " + << d_nrecvd << " (" << event << ")\n"; + } + + if(d_nrecvd == d_nmsgs_to_recv) + shutdown_all(PMT_T); +} + +REGISTER_MBLOCK_CLASS(qa_cs_top); // ---------------------------------------------------------------------------------------------- void +qa_inband_usrp_server::test_open_close() +{ + mb_runtime_sptr rt = mb_make_runtime(); + pmt_t result = PMT_T; + + // std::cout << "\n\n----------------------------\n"; + // std::cout << " RUNNING OPEN/CLOSE TESTS \n"; + + rt->run("top", "qa_open_close_top", PMT_F, &result); + + CPPUNIT_ASSERT(pmt_equal(PMT_T, result)); +} + +void qa_inband_usrp_server::test_chan_allocation() { mb_runtime_sptr rt = mb_make_runtime(); pmt_t result = PMT_T; - rt->run("top", "qa_alloc_top", PMT_F, &result); + // std::cout << "\n\n----------------------------\n"; + // std::cout << " RUNNING ALLOCATION TESTS \n"; + + rt->run("qa_alloc_top", "qa_alloc_top", PMT_F, &result); CPPUNIT_ASSERT(pmt_equal(PMT_T, result)); } @@ -443,13 +1349,52 @@ qa_inband_usrp_server::test_chan_deallocation() mb_runtime_sptr rt = mb_make_runtime(); pmt_t result = PMT_T; - rt->run("top", "qa_dealloc_top", PMT_F, &result); + // std::cout << "\n\n----------------------------\n"; + // std::cout << " RUNNING DEALLOCATION TESTS \n"; + + rt->run("qa_dealloc_top", "qa_dealloc_top", PMT_F, &result); + + CPPUNIT_ASSERT(pmt_equal(PMT_T, result)); +} + +void +qa_inband_usrp_server::test_tx() +{ + mb_runtime_sptr rt = mb_make_runtime(); + pmt_t result = PMT_T; + + // std::cout << "\n\n-----------------\n"; + // std::cout << " RUNNING TX TESTS \n"; + + rt->run("top", "qa_tx_top", PMT_F, &result); + + CPPUNIT_ASSERT(pmt_equal(PMT_T, result)); +} + +void +qa_inband_usrp_server::test_rx() +{ + mb_runtime_sptr rt = mb_make_runtime(); + pmt_t result = PMT_T; + + // std::cout << "\n\n-----------------\n"; + // std::cout << " RUNNING RX TESTS \n"; + + rt->run("top", "qa_rx_top", PMT_F, &result); CPPUNIT_ASSERT(pmt_equal(PMT_T, result)); } void -qa_inband_usrp_server::test_fragmentation() +qa_inband_usrp_server::test_cs() { + mb_runtime_sptr rt = mb_make_runtime(); + pmt_t result = PMT_T; + + // std::cout << "\n\n-----------------\n"; + // std::cout << " RUNNING CS TESTS \n"; + + rt->run("top", "qa_cs_top", PMT_F, &result); + CPPUNIT_ASSERT(pmt_equal(PMT_T, result)); } diff --git a/usrp/host/lib/inband/qa_inband_usrp_server.h b/usrp/host/lib/inband/qa_inband_usrp_server.h index 91cf7d87c..5db57c3ed 100644 --- a/usrp/host/lib/inband/qa_inband_usrp_server.h +++ b/usrp/host/lib/inband/qa_inband_usrp_server.h @@ -28,15 +28,21 @@ class qa_inband_usrp_server : public CppUnit::TestCase { CPPUNIT_TEST_SUITE(qa_inband_usrp_server); + CPPUNIT_TEST(test_open_close); CPPUNIT_TEST(test_chan_allocation); CPPUNIT_TEST(test_chan_deallocation); - CPPUNIT_TEST(test_fragmentation); + CPPUNIT_TEST(test_tx); + CPPUNIT_TEST(test_rx); + CPPUNIT_TEST(test_cs); CPPUNIT_TEST_SUITE_END(); private: void test_chan_allocation(); void test_chan_deallocation(); - void test_fragmentation(); + void test_open_close(); + void test_tx(); + void test_rx(); + void test_cs(); }; #endif /* INCLUDED_QA_INBAND_USRP_SERVER_H */ diff --git a/usrp/host/lib/inband/symbols_usrp_channel.h b/usrp/host/lib/inband/symbols_usrp_channel.h new file mode 100644 index 000000000..a0114cf3c --- /dev/null +++ b/usrp/host/lib/inband/symbols_usrp_channel.h @@ -0,0 +1,40 @@ +/* -*- c++ -*- */ +/* + * Copyright 2007 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * GNU Radio is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3, or (at your option) + * any later version. + * + * GNU Radio is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ +#ifndef INCLUDED_SYMBOLS_USRP_CHANNEL_H +#define INCLUDED_SYMBOLS_USRP_CHANNEL_H + +#include <pmt.h> + +// Outgoing +static pmt_t s_cmd_allocate_channel = pmt_intern("cmd-allocate-channel"); +static pmt_t s_cmd_deallocate_channel = pmt_intern("cmd-deallocate-channel"); + +// Incoming +static pmt_t s_response_allocate_channel = pmt_intern("response-allocate-channel"); +static pmt_t s_response_deallocate_channel = pmt_intern("response-deallocate-channel"); + +// Errors +static pmt_t s_err_requested_capacity_unavailable = pmt_intern("err-requested-capacity-unavailable"); +static pmt_t s_err_channel_unavailable = pmt_intern("err-channel-unavailable"); +static pmt_t s_err_channel_invalid = pmt_intern("err-channel-invalid"); +static pmt_t s_err_channel_permission_denied = pmt_intern("err-channel-permission-denied"); + +#endif /* INCLUDED_SYMBOLS_USRP_CHANNEL_H */ diff --git a/usrp/host/lib/inband/symbols_usrp_interface_cs.h b/usrp/host/lib/inband/symbols_usrp_interface_cs.h new file mode 100644 index 000000000..72c8fcc91 --- /dev/null +++ b/usrp/host/lib/inband/symbols_usrp_interface_cs.h @@ -0,0 +1,43 @@ +/* -*- c++ -*- */ +/* + * Copyright 2007 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * GNU Radio is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3, or (at your option) + * any later version. + * + * GNU Radio is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ +#ifndef INCLUDED_SYMBOLS_USRP_INTERFACE_CS_H +#define INCLUDED_SYMBOLS_USRP_INTERFACE_CS_H + +#include <pmt.h> + +// Outgoing +static pmt_t s_cmd_usrp_open = pmt_intern("cmd-usrp-open"); +static pmt_t s_cmd_usrp_close = pmt_intern("cmd-usrp-close"); +static pmt_t s_cmd_usrp_ntx_chan = pmt_intern("cmd-usrp-ntx-chan"); +static pmt_t s_cmd_usrp_nrx_chan = pmt_intern("cmd-usrp-nrx-chan"); +static pmt_t s_cmd_usrp_write = pmt_intern("cmd-usrp-write"); +static pmt_t s_cmd_usrp_start_reading = pmt_intern("cmd-usrp-start-reading"); +static pmt_t s_cmd_usrp_stop_reading = pmt_intern("cmd-usrp-stop-reading"); + +// Incoming +static pmt_t s_response_usrp_open = pmt_intern("response-usrp-open"); +static pmt_t s_response_usrp_close = pmt_intern("response-usrp-close"); +static pmt_t s_response_usrp_ntx_chan = pmt_intern("response-usrp-ntx-chan"); +static pmt_t s_response_usrp_nrx_chan = pmt_intern("response-usrp-nrx-chan"); +static pmt_t s_response_usrp_write = pmt_intern("response-usrp-write"); +static pmt_t s_response_usrp_read = pmt_intern("response-usrp-read"); + +#endif /* INCLUDED_SYMBOLS_USRP_INTERFACE_CS_H */ diff --git a/usrp/host/lib/inband/symbols_usrp_low_level_cs.h b/usrp/host/lib/inband/symbols_usrp_low_level_cs.h new file mode 100644 index 000000000..a7260603a --- /dev/null +++ b/usrp/host/lib/inband/symbols_usrp_low_level_cs.h @@ -0,0 +1,47 @@ +/* -*- c++ -*- */ +/* + * Copyright 2007 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * GNU Radio is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3, or (at your option) + * any later version. + * + * GNU Radio is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ +#ifndef INCLUDED_SYMBOLS_USRP_LOW_LEVEL_CS_H +#define INCLUDED_SYMBOLS_USRP_LOW_LEVEL_CS_H + +#include <pmt.h> + +// Outgoing +static pmt_t s_cmd_to_control_channel = pmt_intern("cmd-to-control-channel"); + +// Incoming +static pmt_t s_response_from_control_channel = pmt_intern("response-from-control-channel"); + +// Subpackets +static pmt_t s_op_ping_fixed = pmt_intern("op-ping-fixed"); +static pmt_t s_op_ping_fixed_reply = pmt_intern("op-ping-fixed-reply"); +static pmt_t s_op_write_reg = pmt_intern("op-write-reg"); +static pmt_t s_op_write_reg_masked = pmt_intern("op-write-reg-masked"); +static pmt_t s_op_read_reg = pmt_intern("op-read-reg"); +static pmt_t s_op_read_reg_reply = pmt_intern("op-read-reg-reply"); +static pmt_t s_op_i2c_write = pmt_intern("op-i2c-write"); +static pmt_t s_op_i2c_read = pmt_intern("op-i2c-read"); +static pmt_t s_op_i2c_read_reply = pmt_intern("op-i2c-read-reply"); +static pmt_t s_op_spi_write = pmt_intern("op-spi-write"); +static pmt_t s_op_spi_read = pmt_intern("op-spi-read"); +static pmt_t s_op_spi_read_reply = pmt_intern("op-spi-read-reply"); +static pmt_t s_op_delay = pmt_intern("op-delay"); + +#endif /* INCLUDED_SYMBOLS_USRP_LOW_LEVEL_CS_H */ diff --git a/usrp/host/lib/inband/symbols_usrp_rx.h b/usrp/host/lib/inband/symbols_usrp_rx.h new file mode 100644 index 000000000..07d58a3f5 --- /dev/null +++ b/usrp/host/lib/inband/symbols_usrp_rx.h @@ -0,0 +1,36 @@ +/* -*- c++ -*- */ +/* + * Copyright 2007 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * GNU Radio is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3, or (at your option) + * any later version. + * + * GNU Radio is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ +#ifndef INCLUDED_SYMBOLS_USRP_RX_H +#define INCLUDED_SYMBOLS_USRP_RX_H + +#include <pmt.h> + +// Outgoing +static pmt_t s_cmd_start_recv_raw_samples = pmt_intern("cmd-start-recv-raw-samples"); +static pmt_t s_cmd_stop_recv_raw_samples = pmt_intern("cmd-stop-recv-raw-samples"); + +// Incoming +static pmt_t s_response_recv_raw_samples = pmt_intern("response-recv-raw-samples"); + +// Errors +static pmt_t s_err_already_receiving = pmt_intern("err-already-receiving"); + +#endif /* INCLUDED_SYMBOLS_USRP_RX_H */ diff --git a/usrp/host/lib/inband/symbols_usrp_rx_cs.h b/usrp/host/lib/inband/symbols_usrp_rx_cs.h new file mode 100644 index 000000000..bf4f0338b --- /dev/null +++ b/usrp/host/lib/inband/symbols_usrp_rx_cs.h @@ -0,0 +1,32 @@ +/* -*- c++ -*- */ +/* + * Copyright 2007 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * GNU Radio is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3, or (at your option) + * any later version. + * + * GNU Radio is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ +#ifndef INCLUDED_SYMBOLS_USRP_RX_CS_H +#define INCLUDED_SYMBOLS_USRP_RX_CS_H + +#include <pmt.h> + +// Outgoing +static pmt_t s_cmd_usrp_rx_start_reading = pmt_intern("cmd-usrp-rx-start-reading"); + +// Incoming +static pmt_t s_response_usrp_rx_read = pmt_intern("response-usrp-rx-read"); + +#endif /* INCLUDED_SYMBOLS_USRP_RX_CS_H */ diff --git a/usrp/host/lib/inband/symbols_usrp_server_cs.h b/usrp/host/lib/inband/symbols_usrp_server_cs.h new file mode 100644 index 000000000..e612e24ea --- /dev/null +++ b/usrp/host/lib/inband/symbols_usrp_server_cs.h @@ -0,0 +1,47 @@ +/* -*- c++ -*- */ +/* + * Copyright 2007 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * GNU Radio is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3, or (at your option) + * any later version. + * + * GNU Radio is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ +#ifndef INCLUDED_SYMBOLS_USRP_SERVER_CS_H +#define INCLUDED_SYMBOLS_USRP_SERVER_CS_H + +#include <pmt.h> + +// Outgoing +static pmt_t s_cmd_open = pmt_intern("cmd-open"); +static pmt_t s_cmd_close = pmt_intern("cmd-close"); +static pmt_t s_cmd_max_capacity = pmt_intern("cmd-max-capacity"); +static pmt_t s_cmd_ntx_chan = pmt_intern("cmd-ntx-chan"); +static pmt_t s_cmd_nrx_chan = pmt_intern("cmd-nrx-chan"); +static pmt_t s_cmd_current_capacity_allocation = pmt_intern("cmd-current-capacity-allocation"); + +// Incoming +static pmt_t s_response_open = pmt_intern("response-open"); +static pmt_t s_response_close = pmt_intern("response-close"); +static pmt_t s_response_max_capacity = pmt_intern("response-max-capacity"); +static pmt_t s_response_ntx_chan = pmt_intern("response-ntx-chan"); +static pmt_t s_response_nrx_chan = pmt_intern("response-nrx-chan"); +static pmt_t s_response_current_capacity_allocation = pmt_intern("response-current-capacity-allocation"); + +// Errors +static pmt_t s_err_usrp_not_opened = pmt_intern("err-usrp-not-opened"); +static pmt_t s_err_usrp_already_opened = pmt_intern("err-usrp-already-opened"); +static pmt_t s_err_usrp_already_closed = pmt_intern("err-usrp-already-closed"); + +#endif /* INCLUDED_SYMBOLS_USRP_SERVER_CS_H */ diff --git a/usrp/host/lib/inband/symbols_usrp_tx.h b/usrp/host/lib/inband/symbols_usrp_tx.h new file mode 100644 index 000000000..4e58e2cf9 --- /dev/null +++ b/usrp/host/lib/inband/symbols_usrp_tx.h @@ -0,0 +1,32 @@ +/* -*- c++ -*- */ +/* + * Copyright 2007 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * GNU Radio is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3, or (at your option) + * any later version. + * + * GNU Radio is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ +#ifndef INCLUDED_SYMBOLS_USRP_TX_H +#define INCLUDED_SYMBOLS_USRP_TX_H + +#include <pmt.h> + +// Outgoing +static pmt_t s_cmd_xmit_raw_frame = pmt_intern("cmd-xmit-raw-frame"); + +// Incoming +static pmt_t s_response_xmit_raw_frame = pmt_intern("response-xmit-raw-frame"); + +#endif /* INCLUDED_SYMBOLS_USRP_TX_H */ diff --git a/usrp/host/lib/inband/symbols_usrp_tx_cs.h b/usrp/host/lib/inband/symbols_usrp_tx_cs.h new file mode 100644 index 000000000..d02ef1d26 --- /dev/null +++ b/usrp/host/lib/inband/symbols_usrp_tx_cs.h @@ -0,0 +1,32 @@ +/* -*- c++ -*- */ +/* + * Copyright 2007 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * GNU Radio is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3, or (at your option) + * any later version. + * + * GNU Radio is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ +#ifndef INCLUDED_SYMBOLS_USRP_TX_CS_H +#define INCLUDED_SYMBOLS_USRP_TX_CS_H + +#include <pmt.h> + +// Outgoing +static pmt_t s_cmd_usrp_tx_write = pmt_intern("cmd-usrp-tx-write"); + +// Incoming +static pmt_t s_response_usrp_tx_write = pmt_intern("response-usrp-tx-write"); + +#endif /* INCLUDED_SYMBOLS_USRP_TX_CS_H */ diff --git a/usrp/host/lib/inband/test_usrp_inband.cc b/usrp/host/lib/inband/test_usrp_inband.cc new file mode 100644 index 000000000..dd8d46f84 --- /dev/null +++ b/usrp/host/lib/inband/test_usrp_inband.cc @@ -0,0 +1,297 @@ +/* -*- c++ -*- */ +/* + * Copyright 2007 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * GNU Radio is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3, or (at your option) + * any later version. + * + * GNU Radio is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#include <stdio.h> +#include <iostream> +#include <usrp_inband_usb_packet.h> +#include <mb_mblock.h> +#include <mb_runtime.h> +#include <mb_protocol_class.h> +#include <mb_class_registry.h> +#include <pmt.h> +#include "usrp_standard.h" + +typedef usrp_inband_usb_packet transport_pkt; + +// Signal set for the USRP server +static pmt_t s_cmd_open = pmt_intern("cmd-open"); +static pmt_t s_response_open = pmt_intern("response-open"); +static pmt_t s_cmd_close = pmt_intern("cmd-close"); +static pmt_t s_response_close = pmt_intern("response-close"); +static pmt_t s_cmd_allocate_channel = pmt_intern("cmd-allocate-channel"); +static pmt_t s_response_allocate_channel = pmt_intern("response-allocate-channel"); +static pmt_t s_send_allocate_channel = pmt_intern("send-allocate-channel"); +static pmt_t s_cmd_deallocate_channel = pmt_intern("cmd-deallocate-channel"); +static pmt_t s_response_deallocate_channel = pmt_intern("response-deallocate-channel"); +static pmt_t s_send_deallocate_channel = pmt_intern("send-deallocate-channel"); +static pmt_t s_cmd_max_capacity = pmt_intern("cmd-max-capacity"); +static pmt_t s_response_max_capacity = pmt_intern("response-max-capacity"); +static pmt_t s_cmd_ntx_chan = pmt_intern("cmd-ntx-chan"); +static pmt_t s_cmd_nrx_chan = pmt_intern("cmd-nrx-chan"); +static pmt_t s_response_ntx_chan = pmt_intern("response-ntx-chan"); +static pmt_t s_response_nrx_chan = pmt_intern("response-nrx-chan"); +static pmt_t s_cmd_current_capacity_allocation = pmt_intern("cmd-current-capacity-allocation"); +static pmt_t s_response_current_capacity_allocation = pmt_intern("response-current-capacity-allocation"); +static pmt_t s_cmd_xmit_raw_frame = pmt_intern("cmd-xmit-raw-frame"); +static pmt_t s_response_xmit_raw_frame = pmt_intern("response-xmit-raw-frame"); + +bool loopback_p = false; +bool counting_p = false; +bool fake_usrp_p = false; +char *prog_name; + +static void +set_progname (char *path) +{ + char *p = strrchr (path, '/'); + if (p != 0) + prog_name = p+1; + else + prog_name = path; +} + +static void +usage() +{ + fprintf (stderr, "usage: %s [-l]\n", prog_name); + fprintf (stderr, " [-l] digital loopback in FPGA\n"); + fprintf (stderr, " [-c] counting in FPGA\n"); + fprintf (stderr, " [-f] fake usrp\n"); + + exit(1); +} + +int +main(int argc, char **argv) +{ + int ch; + + set_progname(argv[0]); + + mb_runtime_sptr rt = mb_make_runtime(); + pmt_t result = PMT_T; + + while ((ch = getopt(argc, argv, "flc")) != EOF) { + switch(ch) { + + case 'l': + loopback_p = true; + break; + + case 'c': + counting_p = true; + break; + + case 'f': + fake_usrp_p = true; + break; + + default: + usage(); + } + } + + + std::cout << "[test_usrp_inband] Starting...\n"; + + rt->run("top", "test_usrp_inband_top", PMT_F, &result); +} + +class test_usrp_inband_top : public mb_mblock +{ + mb_port_sptr d_tx; + mb_port_sptr d_cs; + + long d_tx_chan; + + public: + test_usrp_inband_top(mb_runtime *runtime, const std::string &instance_name, pmt_t user_arg); + ~test_usrp_inband_top(); + void initial_transition(); + void handle_message(mb_message_sptr msg); + + protected: + void open_usrp(); + void close_usrp(); + void check_message(mb_message_sptr msg); + void allocate_channel(); + void send_packets(); +}; + +test_usrp_inband_top::test_usrp_inband_top(mb_runtime *runtime, const std::string &instance_name, pmt_t user_arg) + : mb_mblock(runtime, instance_name, user_arg) +{ + std::cout << "[TEST_USRP_INBAND_TOP] Initializing...\n"; + + d_tx = define_port("tx0", "usrp-tx", false, mb_port::INTERNAL); + d_cs = define_port("cs", "usrp-server-cs", false, mb_port::INTERNAL); + + // Test the TX side + + // Pass a dictionary to usrp_server which specifies which interface to use, the stub or USRP + pmt_t usrp_server_dict = pmt_make_dict(); + + if(fake_usrp_p) + pmt_dict_set(usrp_server_dict, pmt_intern("usrp-interface"), pmt_intern("usrp_usb_interface_stub")); + + define_component("server", "usrp_server", usrp_server_dict); + connect("self", "tx0", "server", "tx0"); + connect("self", "cs", "server", "cs"); +} + +test_usrp_inband_top::~test_usrp_inband_top() +{ +} + +void +test_usrp_inband_top::initial_transition() +{ + open_usrp(); +} + +void +test_usrp_inband_top::handle_message(mb_message_sptr msg) +{ + pmt_t event = msg->signal(); // the "name" of the message + pmt_t port_id = msg->port_id(); // which port it came in on + pmt_t data = msg->data(); + pmt_t metadata = msg->metadata(); + pmt_t status; + + if (pmt_eq(port_id, d_cs->port_symbol())) { // message came in on our control/status port + + //---------- OPEN RESPONSE ----------// + if (pmt_eq(event, s_response_open)) { + status = pmt_nth(1, data); + + if(pmt_eq(status, PMT_T)) { + std::cout << "[TEST_USRP_INBAND_TOP] Success opening USRP\n"; + } + else { + std::cout << "[TEST_USRP_INBAND_TOP] Received error message opening USRP\n"; + shutdown_all(PMT_F); + } + + allocate_channel(); + + return; + } + //--------- CLOSE RESPONSE -----------// + else if (pmt_eq(event, s_response_close)) { + status = pmt_nth(1, data); + + if(pmt_eq(status, PMT_T)) { + std::cout << "[TEST_USRP_INBAND_TOP] Successfully closed USRP\n"; + } + else { + std::cout << "[TEST_USRP_INBAND_TOP] Received error message closing USRP\n"; + shutdown_all(PMT_F); + } + + shutdown_all(PMT_T); + + return; + } + } + + if (pmt_eq(port_id, d_tx->port_symbol())) { + + //---------- ALLOCATE RESPONSE ---------// + if(pmt_eq(event, s_response_allocate_channel)) { + status = pmt_nth(1, data); + pmt_t channel = pmt_nth(2, data); + + if(pmt_eq(status, PMT_T)) { + d_tx_chan = pmt_to_long(channel); + std::cout << "[TEST_USRP_INBAND_TOP] Received allocation on channel " << d_tx_chan << "\n"; + } + else { + std::cout << "[TEST_USRP_INBAND_TOP] Error allocating channel\n"; + shutdown_all(PMT_F); + } + + send_packets(); + + return; + } + //----------- XMIT RESPONSE ------------// + else if(pmt_eq(event, s_response_xmit_raw_frame)) { + status = pmt_nth(1, data); + + if(pmt_eq(status, PMT_T)) { + std::cout << "[TEST_USRP_INBAND_TOP] Transmission successful\n"; + } + else { + std::cout << "[TEST_USRP_INBAND_TOP] Failed transmission\n"; + shutdown_all(PMT_F); + } + + close_usrp(); + + return; + } + } + + std::cout << "[TEST_USRP_INBAND_TOP] Received unhandled message: " << event << "\n"; +} + +void +test_usrp_inband_top::allocate_channel() +{ + std::cout << "[TEST_USRP_INBAND_TOP] Requesting channel allocation...\n"; + + d_tx->send(s_cmd_allocate_channel, pmt_list2(PMT_T, pmt_from_long(1))); +} + +void +test_usrp_inband_top::send_packets() +{ + std::cout << "[TEST_USRP_INBAND_TOP] Sending single packet..\n"; + d_tx->send(s_cmd_xmit_raw_frame, pmt_list4(pmt_from_long(1), pmt_from_long(d_tx_chan), pmt_make_u32vector(transport_pkt::max_payload()/4, 0), pmt_from_long(0))); + +} + +void +test_usrp_inband_top::open_usrp() +{ + pmt_t usrp = pmt_from_long(0); + + long rx_mode = 0; + + if(loopback_p) + rx_mode |= usrp_standard_rx::FPGA_MODE_LOOPBACK; + if(counting_p) + rx_mode |= usrp_standard_rx::FPGA_MODE_COUNTING; + + d_cs->send(s_cmd_open, pmt_list2(PMT_NIL, usrp)); +} + +void +test_usrp_inband_top::close_usrp() +{ + d_cs->send(s_cmd_close, pmt_list1(PMT_NIL)); +} + +REGISTER_MBLOCK_CLASS(test_usrp_inband_top); diff --git a/usrp/host/lib/inband/usrp_inband_usb_packet.cc b/usrp/host/lib/inband/usrp_inband_usb_packet.cc new file mode 100644 index 000000000..b8befa493 --- /dev/null +++ b/usrp/host/lib/inband/usrp_inband_usb_packet.cc @@ -0,0 +1,749 @@ +/* -*- c++ -*- */ +/* + * Copyright 2007 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * GNU Radio is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3, or (at your option) + * any later version. + * + * GNU Radio is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#include <usrp_inband_usb_packet.h> + +#include <usrp_bytesex.h> +#include <iostream> +#include <stdio.h> + +bool usrp_inband_usb_packet::align32() +{ + int p_len = payload_len(); + + int bytes_needed = 4 - (p_len % 4); + + if(bytes_needed == 4) + return true; + + // If the room left in the packet is less than the number of bytes + // needed, return false to indicate no room to align + if((MAX_PAYLOAD - p_len) < bytes_needed) + return false; + + p_len += bytes_needed; + + int h_flags = flags(); + int h_chan = chan(); + int h_tag = tag(); + int h_payload_len = p_len; + + set_header(h_flags, h_chan, h_tag, h_payload_len); + + return true; +} + +bool usrp_inband_usb_packet::cs_ping(long rid, long ping_val) +{ + if(!align32()) + return false; + + int p_len = payload_len(); + + if((MAX_PAYLOAD - p_len) < (CS_PING_LEN + CS_FIXED_LEN)) + return false; + + uint32_t ping = ( + ((OP_PING_FIXED & CS_OPCODE_MASK) << CS_OPCODE_SHIFT) + | ((CS_PING_LEN & CS_LEN_MASK) << CS_LEN_SHIFT) + | ((rid & CS_RID_MASK) << CS_RID_SHIFT) + | (ping_val & CS_PINGVAL_MASK) + + ); + + uint32_t *payload = (uint32_t *) (d_payload + p_len); + *payload = host_to_usrp_u32(ping); + + // Update payload length + int h_flags = flags(); + int h_chan = chan(); + int h_tag = tag(); + int h_payload_len = payload_len() + CS_FIXED_LEN + CS_PING_LEN; + + set_header(h_flags, h_chan, h_tag, h_payload_len); + + return true; +} + + +bool usrp_inband_usb_packet::cs_ping_reply(long rid, long ping_val) +{ + if(!align32()) + return false; + + int p_len = payload_len(); + + if((MAX_PAYLOAD - p_len) < (CS_PING_LEN + CS_FIXED_LEN)) + return false; + + uint32_t ping = ( + ((OP_PING_FIXED_REPLY & CS_OPCODE_MASK) << CS_OPCODE_SHIFT) + | ((CS_PING_LEN & CS_LEN_MASK) << CS_LEN_SHIFT) + | ((rid & CS_RID_MASK) << CS_RID_SHIFT) + | ((ping_val & CS_PINGVAL_MASK) << CS_PINGVAL_SHIFT) + + ); + + uint32_t *payload = (uint32_t *) (d_payload + p_len); + *payload = host_to_usrp_u32(ping); + + // Update payload length + int h_flags = flags(); + int h_chan = chan(); + int h_tag = tag(); + int h_payload_len = payload_len() + CS_FIXED_LEN + CS_PING_LEN; + + set_header(h_flags, h_chan, h_tag, h_payload_len); + + return true; +} + +bool usrp_inband_usb_packet::cs_write_reg(long reg_num, long val) +{ + if(!align32()) + return false; + + int p_len = payload_len(); + + if((MAX_PAYLOAD - p_len) < (CS_WRITEREG_LEN + CS_FIXED_LEN)) + return false; + + uint32_t word0 = 0; + + // Build the first word which includes the register number + word0 = ( + ((OP_WRITE_REG & CS_OPCODE_MASK) << CS_OPCODE_SHIFT) + | ((CS_WRITEREG_LEN & CS_LEN_MASK) << CS_LEN_SHIFT) + | ((reg_num & CS_REGNUM_MASK) << CS_REGNUM_SHIFT) + ); + + uint32_t *payload = (uint32_t *) (d_payload + p_len); + *payload = host_to_usrp_u32(word0); + + // The second word is solely the register value to be written + // FIXME: should this be unsigned? + payload += 1; + *payload = host_to_usrp_u32((uint32_t) val); + + // Rebuild the header to update the payload length + int h_flags = flags(); + int h_chan = chan(); + int h_tag = tag(); + int h_payload_len = payload_len() + CS_FIXED_LEN + CS_WRITEREG_LEN; + + set_header(h_flags, h_chan, h_tag, h_payload_len); + + return true; +} + +bool usrp_inband_usb_packet::cs_write_reg_masked(long reg_num, long val, long mask) +{ + if(!align32()) + return false; + + int p_len = payload_len(); + + if((MAX_PAYLOAD - p_len) < (CS_WRITEREGMASKED_LEN + CS_FIXED_LEN)) + return false; + + uint32_t word0 = 0; + + // Build the first word which includes the register number + word0 = ( + ((OP_WRITE_REG_MASKED & CS_OPCODE_MASK) << CS_OPCODE_SHIFT) + | ((CS_WRITEREGMASKED_LEN & CS_LEN_MASK) << CS_LEN_SHIFT) + | ((reg_num & CS_REGNUM_MASK) << CS_REGNUM_SHIFT) + ); + + uint32_t *payload = (uint32_t *) (d_payload + p_len); + *payload = host_to_usrp_u32(word0); + + // Skip over the first word and write the register value + payload += 1; + *payload = host_to_usrp_u32((uint32_t) val); + + // Skip over the register value and write the mask + payload += 1; + *payload = host_to_usrp_u32((uint32_t) mask); + + // Rebuild the header to update the payload length + int h_flags = flags(); + int h_chan = chan(); + int h_tag = tag(); + int h_payload_len = payload_len() + CS_FIXED_LEN + CS_WRITEREGMASKED_LEN; + + set_header(h_flags, h_chan, h_tag, h_payload_len); + + return true; +} + +bool usrp_inband_usb_packet::cs_read_reg(long rid, long reg_num) +{ + if(!align32()) + return false; + + int p_len = payload_len(); + + if((MAX_PAYLOAD - p_len) < (CS_READREG_LEN + CS_FIXED_LEN)) + return false; + + uint32_t read_reg = ( + ((OP_READ_REG & CS_OPCODE_MASK) << CS_OPCODE_SHIFT) + | ((CS_READREG_LEN & CS_LEN_MASK) << CS_LEN_SHIFT) + | ((rid & CS_RID_MASK) << CS_RID_SHIFT) + | ((reg_num & CS_REGNUM_MASK) << CS_REGNUM_SHIFT) + + ); + + uint32_t *payload = (uint32_t *) (d_payload + p_len); + *payload = host_to_usrp_u32(read_reg); + + // Update payload length + int h_flags = flags(); + int h_chan = chan(); + int h_tag = tag(); + int h_payload_len = payload_len() + CS_FIXED_LEN + CS_READREG_LEN; + + set_header(h_flags, h_chan, h_tag, h_payload_len); + + return true; +} + +bool usrp_inband_usb_packet::cs_read_reg_reply(long rid, long reg_num, long reg_val) +{ + if(!align32()) + return false; + + int p_len = payload_len(); + + if((MAX_PAYLOAD - p_len) < (CS_READREGREPLY_LEN + CS_FIXED_LEN)) + return false; + + uint32_t word0 = ( + ((OP_READ_REG_REPLY & CS_OPCODE_MASK) << CS_OPCODE_SHIFT) + | ((CS_READREGREPLY_LEN & CS_LEN_MASK) << CS_LEN_SHIFT) + | ((rid & CS_RID_MASK) << CS_RID_SHIFT) + | ((reg_num & CS_REGNUM_MASK) << CS_REGNUM_SHIFT) + + ); + + uint32_t *payload = (uint32_t *) (d_payload + p_len); + *payload = host_to_usrp_u32(word0); + + // Hop to the next word and write the reg value + payload += 1; + *payload = host_to_usrp_u32((uint32_t) reg_val); + + // Update payload length + int h_flags = flags(); + int h_chan = chan(); + int h_tag = tag(); + int h_payload_len = payload_len() + CS_FIXED_LEN + CS_READREGREPLY_LEN; + + set_header(h_flags, h_chan, h_tag, h_payload_len); + + return true; +} + +bool usrp_inband_usb_packet::cs_delay(long ticks) +{ + if(!align32()) + return false; + + int p_len = payload_len(); + + if((MAX_PAYLOAD - p_len) < (CS_DELAY_LEN + CS_FIXED_LEN)) + return false; + + uint32_t delay = ( + ((OP_DELAY & CS_OPCODE_MASK) << CS_OPCODE_SHIFT) + | ((CS_DELAY_LEN & CS_LEN_MASK) << CS_LEN_SHIFT) + | ((ticks & CS_DELAY_MASK) << CS_DELAY_SHIFT) + + ); + + uint32_t *payload = (uint32_t *) (d_payload + p_len); + *payload = host_to_usrp_u32(delay); + + // Update payload length + int h_flags = flags(); + int h_chan = chan(); + int h_tag = tag(); + int h_payload_len = payload_len() + CS_FIXED_LEN + CS_DELAY_LEN; + + set_header(h_flags, h_chan, h_tag, h_payload_len); + + return true; +} + +bool usrp_inband_usb_packet::cs_i2c_write(long i2c_addr, uint8_t *i2c_data, size_t data_len) +{ + if(!align32()) + return false; + + int p_len = payload_len(); + + int i2c_len = data_len + 2; // 2 bytes between mbz and addr + + if((MAX_PAYLOAD - p_len) < (i2c_len + CS_FIXED_LEN)) + return false; + + uint32_t word0 = 0; + + word0 = ( + ((OP_I2C_WRITE & CS_OPCODE_MASK) << CS_OPCODE_SHIFT) + | ((i2c_len & CS_LEN_MASK) << CS_LEN_SHIFT) + | ((i2c_addr & CS_I2CADDR_MASK) << CS_I2CADDR_SHIFT) + ); + + uint32_t *payload = (uint32_t *) (d_payload + p_len); + *payload = host_to_usrp_u32(word0); + + // Jump over the first word and write the data + // FIXME: Should the data be changed to usrp byte order? + payload += 1; + memcpy(payload, i2c_data, data_len); + + // Update payload length + int h_flags = flags(); + int h_chan = chan(); + int h_tag = tag(); + int h_payload_len = payload_len() + CS_FIXED_LEN + i2c_len; + + set_header(h_flags, h_chan, h_tag, h_payload_len); + + return true; +} + +bool usrp_inband_usb_packet::cs_i2c_read(long rid, long i2c_addr, long n_bytes) +{ + if(!align32()) + return false; + + int p_len = payload_len(); + + if((MAX_PAYLOAD - p_len) < (CS_I2CREAD_LEN + CS_FIXED_LEN)) + return false; + + uint32_t word0 = 0; + + word0 = ( + ((OP_I2C_READ & CS_OPCODE_MASK) << CS_OPCODE_SHIFT) + | ((CS_I2CREAD_LEN & CS_LEN_MASK) << CS_LEN_SHIFT) + | ((rid & CS_RID_MASK) << CS_RID_SHIFT) + | ((i2c_addr & CS_I2CADDR_MASK) << CS_I2CADDR_SHIFT) + ); + + uint32_t *payload = (uint32_t *) (d_payload + p_len); + *payload = host_to_usrp_u32(word0); + + // Jump a word and write the number of bytes to read + payload += 1; + uint32_t word1 = + (n_bytes & CS_I2CREADBYTES_MASK) << CS_I2CREADBYTES_SHIFT; + *payload = host_to_usrp_u32(word1); + + // Update payload length + int h_flags = flags(); + int h_chan = chan(); + int h_tag = tag(); + int h_payload_len = payload_len() + CS_FIXED_LEN + CS_I2CREAD_LEN; + + set_header(h_flags, h_chan, h_tag, h_payload_len); + + return true; +} + +bool usrp_inband_usb_packet::cs_i2c_read_reply(long rid, long i2c_addr, uint8_t *i2c_data, long i2c_data_len) +{ + if(!align32()) + return false; + + int p_len = payload_len(); + + int i2c_len = i2c_data_len + 2; + + if((MAX_PAYLOAD - p_len) < (i2c_len + CS_FIXED_LEN)) + return false; + + uint32_t word0 = 0; + + word0 = ( + ((OP_I2C_READ_REPLY & CS_OPCODE_MASK) << CS_OPCODE_SHIFT) + | ((i2c_len & CS_LEN_MASK) << CS_LEN_SHIFT) + | ((rid & CS_RID_MASK) << CS_RID_SHIFT) + | ((i2c_addr & CS_I2CADDR_MASK) << CS_I2CADDR_SHIFT) + ); + + uint32_t *payload = (uint32_t *) (d_payload + p_len); + *payload = host_to_usrp_u32(word0); + + // Jump a word and write the actual data + payload += 1; + memcpy(payload, i2c_data, i2c_data_len); + + // Update payload length + int h_flags = flags(); + int h_chan = chan(); + int h_tag = tag(); + int h_payload_len = payload_len() + CS_FIXED_LEN + i2c_len; + + set_header(h_flags, h_chan, h_tag, h_payload_len); + + return true; +} + +bool usrp_inband_usb_packet::cs_spi_write(long enables, long format, long opt_header_bytes, uint8_t *spi_data, long spi_data_len) +{ + if(!align32()) + return false; + + int p_len = payload_len(); + + int spi_len = spi_data_len + 6; + + if((MAX_PAYLOAD - p_len) < (spi_len + CS_FIXED_LEN)) + return false; + + uint32_t word = 0; + + // First word contains the opcode and length, then mbz + word = ( + ((OP_SPI_WRITE & CS_OPCODE_MASK) << CS_OPCODE_SHIFT) + | ((spi_len & CS_LEN_MASK) << CS_LEN_SHIFT) + ); + uint32_t *payload = (uint32_t *) (d_payload + p_len); + *payload = host_to_usrp_u32(word); + + payload += 1; + + // Second word contains the enables, format, and optional tx bytes + word = 0; + word = ( + ((enables & CS_SPIENABLES_MASK) << CS_SPIENABLES_SHIFT) + | ((format & CS_SPIFORMAT_MASK) << CS_SPIFORMAT_SHIFT) + | ((opt_header_bytes & CS_SPIOPT_MASK) << CS_SPIOPT_SHIFT) + ); + payload = (uint32_t *) (d_payload + p_len); + *payload = host_to_usrp_u32(word); + + payload += 1; + memcpy(payload, spi_data, spi_data_len); + + // Update payload length + int h_flags = flags(); + int h_chan = chan(); + int h_tag = tag(); + int h_payload_len = payload_len() + CS_FIXED_LEN + spi_len; + + set_header(h_flags, h_chan, h_tag, h_payload_len); + + return true; +} + +bool usrp_inband_usb_packet::cs_spi_read(long rid, long enables, long format, long opt_header_bytes, long n_bytes) +{ + if(!align32()) + return false; + + int p_len = payload_len(); + + if((MAX_PAYLOAD - p_len) < (CS_SPIREAD_LEN + CS_FIXED_LEN)) + return false; + + uint32_t word = 0; + + // First word contains the opcode, length, and RID + word = ( + ((OP_SPI_READ & CS_OPCODE_MASK) << CS_OPCODE_SHIFT) + | ((CS_SPIREAD_LEN & CS_LEN_MASK) << CS_LEN_SHIFT) + | ((rid & CS_RID_MASK) << CS_RID_SHIFT) + ); + uint32_t *payload = (uint32_t *) (d_payload + p_len); + *payload = host_to_usrp_u32(word); + + payload += 1; + + // Second word contains the enables, format, and optional tx bytes + word = 0; + word = ( + ((enables & CS_SPIENABLES_MASK) << CS_SPIENABLES_SHIFT) + | ((format & CS_SPIFORMAT_MASK) << CS_SPIFORMAT_SHIFT) + | ((opt_header_bytes & CS_SPIOPT_MASK) << CS_SPIOPT_SHIFT) + ); + payload = (uint32_t *) (d_payload + p_len); + *payload = host_to_usrp_u32(word); + + payload += 1; + + // The third word contains the number of bytes + word = 0; + word = ( + ((n_bytes & CS_SPINBYTES_MASK) << CS_SPINBYTES_SHIFT) + ); + payload = (uint32_t *) (d_payload + p_len); + *payload = host_to_usrp_u32(word); + + // Update payload length + int h_flags = flags(); + int h_chan = chan(); + int h_tag = tag(); + int h_payload_len = payload_len() + CS_FIXED_LEN + CS_SPIREAD_LEN; + + set_header(h_flags, h_chan, h_tag, h_payload_len); + + return true; +} + +bool usrp_inband_usb_packet::cs_spi_read_reply(long rid, uint8_t *spi_data, long spi_data_len) +{ + if(!align32()) + return false; + + int p_len = payload_len(); + + int spi_len = spi_data_len + 2; + + if((MAX_PAYLOAD - p_len) < (spi_len + CS_FIXED_LEN)) + return false; + + uint32_t word = 0; + + // First word contains the opcode, length, and RID + word = ( + ((OP_SPI_READ_REPLY & CS_OPCODE_MASK) << CS_OPCODE_SHIFT) + | ((spi_len & CS_LEN_MASK) << CS_LEN_SHIFT) + | ((rid & CS_RID_MASK) << CS_RID_SHIFT) + ); + uint32_t *payload = (uint32_t *) (d_payload + p_len); + *payload = host_to_usrp_u32(word); + + // Jump a word and write the actual data + payload += 1; + memcpy(payload, spi_data, spi_data_len); + + // Update payload length + int h_flags = flags(); + int h_chan = chan(); + int h_tag = tag(); + int h_payload_len = payload_len() + CS_FIXED_LEN + spi_len; + + set_header(h_flags, h_chan, h_tag, h_payload_len); + + return true; +} + +// Takes an offset to the beginning of a subpacket and extracts the +// length of the subpacket +int usrp_inband_usb_packet::cs_len(int payload_offset) { + uint32_t subpkt = usrp_to_host_u32(*((uint32_t *)(d_payload + payload_offset))); + return (subpkt >> CS_LEN_SHIFT) & CS_LEN_MASK; +} + +// The following method takes an offset within the packet payload to extract +// a control/status subpacket and construct a pmt response which includes the +// proper signal and arguments specified by usrp-low-level-cs. The USRP +// server could therefore use this to read subpackets and pass them responses +// back up to the application. It's arguable that only reply packets should +// be parsed here, however we parse others for use in debugging or failure +// reporting on the transmit side of packets. +pmt_t usrp_inband_usb_packet::read_subpacket(int payload_offset) { + + uint32_t subpkt = usrp_to_host_u32(*((uint32_t *)(d_payload + payload_offset))); + uint32_t opcode = (subpkt >> CS_OPCODE_SHIFT) & CS_OPCODE_MASK; + uint32_t len = (subpkt >> CS_LEN_SHIFT) & CS_LEN_MASK; + + switch(opcode) { + + case OP_PING_FIXED_REPLY: + { + pmt_t rid = pmt_from_long((subpkt >> CS_RID_SHIFT) & CS_RID_MASK); + pmt_t pingval = pmt_from_long((subpkt >> CS_PINGVAL_SHIFT) & CS_PINGVAL_MASK); + return pmt_list3(s_op_ping_fixed_reply, rid, pingval); + } + + case OP_READ_REG_REPLY: + { + pmt_t rid = pmt_from_long((subpkt >> CS_RID_SHIFT) & CS_RID_MASK); + pmt_t reg_num = pmt_from_long((subpkt >> CS_REGNUM_SHIFT) & CS_REGNUM_MASK); + + // To get the register value we just read the next 32 bits + uint32_t val = usrp_to_host_u32(*((uint32_t *)(d_payload + payload_offset + 4))); + pmt_t reg_val = pmt_from_long(val); + + return pmt_list4(s_op_read_reg_reply, rid, reg_num, reg_val); + } + + case OP_I2C_READ_REPLY: + { + pmt_t rid = pmt_from_long((subpkt >> CS_RID_SHIFT) & CS_RID_MASK); + pmt_t i2c_addr = pmt_from_long((subpkt >> CS_I2CADDR_SHIFT) & CS_I2CADDR_MASK); + + // Make a u8 vector to dump the data from the packet into + size_t i2c_data_len; + pmt_t i2c_data = pmt_make_u8vector(len - 2, 0); // skip rid+mbz+addr = 2 bytes + uint8_t *w_data = + (uint8_t *) pmt_u8vector_writeable_elements(i2c_data, i2c_data_len); + + memcpy(w_data, d_payload + payload_offset + 4, i2c_data_len); // skip first word + + return pmt_list4(s_op_i2c_read_reply, rid, i2c_addr, i2c_data); + } + + case OP_SPI_READ_REPLY: + { + pmt_t rid = pmt_from_long((subpkt >> CS_RID_SHIFT) & CS_RID_MASK); + + // Make a u8 vector to dump the data from the packet into + size_t spi_data_len; + pmt_t spi_data = pmt_make_u8vector(len - 2, 0); // skip rid+mbz+addr = 2 bytes + uint8_t *w_data = + (uint8_t *) pmt_u8vector_writeable_elements(spi_data, spi_data_len); + + memcpy(w_data, d_payload + payload_offset + 4, spi_data_len); // skip first word + + return pmt_list3(s_op_spi_read_reply, rid, spi_data); + } + + case OP_PING_FIXED: + { + pmt_t rid = pmt_from_long((subpkt >> CS_RID_SHIFT) & CS_RID_MASK); + pmt_t pingval = pmt_from_long((subpkt >> CS_PINGVAL_SHIFT) & CS_PINGVAL_MASK); + return pmt_list3(s_op_ping_fixed, rid, pingval); + } + + case OP_WRITE_REG: + { + pmt_t reg_num = pmt_from_long((subpkt >> CS_REGNUM_SHIFT) & CS_REGNUM_MASK); + + // To get the register value we just read the next 32 bits + uint32_t val = usrp_to_host_u32(*((uint32_t *)(d_payload + payload_offset + 4))); + pmt_t reg_val = pmt_from_long(val); + + return pmt_list3(s_op_write_reg, reg_num, reg_val); + } + + case OP_WRITE_REG_MASKED: + { + pmt_t reg_num = pmt_from_long((subpkt >> CS_REGNUM_SHIFT) & CS_REGNUM_MASK); + + // To get the register value we just read the next 32 bits + uint32_t val = usrp_to_host_u32(*((uint32_t *)(d_payload + payload_offset + 4))); + pmt_t reg_val = pmt_from_long(val); + + // The mask is the next 32 bits + uint32_t mask = usrp_to_host_u32(*((uint32_t *)(d_payload + payload_offset + 8))); + pmt_t reg_mask = pmt_from_long(mask); + + return pmt_list4(s_op_write_reg_masked, reg_num, reg_val, reg_mask); + } + + case OP_READ_REG: + { + pmt_t rid = pmt_from_long((subpkt >> CS_RID_SHIFT) & CS_RID_MASK); + pmt_t reg_num = pmt_from_long((subpkt >> CS_REGNUM_SHIFT) & CS_REGNUM_MASK); + + return pmt_list3(s_op_read_reg, rid, reg_num); + } + + case OP_I2C_WRITE: + { + pmt_t i2c_addr = pmt_from_long((subpkt >> CS_I2CADDR_SHIFT) & CS_I2CADDR_MASK); + + // The length includes an extra 2 bytes for storing the mbz and addr + pmt_t i2c_data = pmt_make_u8vector(len-2, 0); + + // Get a writeable address to copy the data from the packet + size_t ignore; + uint8_t *w_data = (uint8_t *) pmt_u8vector_writeable_elements(i2c_data, ignore); + memcpy(w_data, d_payload + payload_offset + 4, len-2); + + + return pmt_list3(s_op_i2c_write, i2c_addr, i2c_data); + } + + case OP_I2C_READ: + { + pmt_t rid = pmt_from_long((subpkt >> CS_RID_SHIFT) & CS_RID_MASK); + pmt_t i2c_addr = pmt_from_long((subpkt >> CS_I2CADDR_SHIFT) & CS_I2CADDR_MASK); + + // The number of bytes is in the next word + uint32_t bytes = usrp_to_host_u32(*((uint32_t *)(d_payload + payload_offset + 4))); + bytes = (bytes >> CS_I2CREADBYTES_SHIFT) & CS_I2CREADBYTES_MASK; + pmt_t i2c_bytes = pmt_from_long(bytes); + + return pmt_list4(s_op_i2c_read, rid, i2c_addr, i2c_bytes); + } + + case OP_SPI_WRITE: + { + // Nothing interesting in the first word, skip to the next + uint32_t word = usrp_to_host_u32(*((uint32_t *)(d_payload + payload_offset + 4))); + pmt_t enables = pmt_from_long((word >> CS_SPIENABLES_SHIFT) & CS_SPIENABLES_MASK); + pmt_t format = pmt_from_long((word >> CS_SPIFORMAT_SHIFT) & CS_SPIFORMAT_MASK); + pmt_t opt = pmt_from_long((word >> CS_SPIOPT_SHIFT) & CS_SPIOPT_MASK); + + // From the next word and on is data + size_t spi_data_len; + pmt_t spi_data = pmt_make_u8vector(len - 6, 0); // skip rid+mbz+addr = 2 bytes + uint8_t *w_data = + (uint8_t *) pmt_u8vector_writeable_elements(spi_data, spi_data_len); + + memcpy(w_data, d_payload + payload_offset + 8, spi_data_len); // skip first 2 words + + return pmt_list5(s_op_spi_write, enables, format, opt, spi_data); + } + + case OP_SPI_READ: + { + // Read the RID from the first word, the rest is mbz + pmt_t rid = pmt_from_long((subpkt >> CS_RID_SHIFT) & CS_RID_MASK); + + // Continue at the next word... + uint32_t word = usrp_to_host_u32(*((uint32_t *)(d_payload + payload_offset + 4))); + pmt_t enables = pmt_from_long((word >> CS_SPIENABLES_SHIFT) & CS_SPIENABLES_MASK); + pmt_t format = pmt_from_long((word >> CS_SPIFORMAT_SHIFT) & CS_SPIFORMAT_MASK); + pmt_t opt = pmt_from_long((word >> CS_SPIOPT_SHIFT) & CS_SPIOPT_MASK); + + // The number of bytes is the only thing to read in the next word + word = usrp_to_host_u32(*((uint32_t *)(d_payload + payload_offset + 8))); + pmt_t n_bytes = pmt_from_long((word >> CS_SPINBYTES_SHIFT) & CS_SPINBYTES_MASK); + + return pmt_list6(s_op_spi_read, rid, enables, format, opt, n_bytes); + } + + case OP_DELAY: + { + pmt_t ticks = pmt_from_long((subpkt >> CS_DELAY_SHIFT) & CS_DELAY_MASK); + + return pmt_list2(s_op_delay, ticks); + } + + default: + return PMT_NIL; + + } +} + diff --git a/usrp/host/lib/inband/usrp_inband_usb_packet.h b/usrp/host/lib/inband/usrp_inband_usb_packet.h index e22b567fa..9290f55ae 100644 --- a/usrp/host/lib/inband/usrp_inband_usb_packet.h +++ b/usrp/host/lib/inband/usrp_inband_usb_packet.h @@ -24,6 +24,10 @@ #include <usrp_bytesex.h> #include <mb_mblock.h> +#include <pmt.h> +#include <iostream> + +#include <symbols_usrp_low_level_cs.h> static const int USB_PKT_SIZE = 512; // bytes static const int MAX_PAYLOAD = USB_PKT_SIZE-2*sizeof(uint32_t); @@ -38,12 +42,28 @@ class usrp_inband_usb_packet { public: + enum opcodes { + OP_PING_FIXED = 0x00, + OP_PING_FIXED_REPLY = 0x01, + OP_WRITE_REG = 0x02, + OP_WRITE_REG_MASKED = 0x03, + OP_READ_REG = 0x04, + OP_READ_REG_REPLY = 0x05, + OP_I2C_WRITE = 0x06, + OP_I2C_READ = 0x07, + OP_I2C_READ_REPLY = 0x08, + OP_SPI_WRITE = 0x09, + OP_SPI_READ = 0x0a, + OP_SPI_READ_REPLY = 0x0b, + OP_DELAY = 0x0c + }; + enum flags { FL_OVERRUN = 0x80000000, FL_UNDERRUN = 0x40000000, FL_DROPPED = 0x20000000, - FL_END_OF_BURST = 0x10000000, - FL_START_OF_BURST = 0x08000000, + FL_START_OF_BURST = 0x10000000, + FL_END_OF_BURST = 0x08000000, FL_ALL_FLAGS = 0xf8000000 }; @@ -51,8 +71,8 @@ public: static const int FL_OVERRUN_SHIFT = 31; static const int FL_UNDERRUN_SHIFT = 30; static const int FL_DROPPED_SHIFT = 29; - static const int FL_END_OF_BURST_SHIFT = 28; - static const int FL_START_OF_BURST_SHIFT = 27; + static const int FL_END_OF_BURST_SHIFT = 27; + static const int FL_START_OF_BURST_SHIFT = 28; static const int RSSI_MASK = 0x3f; static const int RSSI_SHIFT = 21; @@ -66,6 +86,50 @@ public: static const int PAYLOAD_LEN_MASK = 0x1ff; static const int PAYLOAD_LEN_SHIFT = 0; + // Fixed size for opcode and length fields + static const int CS_FIXED_LEN = 2; + + static const int CS_OPCODE_MASK = 0xff; + static const int CS_OPCODE_SHIFT = 24; + + static const int CS_LEN_MASK = 0xff; + static const int CS_LEN_SHIFT = 16; + + static const int CS_RID_MASK = 0x3f; + static const int CS_RID_SHIFT = 10; + + static const int CS_PING_LEN = 2; + static const int CS_PINGVAL_MASK = 0x3ff; + static const int CS_PINGVAL_SHIFT = 0; + + static const int CS_WRITEREG_LEN = 6; + static const int CS_WRITEREGMASKED_LEN = 10; + static const int CS_READREG_LEN = 2; + static const int CS_READREGREPLY_LEN = 6; + static const int CS_REGNUM_MASK = 0x3ff; + static const int CS_REGNUM_SHIFT = 0; + + static const int CS_DELAY_LEN = 2; + static const int CS_DELAY_MASK = 0xffff; + static const int CS_DELAY_SHIFT = 0; + + static const int CS_I2CADDR_MASK = 0x7f; + static const int CS_I2CADDR_SHIFT = 0; + + static const int CS_I2CREAD_LEN = 3; + static const int CS_I2CREADBYTES_MASK = 0x7f; + static const int CS_I2CREADBYTES_SHIFT = 24; + + static const int CS_SPIOPT_MASK = 0xffff; + static const int CS_SPIOPT_SHIFT = 0; + static const int CS_SPIFORMAT_MASK = 0xff; + static const int CS_SPIFORMAT_SHIFT = 16; + static const int CS_SPIENABLES_MASK = 0xff; + static const int CS_SPIENABLES_SHIFT = 24; + static const int CS_SPIREAD_LEN = 7; + static const int CS_SPINBYTES_MASK = 0xff; + static const int CS_SPINBYTES_SHIFT = 24; + public: void set_timestamp(uint32_t timestamp){ @@ -77,7 +141,7 @@ public: word0 |= 1<<FL_END_OF_BURST_SHIFT; d_word0 = host_to_usrp_u32(word0); } - + void set_header(int flags, int chan, int tag, int payload_len){ uint32_t word0 = ((flags & FL_ALL_FLAGS) | ((chan & CHAN_MASK) << CHAN_SHIFT) @@ -144,6 +208,27 @@ public: return MAX_PAYLOAD; } + static int max_pkt_size() { + return USB_PKT_SIZE; + } + + // C/S methods + bool align32(); + bool cs_ping(long rid, long ping_val); + bool cs_ping_reply(long rid, long ping_val); + bool cs_write_reg(long reg_num, long val); + bool cs_write_reg_masked(long reg_num, long val, long mask); + bool cs_read_reg(long rid, long reg_num); + bool cs_read_reg_reply(long rid, long reg_num, long reg_val); + bool cs_delay(long ticks); + bool cs_i2c_write(long i2c_addr, uint8_t *i2c_data, size_t data_len); + bool cs_i2c_read(long rid, long i2c_addr, long n_bytes); + bool cs_i2c_read_reply(long rid, long i2c_addr, uint8_t *i2c_data, long i2c_data_len); + bool cs_spi_write(long enables, long format, long opt_header_bytes, uint8_t *spi_data, long spi_data_len); + bool cs_spi_read(long rid, long enables, long format, long opt_header_bytes, long n_bytes); + bool cs_spi_read_reply(long rid, uint8_t *spi_data, long spi_data_len); + int cs_len(int payload_offset); + pmt_t read_subpacket(int payload_offset); }; #endif diff --git a/usrp/host/lib/inband/usrp_interface.mbh b/usrp/host/lib/inband/usrp_interface.mbh new file mode 100644 index 000000000..ad0f78b4e --- /dev/null +++ b/usrp/host/lib/inband/usrp_interface.mbh @@ -0,0 +1,88 @@ +;; -*- scheme -*- ; not really, but tells emacs how to format this +;; +;; Copyright 2007 Free Software Foundation, Inc. +;; +;; This file is part of GNU Radio +;; +;; GNU Radio is free software; you can redistribute it and/or modify +;; it under the terms of the GNU General Public License as published by +;; the Free Software Foundation; either version 2, or (at your option) +;; any later version. +;; +;; GNU Radio is distributed in the hope that it will be useful, +;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +;; GNU General Public License for more details. +;; +;; You should have received a copy of the GNU General Public License along +;; with this program; if not, write to the Free Software Foundation, Inc., +;; 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +;; + +;; ---------------------------------------------------------------- +;; This is an mblock header file +;; +;; The format is very much a work-in-progress. +;; It'll be compiled to C++. +;; ---------------------------------------------------------------- + +;; ---------------------------------------------------------------- +;; usrp-interface-cs +;; +;; Handles interaction between the usrp_sever and the USB interface + +(define-protocol-class usrp-interface-cs + + (:outgoing + (cmd-usrp-open invocation-handle which-usrp) + (cmd-usrp-close invocation-handle) + (cmd-usrp-ntx-chan invocation-handle) + (cmd-usrp-nrx-chan invocation-handle) + (cmd-usrp-write invocation-handle channel data) + (cmd-usrp-start-reading invocation-handle channel) + ) + + (:incoming + (response-usrp-open invocation-handle status) + (response-usrp-close invocation-handle status) + (response-usrp-ntx-chan invocation-handle ntx-chan) + (response-usrp-nrx-chan invocation-handle nrx-chan) + (response-usrp-write invocation-handle status channel) + (response-usrp-read invocation-handle status data) + ) + ) + +;; ---------------------------------------------------------------- +;; usrp-tx-cs +;; +;; Handles interaction between the USB interface and TX interface + +(define-protocol-class usrp-tx-cs + + (:outgoing + (cmd-usrp-tx-write invocation-handle channel data tx-handle) + ) + + (:incoming + (response-usrp-tx-write invocation-handle status channel) + ) + ) + +;; ---------------------------------------------------------------- +;; usrp-rx-cs +;; +;; Handles interaction between the USB interface and RX interface + +(define-protocol-class usrp-rx-cs + + (:outgoing + (cmd-usrp-rx-start-reading invocation-handle rx-handle) + (cmd-usrp-rx-stop-reading invocation-handle) + ) + + (:incoming + (response-usrp-rx-read invocation-handle status data) + + ;; There is currently no response to a stop reading + ) + ) diff --git a/usrp/host/lib/inband/usrp_rx.cc b/usrp/host/lib/inband/usrp_rx.cc new file mode 100644 index 000000000..7344a6e89 --- /dev/null +++ b/usrp/host/lib/inband/usrp_rx.cc @@ -0,0 +1,142 @@ +/* -*- c++ -*- */ +/* + * Copyright 2007 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * GNU Radio is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3, or (at your option) + * any later version. + * + * GNU Radio is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#include <usrp_rx.h> + +#include <usrp_standard.h> +#include <iostream> +#include <vector> +#include <usb.h> +#include <mb_class_registry.h> +#include <usrp_inband_usb_packet.h> +#include <fpga_regs_common.h> +#include <stdio.h> + +#include <symbols_usrp_rx_cs.h> + +typedef usrp_inband_usb_packet transport_pkt; + +static const bool verbose = false; + +usrp_rx::usrp_rx(mb_runtime *rt, const std::string &instance_name, pmt_t user_arg) + : mb_mblock(rt, instance_name, user_arg), + d_disk_write(false) +{ + d_cs = define_port("cs", "usrp-rx-cs", true, mb_port::EXTERNAL); + + //d_disk_write=true; + + if(d_disk_write) { + d_ofile.open("rx_data.dat",std::ios::binary|std::ios::out); + d_cs_ofile.open("rx_cs.dat",std::ios::binary|std::ios::out); + } + +} + +usrp_rx::~usrp_rx() +{ + if(d_disk_write) { + d_ofile.close(); + d_cs_ofile.close(); + } +} + +void +usrp_rx::initial_transition() +{ + +} + +void +usrp_rx::handle_message(mb_message_sptr msg) +{ + pmt_t event = msg->signal(); + pmt_t port_id = msg->port_id(); + pmt_t data = msg->data(); + + // Theoretically only have 1 message to ever expect, but + // want to make sure its at least what we want + if(pmt_eq(port_id, d_cs->port_symbol())) { + + if(pmt_eqv(event, s_cmd_usrp_rx_start_reading)) + read_and_respond(data); + } +} + +void +usrp_rx::read_and_respond(pmt_t data) +{ + size_t ignore; + bool underrun; + unsigned int n_read; + unsigned int pkt_size = sizeof(transport_pkt); + + pmt_t invocation_handle = pmt_nth(0, data); + + // Need the handle to the RX port to send responses, this is passed + // by the USRP interface m-block + d_urx = + boost::any_cast<usrp_standard_rx *>(pmt_any_ref(pmt_nth(1, data))); + + if(verbose) + std::cout << "[usrp_rx] Waiting for packets..\n"; + + // Read by 512 which is packet size and send them back up + while(1) { + + pmt_t v_pkt = pmt_make_u8vector(pkt_size, 0); + transport_pkt *pkt = + (transport_pkt *) pmt_u8vector_writeable_elements(v_pkt, ignore); + + n_read = d_urx->read(pkt, pkt_size, &underrun); + + if(n_read != pkt_size) { + std::cerr << "[usrp_rx] Error reading packet, shutting down\n"; + d_cs->send(s_response_usrp_rx_read, + pmt_list3(PMT_NIL, PMT_F, PMT_NIL)); + return; + } + + if(underrun) + std::cout << "[usrp_rx] Underrun\n"; + + d_cs->send(s_response_usrp_rx_read, + pmt_list3(PMT_NIL, PMT_T, v_pkt)); + if(verbose) + std::cout << "[usrp_rx] Read 1 packet\n"; + + if(d_disk_write) { + if(pkt->chan() == 0x1f) + d_cs_ofile.write((const char *)pkt, transport_pkt::max_pkt_size()); + else + d_ofile.write((const char *)pkt, transport_pkt::max_pkt_size()); + + d_cs_ofile.flush(); + d_ofile.flush(); + } + } +} + +REGISTER_MBLOCK_CLASS(usrp_rx); diff --git a/usrp/host/lib/inband/usrp_rx.h b/usrp/host/lib/inband/usrp_rx.h new file mode 100644 index 000000000..e1a90a781 --- /dev/null +++ b/usrp/host/lib/inband/usrp_rx.h @@ -0,0 +1,55 @@ +/* -*- c++ -*- */ +/* + * Copyright 2007 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * GNU Radio is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3, or (at your option) + * any later version. + * + * GNU Radio is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ +#ifndef INCLUDED_USRP_RX_H +#define INCLUDED_USRP_RX_H + +#include <mb_mblock.h> +#include <fstream> + +class usrp_standard_rx; + +/*! + * \brief Implements the low level usb interface to the USRP + */ +class usrp_rx : public mb_mblock +{ + mb_port_sptr d_cs; + usrp_standard_rx *d_urx; + + bool d_disk_write; + std::ofstream d_ofile; + std::ofstream d_cs_ofile; + + public: + usrp_rx(mb_runtime *rt, const std::string &instance_name, pmt_t user_arg); + ~usrp_rx(); + void initial_transition(); + void handle_message(mb_message_sptr msg); + + private: + void read_and_respond(pmt_t data); + void read_data(); + +}; + + +#endif /* INCLUDED_USRP_RX_H */ + diff --git a/usrp/host/lib/inband/usrp_rx_stub.cc b/usrp/host/lib/inband/usrp_rx_stub.cc new file mode 100644 index 000000000..bf78ddf27 --- /dev/null +++ b/usrp/host/lib/inband/usrp_rx_stub.cc @@ -0,0 +1,183 @@ +/* -*- c++ -*- */ +/* + * Copyright 2007 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * GNU Radio is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3, or (at your option) + * any later version. + * + * GNU Radio is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#include <usrp_rx_stub.h> + +#include <iostream> +#include <vector> +#include <usb.h> +#include <mb_class_registry.h> +#include <usrp_inband_usb_packet.h> +#include <fpga_regs_common.h> +#include "usrp_standard.h" +#include <stdio.h> +#include "ui_nco.h" +#include <fstream> + +#include <symbols_usrp_rx_cs.h> + +typedef usrp_inband_usb_packet transport_pkt; + +static const bool verbose = false; + +bool usrp_rx_stop; + +// Used for the fake control packet response code to send the responses back up +// the RX. The TX stub dumps responses in to this queue. +std::queue<pmt_t> d_cs_queue; + +usrp_rx_stub::usrp_rx_stub(mb_runtime *rt, const std::string &instance_name, pmt_t user_arg) + : mb_mblock(rt, instance_name, user_arg), + d_samples_per_frame((long)(126)), + d_amplitude(16384), + d_disk_write(false) +{ + d_cs = define_port("cs", "usrp-rx-cs", true, mb_port::EXTERNAL); + + // initialize NCO + double freq = 100e3; + int interp = 32; // 32 -> 4MS/s + double sample_rate = 128e6 / interp; + d_nco.set_freq(2*M_PI * freq/sample_rate); + + //d_disk_write = true; + + if(d_disk_write) + d_ofile.open("raw_rx.dat",std::ios::binary|std::ios::out); + + usrp_rx_stop = false; +} + +usrp_rx_stub::~usrp_rx_stub() +{ + if(d_disk_write) + d_ofile.close(); +} + +void +usrp_rx_stub::initial_transition() +{ + +} + +void +usrp_rx_stub::handle_message(mb_message_sptr msg) +{ + pmt_t event = msg->signal(); + pmt_t port_id = msg->port_id(); + pmt_t data = msg->data(); + + // Theoretically only have 1 message to ever expect, but + // want to make sure its at least what we want + if(pmt_eq(port_id, d_cs->port_symbol())) { + + if(verbose) + std::cout << "[USRP_RX_STUB] Starting...\n"; + + if(pmt_eqv(event, s_cmd_usrp_rx_start_reading)) + read_and_respond(data); + } +} + +void +usrp_rx_stub::read_and_respond(pmt_t data) +{ + + while(!usrp_rx_stop) { + + long nsamples_this_frame = d_samples_per_frame; + + size_t nshorts = 2 * nsamples_this_frame; // 16-bit I & Q + long channel = 0; + long n_bytes = nshorts*2; + pmt_t uvec = pmt_make_s16vector(nshorts, 0); + size_t ignore; + int16_t *samples = pmt_s16vector_writeable_elements(uvec, ignore); + + // fill in the complex sinusoid + + for (int i = 0; i < nsamples_this_frame; i++){ + + if (1){ + gr_complex s; + d_nco.sincos(&s, 1, d_amplitude); + // write 16-bit i & q + samples[2*i] = (int16_t) s.real(); + samples[2*i+1] = (int16_t) s.imag(); + } + else { + gr_complex s(d_amplitude, d_amplitude); + + // write 16-bit i & q + samples[2*i] = (int16_t) s.real(); + samples[2*i+1] = (int16_t) s.imag(); + } + } + + if(d_disk_write) + d_ofile.write((const char *)samples, n_bytes); + + pmt_t v_pkt = pmt_make_u8vector(sizeof(transport_pkt), 0); + transport_pkt *pkt = + (transport_pkt *) pmt_u8vector_writeable_elements(v_pkt, ignore); + + pkt->set_header(0, channel, 0, n_bytes); + pkt->set_timestamp(0xffffffff); + memcpy(pkt->payload(), samples, n_bytes); + + d_cs->send(s_response_usrp_rx_read, pmt_list3(PMT_NIL, PMT_T, v_pkt)); + + // Now lets check the shared CS queue between the TX and RX stub. Each + // element in a queue is a list where the first element is an invocation + // handle and the second element is a PMT u8 vect representation of the + // CS packet response which can just be passed transparently. + while(!d_cs_queue.empty()) { + + pmt_t cs_pkt = d_cs_queue.front(); + d_cs_queue.pop(); + + pmt_t invocation_handle = pmt_nth(0, cs_pkt); + pmt_t v_pkt = pmt_nth(1, cs_pkt); + + d_cs->send(s_response_usrp_rx_read, + pmt_list3(invocation_handle, + PMT_T, + v_pkt)); // Take the front CS pkt + + + if(verbose) + std::cout << "[USRP_RX_STUB] Received CS response from TX stub\n"; + } + + } + + usrp_rx_stop = false; + + if(verbose) + std::cout << "[USRP_RX_STUB] Got fake RX stop\n"; + +} + +REGISTER_MBLOCK_CLASS(usrp_rx_stub); diff --git a/usrp/host/lib/inband/usrp_rx_stub.h b/usrp/host/lib/inband/usrp_rx_stub.h new file mode 100644 index 000000000..483af5b48 --- /dev/null +++ b/usrp/host/lib/inband/usrp_rx_stub.h @@ -0,0 +1,71 @@ +/* -*- c++ -*- */ +/* + * Copyright 2007 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * GNU Radio is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3, or (at your option) + * any later version. + * + * GNU Radio is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ +#ifndef INCLUDED_USRP_RX_STUB_H +#define INCLUDED_USRP_RX_STUB_H + +#include <mb_mblock.h> +#include <vector> +#include "usrp_standard.h" +#include "ui_nco.h" +#include <fstream> +#include <queue> +#include <usrp_inband_usb_packet.h> + +typedef usrp_inband_usb_packet transport_pkt; + +extern bool usrp_rx_stop; // used to communicate a 'stop' to the RX stub +extern std::queue<pmt_t> d_cs_queue; + +/*! + * \brief Implements the low level usb interface to the USRP + */ +class usrp_rx_stub : public mb_mblock +{ + public: + + mb_port_sptr d_cs; + usrp_standard_rx* d_urx; + + long d_samples_per_frame; + + // for generating sine wave output + ui_nco<float,float> d_nco; + double d_amplitude; + + bool d_disk_write; + + std::ofstream d_ofile; + + public: + usrp_rx_stub(mb_runtime *rt, const std::string &instance_name, pmt_t user_arg); + ~usrp_rx_stub(); + void initial_transition(); + void handle_message(mb_message_sptr msg); + + private: + void read_and_respond(pmt_t data); + void read_data(); + +}; + + +#endif /* INCLUDED_USRP_RX_H */ + diff --git a/usrp/host/lib/inband/usrp_server.cc b/usrp/host/lib/inband/usrp_server.cc index 800bf0e15..760397dc7 100644 --- a/usrp/host/lib/inband/usrp_server.cc +++ b/usrp/host/lib/inband/usrp_server.cc @@ -27,39 +27,19 @@ #include <usrp_inband_usb_packet.h> #include <mb_class_registry.h> #include <vector> +#include <usrp_usb_interface.h> + +#include <symbols_usrp_server_cs.h> +#include <symbols_usrp_channel.h> +#include <symbols_usrp_tx.h> +#include <symbols_usrp_rx.h> +#include <symbols_usrp_low_level_cs.h> +#include <symbols_usrp_interface_cs.h> +static pmt_t s_shutdown = pmt_intern("%shutdown"); typedef usrp_inband_usb_packet transport_pkt; // makes conversion to gigabit easy -// FIXME We should machine generate these by a simple preprocessor run over this file -// -// These are all the messages that we expect to receive. -// -// We "intern" these here (make them into symbols) so that our -// comparisions below are effectively pointer comparisons. - -static pmt_t s_cmd_allocate_channel = pmt_intern("cmd-allocate-channel"); -static pmt_t s_cmd_close = pmt_intern("cmd-close"); -static pmt_t s_cmd_deallocate_channel = pmt_intern("cmd-deallocate-channel"); -static pmt_t s_cmd_open = pmt_intern("cmd-open"); -static pmt_t s_cmd_start_recv_raw_samples = pmt_intern("cmd-start-recv-raw-samples"); -static pmt_t s_cmd_stop_recv_raw_samples = pmt_intern("cmd-stop-recv-raw-samples"); -static pmt_t s_cmd_to_control_channel = pmt_intern("cmd-to-control-channel"); -static pmt_t s_cmd_xmit_raw_frame = pmt_intern("cmd-xmit-raw-frame"); -static pmt_t s_cmd_max_capacity = pmt_intern("cmd-max-capacity"); -static pmt_t s_cmd_ntx_chan = pmt_intern("cmd-ntx-chan"); -static pmt_t s_cmd_nrx_chan = pmt_intern("cmd-nrx-chan"); -static pmt_t s_cmd_current_capacity_allocation = pmt_intern("cmd-current-capacity-allocation"); -static pmt_t s_response_allocate_channel = pmt_intern("response-allocate-channel"); -static pmt_t s_response_close = pmt_intern("response-close"); -static pmt_t s_response_deallocate_channel = pmt_intern("response-deallocate-channel"); -static pmt_t s_response_from_control_channel = pmt_intern("response-from-control-channel"); -static pmt_t s_response_open = pmt_intern("response-open"); -static pmt_t s_response_recv_raw_samples = pmt_intern("response-recv-raw-samples"); -static pmt_t s_response_xmit_raw_frame = pmt_intern("response-xmit-raw-frame"); -static pmt_t s_response_max_capacity = pmt_intern("response-max-capacity"); -static pmt_t s_response_ntx_chan = pmt_intern("response-ntx-chan"); -static pmt_t s_response_nrx_chan = pmt_intern("response-nrx-chan"); -static pmt_t s_response_current_capacity_allocation = pmt_intern("response-current-capacity-allocation"); +const static bool verbose = false; static std::string str(long x) @@ -70,36 +50,75 @@ str(long x) } usrp_server::usrp_server(mb_runtime *rt, const std::string &instance_name, pmt_t user_arg) - : mb_mblock(rt, instance_name, user_arg) + : mb_mblock(rt, instance_name, user_arg), + d_fake_rx(false) { - // define our ports + // Dictionary for arguments to all of the components + pmt_t usrp_dict = user_arg; + // control & status port d_cs = define_port("cs", "usrp-server-cs", true, mb_port::EXTERNAL); + d_cs_usrp = define_port("cs_usrp", "usrp-interface-cs", false, mb_port::INTERNAL); // ports // // (if/when we do replicated ports, these will be replaced by a // single replicated port) for(int port=0; port < N_PORTS; port++) { - d_tx.push_back(define_port("tx"+str(port), "usrp-tx", true, mb_port::EXTERNAL)); - d_rx.push_back(define_port("rx"+str(port), "usrp-rx", true, mb_port::EXTERNAL)); + + d_tx.push_back(define_port("tx"+str(port), + "usrp-tx", + true, + mb_port::EXTERNAL)); + + d_rx.push_back(define_port("rx"+str(port), + "usrp-rx", + true, + mb_port::EXTERNAL)); } - // FIXME ... initializing to 2 channels on each for now, eventually we should - // query the FPGA to get these values - d_ntx_chan = 2; + define_component("usrp", "usrp_usb_interface", usrp_dict); + connect("self", "cs_usrp", "usrp", "cs"); + + d_defer=false; + d_opened=false; + + // FIXME: needs to be returned from open, if we want to use this d_nrx_chan = 2; + d_ntx_chan = 2; // Initialize capacity on each channel to 0 and to no owner + // Also initialize the USRP standard tx/rx pointers to NULL + for(int chan=0; chan < d_ntx_chan; chan++) + d_chaninfo_tx.push_back(channel_info()); + + for(int chan=0; chan < d_nrx_chan; chan++) + d_chaninfo_rx.push_back(channel_info()); + + d_rx_chan_mask = 0; + + for(int i=0; i < D_MAX_RID; i++) + d_rids.push_back(rid_info()); + + //d_fake_rx=true; +} + +void +usrp_server::reset_channels() +{ + for(int chan=0; chan < d_ntx_chan; chan++) { d_chaninfo_tx[chan].assigned_capacity = 0; d_chaninfo_tx[chan].owner = PMT_NIL; } + for(int chan=0; chan < d_nrx_chan; chan++) { d_chaninfo_rx[chan].assigned_capacity = 0; d_chaninfo_rx[chan].owner = PMT_NIL; } + + d_rx_chan_mask = 0; } usrp_server::~usrp_server() @@ -119,78 +138,328 @@ usrp_server::handle_message(mb_message_sptr msg) pmt_t event = msg->signal(); // the "name" of the message pmt_t port_id = msg->port_id(); // which port it came in on pmt_t data = msg->data(); - pmt_t metadata = msg->metadata(); pmt_t invocation_handle; - pmt_t reply_data; + pmt_t metadata = msg->metadata(); pmt_t status; - if (1){ + long port; + + if (pmt_eq(event, s_shutdown)) // ignore (for now) + return; + + invocation_handle = pmt_nth(0, data); + + if (0){ std::cout << "[USRP_SERVER] event: " << event << std::endl; std::cout << "[USRP_SERVER] port_id: " << port_id << std::endl; } - // It would be nice if this were all table driven, and we could - // compute our state transition as f(current_state, port_id, signal) + // It would be nice if this were all table driven, and we could compute our + // state transition as f(current_state, port_id, signal) + + // A message from the USRP CS, which should *only* be responses + // + // It is important that this set come before checking messages of any other + // components. This is since we always want to listen to the low level USRP + // server, even if we aren't initialized we are waiting for responses to + // become initialized. Likewise, after the usrp_server is "closed", we still + // want to pass responses back from the low level. - if (pmt_eq(port_id, d_cs->port_symbol())){ // message came in on our control/status port + //---------------- USRP RESPONSE ---------------// + if (pmt_eq(port_id, d_cs_usrp->port_symbol())) { + + //-------------- USRP OPEN ------------------// + if(pmt_eq(event, s_response_usrp_open)) { + // pass the response back over the regular CS port + pmt_t status = pmt_nth(1, data); + d_cs->send(s_response_open, pmt_list2(invocation_handle, status)); - if (pmt_eq(event, s_cmd_open)){ - // extract args from data - invocation_handle = pmt_nth(0, data); - long which_usrp = pmt_to_long(pmt_nth(1, data)); // integer usrp id, usually 0 + if(pmt_eqv(status,PMT_T)) { + d_opened = true; + d_defer = false; + recall_defer_queue(); + } + + return; + } + //------------- USRP CLOSE -------------------// + else if (pmt_eq(event, s_response_usrp_close)) { + pmt_t status = pmt_nth(1, data); + d_cs->send(s_response_close, pmt_list2(invocation_handle, status)); + + if(pmt_eqv(status,PMT_T)) { + d_opened = false; + d_defer = false; + reset_channels(); + recall_defer_queue(); + } - // Do the right thing.... - // build a reply - (void) which_usrp; // avoid unused warning + return; + } + //--------------- USRP WRITE --------------// + else if (pmt_eq(event, s_response_usrp_write)) { + + pmt_t status = pmt_nth(1, data); + long channel = pmt_to_long(pmt_nth(2, data)); + long port; + + // Do not report back responses if they were generated from a + // command packet + if(channel == 0x1f) + return; + + // Find the port through the owner of the channel + if((port = tx_port_index(d_chaninfo_tx[channel].owner)) !=-1 ) + d_tx[port]->send(s_response_xmit_raw_frame, + pmt_list2(invocation_handle, status)); + return; + } + //--------------- USRP READ ---------------// + else if (pmt_eq(event, s_response_usrp_read)) { + + pmt_t status = pmt_nth(1, data); + + if(!pmt_eqv(status, PMT_T)) { + std::cerr << "[USRP_SERVER] Error receiving packet\n"; + return; + } + else { + handle_response_usrp_read(data); + return; + } + } + + goto unhandled; + } + + // Checking for defer on all other messages + if(d_defer) { + if (verbose) + std::cout << "[USRP_SERVER] Received msg while deferring (" + << msg->signal() << ")\n"; + d_defer_queue.push(msg); + return; + } + + //--------- CONTROL / STATUS ------------// + if (pmt_eq(port_id, d_cs->port_symbol())){ + + //----------- OPEN -----------// + if (pmt_eq(event, s_cmd_open)){ - // if everything OK - status = PMT_T; - reply_data = pmt_list2(invocation_handle, status); + // Reject if already open + if(d_opened) { + d_cs->send(s_response_open, pmt_list2(invocation_handle, s_err_usrp_already_opened)); + return; + } - // ...and send it - d_cs->send(s_response_open, reply_data); + // the parameters are the same to the low level interface, so we just pass 'data' along + d_cs_usrp->send(s_cmd_usrp_open, data); + + d_defer = true; + return; } + //---------- CLOSE -----------// else if (pmt_eq(event, s_cmd_close)){ - // ... + + if(!d_opened) { + d_cs->send(s_response_close, pmt_list2(invocation_handle, s_err_usrp_already_closed)); + return; + } + + d_defer = true; + d_cs_usrp->send(s_cmd_usrp_close, pmt_list1(invocation_handle)); + + return; } + //---------- MAX CAPACITY ----------// else if (pmt_eq(event, s_cmd_max_capacity)) { - invocation_handle = pmt_nth(0, data); - reply_data = pmt_list2(invocation_handle, pmt_from_long(max_capacity())); - d_cs->send(s_response_max_capacity, reply_data); + + if(!d_opened) { + d_cs->send(s_response_max_capacity, + pmt_list3(invocation_handle, s_err_usrp_not_opened, pmt_from_long(0))); + return; + } + + d_cs->send(s_response_max_capacity, + pmt_list3(invocation_handle, + PMT_T, + pmt_from_long(max_capacity()))); return; } + //---------- NTX CHAN --------------// else if (pmt_eq(event, s_cmd_ntx_chan)) { - invocation_handle = pmt_nth(0, data); - reply_data = pmt_list2(invocation_handle, pmt_from_long(d_ntx_chan)); - d_cs->send(s_response_ntx_chan, reply_data); + + if(!d_opened) { + d_cs->send(s_response_ntx_chan, + pmt_list3(invocation_handle, s_err_usrp_not_opened, pmt_from_long(0))); + return; + } + + d_cs->send(s_response_ntx_chan, + pmt_list3(invocation_handle, + PMT_T, + pmt_from_long(d_ntx_chan))); + return; } + //---------- NRX CHAN -----------// else if (pmt_eq(event, s_cmd_nrx_chan)) { - invocation_handle = pmt_nth(0, data); - reply_data = pmt_list2(invocation_handle, pmt_from_long(d_nrx_chan)); - d_cs->send(s_response_nrx_chan, reply_data); - } + + if(!d_opened) { + d_cs->send(s_response_nrx_chan, + pmt_list3(invocation_handle, s_err_usrp_not_opened, pmt_from_long(0))); + return; + } + + d_cs->send(s_response_nrx_chan, + pmt_list3(invocation_handle, + PMT_T, + pmt_from_long(d_nrx_chan))); + return; + } + //--------- ALLOCATION? -----------// else if (pmt_eq(event, s_cmd_current_capacity_allocation)) { - invocation_handle = pmt_nth(0, data); - reply_data = pmt_list2(invocation_handle, pmt_from_long(current_capacity_allocation())); - d_cs->send(s_response_current_capacity_allocation, reply_data); + + if(!d_opened) { + d_cs->send(s_response_current_capacity_allocation, + pmt_list3(invocation_handle, + s_err_usrp_not_opened, + pmt_from_long(0))); + return; + } + + d_cs->send(s_response_current_capacity_allocation, + pmt_list3(invocation_handle, + PMT_T, + pmt_from_long(current_capacity_allocation()))); + return; } goto unhandled; } + + //-------------- TX ---------------// + if ((port = tx_port_index(port_id)) != -1) { + + //------------ ALLOCATE (TX) ----------------// + if (pmt_eq(event, s_cmd_allocate_channel)){ + + if(!d_opened) { + d_tx[port]->send(s_response_allocate_channel, + pmt_list3(invocation_handle, + s_err_usrp_not_opened, + pmt_from_long(0))); + return; + } + + handle_cmd_allocate_channel(d_tx[port], d_chaninfo_tx, data); + return; + } + + //----------- DEALLOCATE (TX) ---------------// + if (pmt_eq(event, s_cmd_deallocate_channel)) { + + if(!d_opened) { + d_tx[port]->send(s_response_deallocate_channel, + pmt_list3(invocation_handle, + s_err_usrp_not_opened, + pmt_from_long(0))); + return; + } - if (pmt_eq(event, s_cmd_allocate_channel)){ - handle_cmd_allocate_channel(port_id, data); - return; - } + handle_cmd_deallocate_channel(d_tx[port], d_chaninfo_tx, data); + return; + } + + //-------------- XMIT RAW FRAME -----------------/ + if (pmt_eq(event, s_cmd_xmit_raw_frame)){ - if (pmt_eq(event, s_cmd_deallocate_channel)) { - handle_cmd_deallocate_channel(port_id, data); - return; + if(!d_opened) { + d_tx[port]->send(s_response_xmit_raw_frame, + pmt_list2(invocation_handle, s_err_usrp_not_opened)); + return; + } + + handle_cmd_xmit_raw_frame(d_tx[port], d_chaninfo_tx, data); + return; + } + + //-------------- CONTROL PACKET -----------------/ + if (pmt_eq(event, s_cmd_to_control_channel)) { + + if(!d_opened) { + d_tx[port]->send(s_response_xmit_raw_frame, + pmt_list2(invocation_handle, s_err_usrp_not_opened)); + return; + } + + handle_cmd_to_control_channel(d_tx[port], d_chaninfo_tx, data); + return; + + } + + goto unhandled; } + + //-------------- RX ---------------// + if ((port = rx_port_index(port_id)) != -1) { - if (pmt_eq(event, s_cmd_xmit_raw_frame)){ - handle_cmd_xmit_raw_frame(data); - return; + //------------ ALLOCATE (RX) ----------------// + if (pmt_eq(event, s_cmd_allocate_channel)) { + + if(!d_opened) { + d_rx[port]->send(s_response_allocate_channel, + pmt_list3(invocation_handle, + s_err_usrp_not_opened, + pmt_from_long(0))); + return; + } + + handle_cmd_allocate_channel(d_rx[port], d_chaninfo_rx, data); + return; + } + + //----------- DEALLOCATE (RX) ---------------// + if (pmt_eq(event, s_cmd_deallocate_channel)) { + + if(!d_opened) { + d_rx[port]->send(s_response_deallocate_channel, + pmt_list3(invocation_handle, + s_err_usrp_not_opened, + pmt_from_long(0))); + return; + } + + handle_cmd_deallocate_channel(d_rx[port], d_chaninfo_rx, data); + return; + } + + //-------------- START RECV ----------------// + if (pmt_eq(event, s_cmd_start_recv_raw_samples)) { + + if(!d_opened) { + d_rx[port]->send(s_response_recv_raw_samples, + pmt_list2(invocation_handle, s_err_usrp_not_opened)); + return; + } + + handle_cmd_start_recv_raw_samples(d_rx[port], d_chaninfo_rx, data); + return; + } + + //-------------- STOP RECV ----------------// + if (pmt_eq(event, s_cmd_stop_recv_raw_samples)) { + + if(!d_opened) + return; + + // FIX ME : no response for stopping? even if error? (permissions) + handle_cmd_stop_recv_raw_samples(d_rx[port], d_chaninfo_rx, data); + + return; + } + + goto unhandled; } unhandled: @@ -231,128 +500,94 @@ long usrp_server::current_capacity_allocation() { return capacity; } -void usrp_server::handle_cmd_allocate_channel(pmt_t port_id, pmt_t data) { - +void +usrp_server::handle_cmd_allocate_channel( + mb_port_sptr port, + std::vector<struct channel_info> &chan_info, + pmt_t data) +{ pmt_t invocation_handle = pmt_nth(0, data); long rqstd_capacity = pmt_to_long(pmt_nth(1, data)); - long chan, port; - pmt_t reply_data; + long chan; - // If it's a TX port, allocate on a free channel, else check if it's a RX port - // and allocate. - if((port = tx_port_index(port_id)) != -1) { + // Check capacity exists + if((D_USB_CAPACITY - current_capacity_allocation()) < rqstd_capacity) { - // Check capacity exists - if((D_USB_CAPACITY - current_capacity_allocation()) < rqstd_capacity) { - reply_data = pmt_list3(invocation_handle, pmt_from_long(RQSTD_CAPACITY_UNAVAIL), PMT_NIL); // no capacity available - d_tx[port]->send(s_response_allocate_channel, reply_data); - return; - } + // no capacity available + port->send(s_response_allocate_channel, + pmt_list3(invocation_handle, + s_err_requested_capacity_unavailable, + PMT_NIL)); + return; + } - // Find a free channel, assign the capacity and respond - for(chan=0; chan < d_ntx_chan; chan++) { - if(d_chaninfo_tx[chan].owner == PMT_NIL) { - d_chaninfo_tx[chan].owner = port_id; - d_chaninfo_tx[chan].assigned_capacity = rqstd_capacity; - reply_data = pmt_list3(invocation_handle, PMT_T, pmt_from_long(chan)); - d_tx[port]->send(s_response_allocate_channel, reply_data); - return; - } - } + // Find a free channel, assign the capacity and respond + for(chan=0; chan < (long)chan_info.size(); chan++) { - std::cout << "[USRP_SERVER] Couldnt find a TX chan\n"; + if(verbose) + std::cout << "[USRP_SERVER] Checking chan: " << chan + << " owner " << chan_info[chan].owner + << " size " << chan_info.size() + << std::endl; - reply_data = pmt_list3(invocation_handle, pmt_from_long(CHANNEL_UNAVAIL), PMT_NIL); // no free TX chan found - d_tx[port]->send(s_response_allocate_channel, reply_data); - return; - } + if(chan_info[chan].owner == PMT_NIL) { - // Repeat the same process on the RX side if the port was not determined to be TX - if((port = rx_port_index(port_id)) != -1) { - - if((D_USB_CAPACITY - current_capacity_allocation()) < rqstd_capacity) { - reply_data = pmt_list3(invocation_handle, pmt_from_long(RQSTD_CAPACITY_UNAVAIL), PMT_NIL); // no capacity available - d_rx[port]->send(s_response_allocate_channel, reply_data); + chan_info[chan].owner = port->port_symbol(); + chan_info[chan].assigned_capacity = rqstd_capacity; + + port->send(s_response_allocate_channel, + pmt_list3(invocation_handle, + PMT_T, + pmt_from_long(chan))); + + if(verbose) + std::cout << "[USRP_SERVER] Assigning channel: " << chan + << " to " << chan_info[chan].owner + << std::endl; return; } + + } - for(chan=0; chan < d_nrx_chan; chan++) { - if(d_chaninfo_rx[chan].owner == PMT_NIL) { - d_chaninfo_rx[chan].owner = port_id; - d_chaninfo_rx[chan].assigned_capacity = rqstd_capacity; - reply_data = pmt_list3(invocation_handle, PMT_T, pmt_from_long(chan)); - d_rx[port]->send(s_response_allocate_channel, reply_data); - return; - } - } + if (verbose) + std::cout << "[USRP_SERVER] Couldnt find a TX chan\n"; - std::cout << "[USRP_SERVER] Couldnt find a RX chan\n"; - reply_data = pmt_list3(invocation_handle, pmt_from_long(CHANNEL_UNAVAIL), PMT_NIL); // no free RX chan found - d_rx[port]->send(s_response_allocate_channel, reply_data); - return; - } + // no free TX chan found + port->send(s_response_allocate_channel, + pmt_list3(invocation_handle, + s_err_channel_unavailable, + PMT_NIL)); + return; } // Check the port type and deallocate assigned capacity based on this, ensuring -// that the owner of the method invocation is the owner of the port and that -// the channel number is valid. -void usrp_server::handle_cmd_deallocate_channel(pmt_t port_id, pmt_t data) { +// that the owner of the method invocation is the owner of the port and that the +// channel number is valid. +void +usrp_server::handle_cmd_deallocate_channel( + mb_port_sptr port, + std::vector<struct channel_info> &chan_info, + pmt_t data) +{ pmt_t invocation_handle = pmt_nth(0, data); long channel = pmt_to_long(pmt_nth(1, data)); - long port; - pmt_t reply_data; - - // Check that the channel number is valid, and that the calling port is the owner - // of the channel, and if so remove the assigned capacity. - if((port = tx_port_index(port_id)) != -1) { - - if(channel >= d_ntx_chan) { - reply_data = pmt_list2(invocation_handle, pmt_from_long(CHANNEL_INVALID)); // not a legit channel number - d_tx[port]->send(s_response_deallocate_channel, reply_data); - return; - } - if(d_chaninfo_tx[channel].owner != port_id) { - reply_data = pmt_list2(invocation_handle, pmt_from_long(PERMISSION_DENIED)); // not the owner of the port - d_tx[port]->send(s_response_deallocate_channel, reply_data); - return; - } - - d_chaninfo_tx[channel].assigned_capacity = 0; - d_chaninfo_tx[channel].owner = PMT_NIL; - - reply_data = pmt_list2(invocation_handle, PMT_T); - d_tx[port]->send(s_response_deallocate_channel, reply_data); + // Ensure the channel is valid and the caller owns the port + if(!check_valid(port, channel, chan_info, + pmt_list2(s_response_deallocate_channel, invocation_handle))) return; - } - - // Repeated process on the RX side - if((port = rx_port_index(port_id)) != -1) { - if(channel >= d_nrx_chan) { - reply_data = pmt_list2(invocation_handle, pmt_from_long(CHANNEL_INVALID)); // not a legit channel number - d_rx[port]->send(s_response_deallocate_channel, reply_data); - return; - } - - if(d_chaninfo_rx[channel].owner != port_id) { - reply_data = pmt_list2(invocation_handle, pmt_from_long(PERMISSION_DENIED)); // not the owner of the port - d_rx[port]->send(s_response_deallocate_channel, reply_data); - return; - } - - d_chaninfo_rx[channel].assigned_capacity = 0; - d_chaninfo_rx[channel].owner = PMT_NIL; - - reply_data = pmt_list2(invocation_handle, PMT_T); - d_rx[port]->send(s_response_deallocate_channel, reply_data); - return; - } + chan_info[channel].assigned_capacity = 0; + chan_info[channel].owner = PMT_NIL; + port->send(s_response_deallocate_channel, + pmt_list2(invocation_handle, + PMT_T)); + return; } -void usrp_server::handle_cmd_xmit_raw_frame(pmt_t data) { +void usrp_server::handle_cmd_xmit_raw_frame(mb_port_sptr port, std::vector<struct channel_info> &chan_info, pmt_t data) { size_t n_bytes, psize; long max_payload_len = transport_pkt::max_payload(); @@ -361,10 +596,18 @@ void usrp_server::handle_cmd_xmit_raw_frame(pmt_t data) { long channel = pmt_to_long(pmt_nth(1, data)); const void *samples = pmt_uniform_vector_elements(pmt_nth(2, data), n_bytes); long timestamp = pmt_to_long(pmt_nth(3, data)); + + // Ensure the channel is valid and the caller owns the port + if(!check_valid(port, channel, chan_info, + pmt_list2(s_response_xmit_raw_frame, invocation_handle))) + return; + + // Determine the number of packets to allocate contiguous memory for + // bursting over the USB and get a pointer to the memory to be used in + // building the packets + long n_packets = + static_cast<long>(std::ceil(n_bytes / (double)max_payload_len)); - // Determine the number of packets to allocate contiguous memory for bursting over the - // USB and get a pointer to the memory to be used in building the packets - long n_packets = static_cast<long>(std::ceil(n_bytes / (double)max_payload_len)); pmt_t v_packets = pmt_make_u8vector(sizeof(transport_pkt) * n_packets, 0); transport_pkt *pkts = @@ -372,7 +615,8 @@ void usrp_server::handle_cmd_xmit_raw_frame(pmt_t data) { for(int n=0; n < n_packets; n++) { - long payload_len = std::min((long)(n_bytes-(n*max_payload_len)), (long)max_payload_len); + long payload_len = + std::min((long)(n_bytes-(n*max_payload_len)), (long)max_payload_len); if(n == 0) { // first packet gets start of burst flag and timestamp pkts[n].set_header(pkts[n].FL_START_OF_BURST, channel, 0, payload_len); @@ -382,14 +626,740 @@ void usrp_server::handle_cmd_xmit_raw_frame(pmt_t data) { pkts[n].set_timestamp(0xffffffff); } - memcpy(pkts[n].payload(), (uint8_t *)samples+(max_payload_len * n), payload_len); + memcpy(pkts[n].payload(), + (uint8_t *)samples+(max_payload_len * n), + payload_len); + + } + + + pkts[n_packets-1].set_end_of_burst(); // set the last packet's end of burst + + if (verbose) + std::cout << "[USRP_SERVER] Received raw frame invocation: " + << invocation_handle << std::endl; + + // The actual response to the write will be generated by a + // s_response_usrp_write + d_cs_usrp->send(s_cmd_usrp_write, + pmt_list3(invocation_handle, + pmt_from_long(channel), + v_packets)); + + return; +} + +void usrp_server::handle_cmd_to_control_channel(mb_port_sptr port, std::vector<struct channel_info> &chan_info, pmt_t data) +{ + + pmt_t invocation_handle = pmt_nth(0, data); + pmt_t subpackets = pmt_nth(1, data); + + long n_subpkts = pmt_length(subpackets); + long curr_subpkt = 0; + + size_t psize; + long payload_len = 0; + long channel = 0x1f; + + // The design of the following code is optimized for simplicity, not + // performance. To performance optimize this code, the total size in bytes + // needed for all of the CS packets is needed to allocate contiguous memory + // which contains the USB packets for bursting over the bus. However to do + // this the packets subpackets would need to be parsed twice and their sizes + // would need to be determined. + // + // The approach taken is to keep parsing the subpackets and putting them in to + // USB packets. Once the USB packet is full, a write is sent for it and + // another packet is created. + // + // The subpacket creation methods will return false if the subpacket will not + // fit in to the current USB packet. In these cases a new USB packet is + // created and the old is sent. + + new_packet: + // This code needs to become "smart" and only make a new packet when full + pmt_t v_packet = pmt_make_u8vector(sizeof(transport_pkt), 0); + transport_pkt *pkt = (transport_pkt *) pmt_u8vector_writeable_elements(v_packet, psize); + payload_len = 0; + + pkt->set_header(0, channel, 0, payload_len); + pkt->set_timestamp(0xffffffff); + + while(curr_subpkt < n_subpkts) { + + pmt_t subp = pmt_nth(curr_subpkt, subpackets); + pmt_t subp_cmd = pmt_nth(0, subp); + pmt_t subp_data = pmt_nth(1, subp); + + //--------- PING FIXED --------------// + if(pmt_eq(subp_cmd, s_op_ping_fixed)) { + + long urid = pmt_to_long(pmt_nth(0, subp_data)); + long pingval = pmt_to_long(pmt_nth(1, subp_data)); + + // USRP server sets request ID's to keep track of which application gets + // what response back. To allow a full 6-bits for an RID to the user, we + // keep a mapping and replace the RID's as the packets go in and out. If + // there are no RID's available, the command is thrown away silently. + long srid; + if((srid = next_rid()) == -1) + goto subpkt_bail; + + // We use a vector to store the owner of the ping request and will use it + // to send the request on any RX port they own. + d_rids[srid].owner = port->port_symbol(); + d_rids[srid].user_rid = urid; + + // Adds a ping after the previous command in the pkt + if(!pkt->cs_ping(srid, pingval)) + { + d_cs_usrp->send(s_cmd_usrp_write, + pmt_list3(invocation_handle, + pmt_from_long(channel), + v_packet)); + + // Return the RID + d_rids[srid].owner = PMT_NIL; + + goto new_packet; + } + + if(verbose) + std::cout << "[USRP_SERVER] Received ping command request" + << " assigning RID " << srid << std::endl; + + } + + //----------- WRITE REG ---------------// + if(pmt_eq(subp_cmd, s_op_write_reg)) { + + long reg_num = pmt_to_long(pmt_nth(0, subp_data)); + long val = pmt_to_long(pmt_nth(1, subp_data)); + + if(!pkt->cs_write_reg(reg_num, val)) + { + d_cs_usrp->send(s_cmd_usrp_write, + pmt_list3(invocation_handle, + pmt_from_long(channel), + v_packet)); + + goto new_packet; + } + + if(verbose) + std::cout << "[USRP_SERVER] Received write register request " + << "(" + << "Reg: " << reg_num << ", " + << "Val: " << val + << ")\n"; + } + + //------- WRITE REG MASKED ----------// + if(pmt_eq(subp_cmd, s_op_write_reg_masked)) { + + long reg_num = pmt_to_long(pmt_nth(0, subp_data)); + long val = pmt_to_long(pmt_nth(1, subp_data)); + long mask = pmt_to_long(pmt_nth(2, subp_data)); + + if(!pkt->cs_write_reg_masked(reg_num, val, mask)) + { + d_cs_usrp->send(s_cmd_usrp_write, + pmt_list3(invocation_handle, + pmt_from_long(channel), + v_packet)); + + goto new_packet; + } + + if(verbose) + std::cout << "[USRP_SERVER] Received write register masked request\n"; + } + + //------------ READ REG --------------// + if(pmt_eq(subp_cmd, s_op_read_reg)) { + + long urid = pmt_to_long(pmt_nth(0, subp_data)); + long reg_num = pmt_to_long(pmt_nth(1, subp_data)); + + long srid; + if((srid = next_rid()) == -1) + goto subpkt_bail; + + d_rids[srid].owner = port->port_symbol(); + d_rids[srid].user_rid = urid; + + if(!pkt->cs_read_reg(srid, reg_num)) + { + d_cs_usrp->send(s_cmd_usrp_write, + pmt_list3(invocation_handle, + pmt_from_long(channel), + v_packet)); + + // Return the rid + d_rids[srid].owner = PMT_NIL; + + goto new_packet; + } + + if(verbose) + std::cout << "[USRP_SERVER] Received read register request" + << " assigning RID " << srid << std::endl; + } + + //------------ DELAY --------------// + if(pmt_eq(subp_cmd, s_op_delay)) { + + long ticks = pmt_to_long(pmt_nth(0, subp_data)); + + if(!pkt->cs_delay(ticks)) + { + d_cs_usrp->send(s_cmd_usrp_write, + pmt_list3(invocation_handle, + pmt_from_long(channel), + v_packet)); + + goto new_packet; + } + + if(verbose) + std::cout << "[USRP_SERVER] Received delay request of " + << ticks << " ticks\n"; + } + + //--------- I2C WRITE -----------// + // FIXME: could check that byte count does not exceed 2^8 which + // is the max length in the subpacket for # of bytes to read. + if(pmt_eq(subp_cmd, s_op_i2c_write)) { + + long i2c_addr = pmt_to_long(pmt_nth(0, subp_data)); + pmt_t data = pmt_nth(1, subp_data); + + // Get a readable address to the data which also gives us the length + size_t data_len; + uint8_t *i2c_data = (uint8_t *) pmt_u8vector_writeable_elements(data, data_len); + + // Make the USB packet + if(!pkt->cs_i2c_write(i2c_addr, i2c_data, data_len)) + { + d_cs_usrp->send(s_cmd_usrp_write, + pmt_list3(invocation_handle, + pmt_from_long(channel), + v_packet)); + + goto new_packet; + } + + if(verbose) + std::cout << "[USRP_SERVER] Received I2C write\n"; + } + + //----------- I2C Read -------------// + if(pmt_eq(subp_cmd, s_op_i2c_read)) { + + long urid = pmt_to_long(pmt_nth(0, subp_data)); + long i2c_addr = pmt_to_long(pmt_nth(1, subp_data)); + long i2c_bytes = pmt_to_long(pmt_nth(2, subp_data)); + + long srid; + if((srid = next_rid()) == -1) + goto subpkt_bail; + + d_rids[srid].owner = port->port_symbol(); + d_rids[srid].user_rid = urid; + + if(!pkt->cs_i2c_read(srid, i2c_addr, i2c_bytes)) + { + + d_cs_usrp->send(s_cmd_usrp_write, + pmt_list3(invocation_handle, + pmt_from_long(channel), + v_packet)); + + d_rids[srid].owner = PMT_NIL; + + goto new_packet; + } + + if(verbose) + std::cout << "[USRP_SERVER] Received I2C read\n"; + } + + //--------- SPI WRITE -----------// + if(pmt_eq(subp_cmd, s_op_spi_write)) { + + long enables = pmt_to_long(pmt_nth(0, subp_data)); + long format = pmt_to_long(pmt_nth(1, subp_data)); + long opt = pmt_to_long(pmt_nth(2, subp_data)); + pmt_t data = pmt_nth(3, subp_data); + + // Get a readable address to the data which also gives us the length + size_t data_len; + uint8_t *spi_data = (uint8_t *) pmt_u8vector_writeable_elements(data, data_len); + + // Make the USB packet + if(!pkt->cs_spi_write(enables, format, opt, spi_data, data_len)) + { + d_cs_usrp->send(s_cmd_usrp_write, + pmt_list3(invocation_handle, + pmt_from_long(channel), + v_packet)); + + goto new_packet; + } + + if(verbose) + std::cout << "[USRP_SERVER] Received SPI write\n"; + } + + //--------- SPI READ -----------// + if(pmt_eq(subp_cmd, s_op_spi_read)) { + + long urid = pmt_to_long(pmt_nth(0, subp_data)); + long enables = pmt_to_long(pmt_nth(1, subp_data)); + long format = pmt_to_long(pmt_nth(2, subp_data)); + long opt = pmt_to_long(pmt_nth(3, subp_data)); + long n_bytes = pmt_to_long(pmt_nth(4, subp_data)); + + long srid; + if((srid = next_rid()) == -1) + goto subpkt_bail; + + d_rids[srid].owner = port->port_symbol(); + d_rids[srid].user_rid = urid; + + // Make the USB packet + if(!pkt->cs_spi_read(srid, enables, format, opt, n_bytes)) + { + d_cs_usrp->send(s_cmd_usrp_write, + pmt_list3(invocation_handle, + pmt_from_long(channel), + v_packet)); + + // Return the rid + d_rids[srid].owner = PMT_NIL; + + goto new_packet; + } + + if(verbose) + std::cout << "[USRP_SERVER] Received SPI read\n"; + } + + subpkt_bail: + curr_subpkt++; + + } + + + // If the current packets length is > 0, we know there are subpackets that + // need to be sent out still. + if(pkt->payload_len() > 0) + d_cs_usrp->send(s_cmd_usrp_write, + pmt_list3(invocation_handle, + pmt_from_long(channel), + v_packet)); + + return; +} + +void +usrp_server::handle_cmd_start_recv_raw_samples(mb_port_sptr port, std::vector<struct channel_info> &chan_info, pmt_t data) +{ + pmt_t invocation_handle = pmt_nth(0, data); + long channel = pmt_to_long(pmt_nth(1, data)); + + // Ensure the channel is valid and the caller owns the port + if(!check_valid(port, channel, chan_info, + pmt_list2(s_response_xmit_raw_frame, invocation_handle))) + return; + + // Already started receiving samples? (another start before a stop) + // Check the RX channel bitmask. + if(d_rx_chan_mask & (1 << channel)) { + port->send(s_response_recv_raw_samples, + pmt_list5(invocation_handle, + s_err_already_receiving, + PMT_NIL, + PMT_NIL, + PMT_NIL)); + return; + } + + // We only need to generate a 'start reading' command down to the + // low level interface if no other channel is already reading + // + // We carry this over the CS interface because the lower level + // interface does not care about the channel, we only demux it + // at the usrp_server on responses. + if(d_rx_chan_mask == 0) { + + if(verbose) + std::cout << "[USRP_SERVER] Sending read request down to start recv\n"; + + d_cs_usrp->send(s_cmd_usrp_start_reading, pmt_list1(invocation_handle)); + } + + d_rx_chan_mask |= 1<<channel; + + return; +} + +void +usrp_server::handle_cmd_stop_recv_raw_samples( + mb_port_sptr port, + std::vector<struct channel_info> &chan_info, + pmt_t data) +{ + pmt_t invocation_handle = pmt_nth(0, data); + long channel = pmt_to_long(pmt_nth(1, data)); + + // FIX ME : we have no responses to send an error... + // Ensure the channel is valid and the caller owns the port + //if(!check_valid(port, channel, chan_info, + // pmt_list2(s_response_xmit_raw_frame, invocation_handle))) + // return; + + // Remove this hosts bit from the receiver mask + d_rx_chan_mask &= ~(1<<channel); + + // We only need to generate a 'start reading' command down to the + // low level interface if no other channel is already reading + // + // We carry this over the CS interface because the lower level + // interface does not care about the channel, we only demux it + // at the usrp_server on responses. + if(d_rx_chan_mask == 0) { + + if(verbose) + std::cout << "[USRP_SERVER] Sending stop reading request down\n"; + + d_cs_usrp->send(s_cmd_usrp_stop_reading, pmt_list1(invocation_handle)); + } + + return; +} + +// Read the packet header, determine the port by the channel owner +void +usrp_server::handle_response_usrp_read(pmt_t data) +{ + + pmt_t invocation_handle = pmt_nth(0, data); + pmt_t status = pmt_nth(1, data); + pmt_t v_pkt = pmt_nth(2, data); + + size_t n_bytes; + size_t ignore; + + if (d_fake_rx) { + + pmt_t pkt = pmt_nth(2, data); + + d_rx[0]->send(s_response_recv_raw_samples, + pmt_list5(PMT_F, + PMT_T, + pkt, + pmt_from_long(0xffff), + PMT_NIL)); + + return; + } + + // Extract the packet and return appropriately + transport_pkt *pkt = (transport_pkt *) pmt_u8vector_writeable_elements(v_pkt, n_bytes); + + // The channel is used to find the port to pass the samples on + long channel = pkt->chan(); + long payload_len = pkt->payload_len(); + long port; + + // Ignore packets which seem to have incorrect size or size 0 + if(payload_len > pkt->max_payload() || payload_len == 0) + return; + + // If the packet is a C/S packet, parse it separately + if(channel == 0x1f) { + parse_control_pkt(invocation_handle, pkt); + return; + } + + if((port = rx_port_index(d_chaninfo_rx[channel].owner)) == -1) + return; // Don't know where to send the sample... possibility on abrupt close + + pmt_t v_samples = pmt_make_u8vector(payload_len, 0); + uint8_t *samples = pmt_u8vector_writeable_elements(v_samples, ignore); + + memcpy(samples, pkt->payload(), payload_len); + + // Build a properties dictionary to store things such as the RSSI + pmt_t properties = pmt_make_dict(); + + pmt_dict_set(properties, + pmt_intern("rssi"), + pmt_from_long(pkt->rssi())); + + if(pkt->overrun()) + pmt_dict_set(properties, + pmt_intern("overrun"), + PMT_T); + + if(pkt->underrun()) + pmt_dict_set(properties, + pmt_intern("underrun"), + PMT_T); + + d_rx[port]->send(s_response_recv_raw_samples, + pmt_list5(invocation_handle, + status, + v_samples, + pmt_from_long(pkt->timestamp()), + properties)); + return; +} + +void +usrp_server::parse_control_pkt(pmt_t invocation_handle, transport_pkt *pkt) +{ + + long payload_len = pkt->payload_len(); + long curr_payload = 0; + long port; + + // We dispatch based on the control packet type, however we can extract the + // opcode and the length immediately which is consistent in all responses. + // + // Since each control packet can have multiple responses, we keep reading the + // lengths of each subpacket until we reach the payload length. + while(curr_payload < payload_len) { + + pmt_t sub_packet = pkt->read_subpacket(curr_payload); + pmt_t op_symbol = pmt_nth(0, sub_packet); + + int len = pkt->cs_len(curr_payload); + + if(verbose) + std::cout << "[USRP_SERVER] Parsing subpacket " + << op_symbol << " ... length " << len << std::endl; + + //----------------- PING RESPONSE ------------------// + if(pmt_eq(op_symbol, s_op_ping_fixed_reply)) { + + long srid = pmt_to_long(pmt_nth(1, sub_packet)); + pmt_t pingval = pmt_nth(2, sub_packet); + + long urid = d_rids[srid].user_rid; + + if(verbose) + std::cout << "[USRP_SERVER] Found ping response " + << "(" + << "URID: " << urid << ", " + << "SRID: " << srid << ", " + << "VAL: " << pingval + << ")\n"; + + // Do some bounds checking incase of bogus/corrupt responses + if(srid > D_MAX_RID) + return; + + pmt_t owner = d_rids[srid].owner; + + // FIXME: should be 1 response for all subpackets here ? + if((port = tx_port_index(owner)) != -1) + d_tx[port]->send(s_response_from_control_channel, + pmt_list4(invocation_handle, + PMT_T, + pmt_list2(s_op_ping_fixed_reply, // subp + pmt_list2(pmt_from_long(urid), + pingval)), + pmt_from_long(pkt->timestamp()))); + } + + //----------------- READ REG RESPONSE ------------------// + else if(pmt_eq(op_symbol, s_op_read_reg_reply)) { + + long srid = pmt_to_long(pmt_nth(1, sub_packet)); + pmt_t reg_num = pmt_nth(2, sub_packet); + pmt_t reg_val = pmt_nth(3, sub_packet); + + long urid = d_rids[srid].user_rid; + + if(verbose) + std::cout << "[USRP_SERVER] Found read register response " + << "(" + << "URID: " << urid << ", " + << "SRID: " << srid << ", " + << "REG: " << reg_num << ", " + << "VAL: " << reg_val + << ")\n"; + + // Do some bounds checking to avoid seg faults + if(srid > D_MAX_RID) + return; + + pmt_t owner = d_rids[srid].owner; + + // FIXME: should be 1 response for all subpackets here ? + if((port = tx_port_index(owner)) != -1) + d_tx[port]->send(s_response_from_control_channel, + pmt_list4(invocation_handle, + PMT_T, + pmt_list2(s_op_read_reg_reply, // subp + pmt_list3(pmt_from_long(urid), + reg_num, + reg_val)), + pmt_from_long(pkt->timestamp()))); + } + + //------------------ I2C READ REPLY -------------------// + else if(pmt_eq(op_symbol, s_op_i2c_read_reply)) { + + long srid = pmt_to_long(pmt_nth(1, sub_packet)); + pmt_t i2c_addr = pmt_nth(2, sub_packet); + pmt_t i2c_data = pmt_nth(3, sub_packet); + + long urid = d_rids[srid].user_rid; + + if(verbose) + std::cout << "[USRP_SERVER] Found i2c read reply " + << "(" + << "URID: " << urid << ", " + << "SRID: " << srid << ", " + << "Addr: " << i2c_addr << ", " + << "Data: " << i2c_data + << ")\n"; + + // Do some bounds checking to avoid seg faults + if(srid > D_MAX_RID) + return; + + pmt_t owner = d_rids[srid].owner; + + if((port = tx_port_index(owner)) != -1) + d_tx[port]->send(s_response_from_control_channel, + pmt_list4(invocation_handle, + PMT_T, + pmt_list2(s_op_i2c_read_reply, + pmt_list3(pmt_from_long(urid), + i2c_addr, + i2c_data)), + pmt_from_long(pkt->timestamp()))); + } + + //------------------ SPI READ REPLY -------------------// + else if(pmt_eq(op_symbol, s_op_spi_read_reply)) { + + long srid = pmt_to_long(pmt_nth(1, sub_packet)); + pmt_t spi_data = pmt_nth(2, sub_packet); + + long urid = d_rids[srid].user_rid; + + if(verbose) + std::cout << "[USRP_SERVER] Found SPI read reply " + << "(" + << "URID: " << urid << ", " + << "SRID: " << srid << ", " + << "Data: " << spi_data + << ")\n"; + + // Bounds check the RID + if(srid > D_MAX_RID) + return; + + pmt_t owner = d_rids[srid].owner; + + if((port = tx_port_index(owner)) != -1) + d_tx[port]->send(s_response_from_control_channel, + pmt_list4(invocation_handle, + PMT_T, + pmt_list2(s_op_spi_read_reply, + pmt_list2(pmt_from_long(urid), + spi_data)), + pmt_from_long(pkt->timestamp()))); + } + + // Each subpacket has an unaccounted for 2 bytes which is the opcode + // and the length field + curr_payload += len + 2; + + // All subpackets are 32-bit aligned + int align_offset = 4 - (curr_payload % 4); + + if(align_offset != 4) + curr_payload += align_offset; + } +} + +void +usrp_server::recall_defer_queue() +{ + + std::vector<mb_message_sptr> recall; + + while(!d_defer_queue.empty()) { + recall.push_back(d_defer_queue.front()); + d_defer_queue.pop(); } - pkts[n_packets-1].set_end_of_burst(); // set the last packet's end of burst + // Parse the messages that were queued while waiting for an open response + for(int i=0; i < (int)recall.size(); i++) + handle_message(recall[i]); + + return; +} + +bool +usrp_server::check_valid(mb_port_sptr port, + long channel, + std::vector<struct channel_info> &chan_info, + pmt_t signal_info) +{ - // interface with the USRP to send the USB packet, since the memory is - // contiguous, this should be a serious of memory copies to the bus, each being - // USB_PKT_SIZE * MAX_PACKET_BURST bytes worth of data (given a full burst) + pmt_t response_signal = pmt_nth(0, signal_info); + pmt_t invocation_handle = pmt_nth(1, signal_info); + + // not a valid channel number? + if(channel >= (long)chan_info.size() && channel != 0x1f) { + port->send(response_signal, + pmt_list2(invocation_handle, + s_err_channel_invalid)); + + if(verbose) + std::cout << "[USRP_SERVER] Invalid channel number for event " + << response_signal << std::endl; + return false; + } + + // not the owner of the port? + if(chan_info[channel].owner != port->port_symbol()) { + port->send(response_signal, + pmt_list2(invocation_handle, + s_err_channel_permission_denied)); + + if(verbose) + std::cout << "[USRP_SERVER] Invalid permissions" + << " for " << response_signal + << " from " << port->port_symbol() + << " proper owner is " << chan_info[channel].owner + << " on channel " << channel + << " invocation " << invocation_handle + << std::endl; + return false; + } + + return true; +} + +// Goes through the vector of RIDs and retreieves an +// available one for use +long +usrp_server::next_rid() +{ + for(int i = 0; i < D_MAX_RID; i++) + if(pmt_eqv(d_rids[i].owner, PMT_NIL)) + return i; + + return -1; } REGISTER_MBLOCK_CLASS(usrp_server); diff --git a/usrp/host/lib/inband/usrp_server.h b/usrp/host/lib/inband/usrp_server.h index d2819cd66..81dceb1f4 100644 --- a/usrp/host/lib/inband/usrp_server.h +++ b/usrp/host/lib/inband/usrp_server.h @@ -23,21 +23,19 @@ #include <mb_mblock.h> #include <vector> +#include <queue> +#include <fstream> +#include <usrp_inband_usb_packet.h> + +typedef usrp_inband_usb_packet transport_pkt; // makes conversion to gigabit easy /*! - * \brief Implements the lowest-level mblock interface to the USRP + * \brief Implements the lowest-level mblock usb_interface to the USRP */ class usrp_server : public mb_mblock { public: - enum error_codes { - RQSTD_CAPACITY_UNAVAIL = 0, - CHANNEL_UNAVAIL = 1, - CHANNEL_INVALID = 2, - PERMISSION_DENIED = 3 - }; - // our ports enum port_types { RX_PORT = 0, @@ -46,19 +44,49 @@ public: static const int N_PORTS = 4; std::vector<mb_port_sptr> d_tx, d_rx; mb_port_sptr d_cs; + mb_port_sptr d_cs_usrp; static const int D_USB_CAPACITY = 32 * 1024 * 1024; static const int D_MAX_CHANNELS = 16; long d_ntx_chan; long d_nrx_chan; + // Keep track of the request IDs + struct rid_info { + pmt_t owner; + long user_rid; + + rid_info() { + owner = PMT_NIL; + user_rid = 0; + } + }; + + static const long D_MAX_RID = 64; + std::vector<rid_info> d_rids; + struct channel_info { - long assigned_capacity; // the capacity currently assignedby the channel + long assigned_capacity; // the capacity currently assignedby the channel pmt_t owner; // port ID of the owner of the channel + + channel_info() { + assigned_capacity = 0; + owner = PMT_NIL; + } }; - struct channel_info d_chaninfo_tx[D_MAX_CHANNELS]; - struct channel_info d_chaninfo_rx[D_MAX_CHANNELS]; + long d_rx_chan_mask; // A bitmask representing the channels in the + // receiving state + + std::vector<struct channel_info> d_chaninfo_tx; + std::vector<struct channel_info> d_chaninfo_rx; + + std::queue<mb_message_sptr> d_defer_queue; + + bool d_defer; + bool d_opened; + + bool d_fake_rx; public: usrp_server(mb_runtime *rt, const std::string &instance_name, pmt_t user_arg); @@ -71,12 +99,21 @@ protected: static int max_capacity() { return D_USB_CAPACITY; } private: - void handle_cmd_allocate_channel(pmt_t port_id, pmt_t data); - void handle_cmd_deallocate_channel(pmt_t port_id, pmt_t data); - void handle_cmd_xmit_raw_frame(pmt_t data); + void handle_cmd_allocate_channel(mb_port_sptr port, std::vector<struct channel_info> &chan_info, pmt_t data); + void handle_cmd_deallocate_channel(mb_port_sptr port, std::vector<struct channel_info> &chan_info, pmt_t data); + void handle_cmd_xmit_raw_frame(mb_port_sptr port, std::vector<struct channel_info> &chan_info, pmt_t data); + void handle_cmd_to_control_channel(mb_port_sptr port, std::vector<struct channel_info> &chan_info, pmt_t data); + void handle_cmd_start_recv_raw_samples(mb_port_sptr port, std::vector<struct channel_info> &chan_info, pmt_t data); + void handle_cmd_stop_recv_raw_samples(mb_port_sptr port, std::vector<struct channel_info> &chan_info, pmt_t data); int rx_port_index(pmt_t port_id); int tx_port_index(pmt_t port_id); long current_capacity_allocation(); + void recall_defer_queue(); + void reset_channels(); + void handle_response_usrp_read(pmt_t data); + bool check_valid(mb_port_sptr port, long channel, std::vector<struct channel_info> &chan_info, pmt_t signal_info); + void parse_control_pkt(pmt_t invocation_handle, transport_pkt *pkt); + long next_rid(); }; #endif /* INCLUDED_USRP_SERVER_H */ diff --git a/usrp/host/lib/inband/usrp_server.mbh b/usrp/host/lib/inband/usrp_server.mbh index e96c3f1ac..06ec4b996 100644 --- a/usrp/host/lib/inband/usrp_server.mbh +++ b/usrp/host/lib/inband/usrp_server.mbh @@ -40,9 +40,8 @@ ;; mechanism to match asynchronous responses with the commands that ;; generated them. ;; -;; status is either #t, indicating success, or a pair containing -;; (status-code . message), where status-code is a symbol and message -;; is a string. +;; status is either #t, indicating success, or a symbol indicating an error. +;; All symbol's names shall begin with %error- ;; ---------------------------------------------------------------- @@ -128,7 +127,7 @@ (:incoming - (response-from-control-channel invocation-handle status list-of-subpackets) + (response-from-control-channel invocation-handle status list-of-subpackets timestamp) ) ) @@ -248,9 +247,9 @@ (:incoming (response-open invocation-handle status) (response-close invocation-handle status) - (response-max-capacity invocation-handle capacity) - (response-ntx-chan invocation-handle ntx-chan) - (response-nrx-chan invocation-handle nrx-chan) - (response-current-capacity-allocation invocation-handle capacity) + (response-max-capacity invocation-handle status capacity) + (response-ntx-chan invocation-handle status ntx-chan) + (response-nrx-chan invocation-handle status nrx-chan) + (response-current-capacity-allocation invocation-handle status capacity) ) ) diff --git a/usrp/host/lib/inband/usrp_tx.cc b/usrp/host/lib/inband/usrp_tx.cc new file mode 100644 index 000000000..a7a5e4a89 --- /dev/null +++ b/usrp/host/lib/inband/usrp_tx.cc @@ -0,0 +1,138 @@ +/* -*- c++ -*- */ +/* + * Copyright 2007 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * GNU Radio is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3, or (at your option) + * any later version. + * + * GNU Radio is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#include <usrp_tx.h> +#include <iostream> +#include <usb.h> +#include <mb_class_registry.h> +#include <usrp_inband_usb_packet.h> +#include <fpga_regs_common.h> +#include <usrp_standard.h> +#include <stdio.h> + +#include <symbols_usrp_tx_cs.h> + +typedef usrp_inband_usb_packet transport_pkt; + +static const bool verbose = false; + +usrp_tx::usrp_tx(mb_runtime *rt, const std::string &instance_name, pmt_t user_arg) + : mb_mblock(rt, instance_name, user_arg), + d_disk_write(false) +{ + d_cs = define_port("cs", "usrp-tx-cs", true, mb_port::EXTERNAL); + + //d_disk_write=true; + + if(d_disk_write) { + d_ofile.open("tx_data.dat",std::ios::binary|std::ios::out); + d_cs_ofile.open("tx_cs.dat",std::ios::binary|std::ios::out); + } +} + +usrp_tx::~usrp_tx() +{ + if(d_disk_write) { + d_ofile.close(); + d_cs_ofile.close(); + } +} + +void +usrp_tx::initial_transition() +{ + +} + +void +usrp_tx::handle_message(mb_message_sptr msg) +{ + pmt_t event = msg->signal(); + pmt_t port_id = msg->port_id(); + pmt_t data = msg->data(); + + // Theoretically only have 1 message to ever expect, but + // want to make sure its at least what we want + if(pmt_eq(port_id, d_cs->port_symbol())) { + + if(pmt_eqv(event, s_cmd_usrp_tx_write)) + write(data); + } +} + +void +usrp_tx::write(pmt_t data) +{ + pmt_t invocation_handle = pmt_nth(0, data); + pmt_t channel = pmt_nth(1, data); + pmt_t v_packets = pmt_nth(2, data); + d_utx = boost::any_cast<usrp_standard_tx *>(pmt_any_ref(pmt_nth(3, data))); + + size_t n_bytes; + bool underrun; // this will need to go, as it is taken care of in the packet headers + + transport_pkt *pkts = (transport_pkt *) pmt_u8vector_writeable_elements(v_packets, n_bytes); + + int ret = d_utx->write (pkts, n_bytes, &underrun); + + if (0 && underrun) + fprintf(stderr, "uU"); + + if (ret == (int) n_bytes) { + if (verbose) + std::cout << "[usrp_server] Write of " << n_bytes << " successful\n"; + // need to respond with the channel so the USRP server knows who to forward the result of + // the write to by looking up the owner of the channel + d_cs->send(s_response_usrp_tx_write, + pmt_list3(invocation_handle, PMT_T, channel)); + } + else { + if (verbose) + std::cout << "[usrp_server] Error writing " << n_bytes << " bytes to USB bus\n"; + d_cs->send(s_response_usrp_tx_write, + pmt_list3(invocation_handle, PMT_F, channel)); + } + + long n_packets = + static_cast<long>(std::ceil(n_bytes / (double)transport_pkt::max_pkt_size())); + + for(int i=0; i < n_packets; i++) { + + if(d_disk_write) { + if(pkts[i].chan() == 0x1f) + d_cs_ofile.write((const char *)&pkts[i], transport_pkt::max_pkt_size()); + else + d_ofile.write((const char *)&pkts[i], transport_pkt::max_pkt_size()); + + d_cs_ofile.flush(); + d_ofile.flush(); + } + } + + + return; +} + +REGISTER_MBLOCK_CLASS(usrp_tx); diff --git a/usrp/host/lib/inband/usrp_tx.h b/usrp/host/lib/inband/usrp_tx.h new file mode 100644 index 000000000..546a26afc --- /dev/null +++ b/usrp/host/lib/inband/usrp_tx.h @@ -0,0 +1,53 @@ +/* -*- c++ -*- */ +/* + * Copyright 2007 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * GNU Radio is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3, or (at your option) + * any later version. + * + * GNU Radio is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ +#ifndef INCLUDED_USRP_TX_H +#define INCLUDED_USRP_TX_H + +#include <mb_mblock.h> +#include <fstream> + +class usrp_standard_tx; + +/*! + * \brief Implements the low level usb interface to the USRP + */ +class usrp_tx : public mb_mblock +{ + mb_port_sptr d_cs; + usrp_standard_tx *d_utx; + + bool d_disk_write; + std::ofstream d_ofile; + std::ofstream d_cs_ofile; + + public: + usrp_tx(mb_runtime *rt, const std::string &instance_name, pmt_t user_arg); + ~usrp_tx(); + void initial_transition(); + void handle_message(mb_message_sptr msg); + + private: + void write(pmt_t data); +}; + + +#endif /* INCLUDED_USRP_TX_H */ + diff --git a/usrp/host/lib/inband/usrp_tx_stub.cc b/usrp/host/lib/inband/usrp_tx_stub.cc new file mode 100644 index 000000000..7a9876322 --- /dev/null +++ b/usrp/host/lib/inband/usrp_tx_stub.cc @@ -0,0 +1,344 @@ +/* -*- c++ -*- */ +/* + * Copyright 2007 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * GNU Radio is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3, or (at your option) + * any later version. + * + * GNU Radio is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#include <iostream> +#include <vector> +#include <usb.h> +#include <mb_class_registry.h> +#include <usrp_tx_stub.h> +#include <usrp_inband_usb_packet.h> +#include <fpga_regs_common.h> +#include "usrp_standard.h" +#include <stdio.h> +#include <fstream> +#include <usrp_rx_stub.h> + +#include <symbols_usrp_tx_cs.h> + +typedef usrp_inband_usb_packet transport_pkt; + +static const bool verbose = false; + +usrp_tx_stub::usrp_tx_stub(mb_runtime *rt, const std::string &instance_name, pmt_t user_arg) + : mb_mblock(rt, instance_name, user_arg), + d_disk_write(false) +{ + d_cs = define_port("cs", "usrp-tx-cs", true, mb_port::EXTERNAL); + + //d_disk_write=true; + + if(d_disk_write) { + d_ofile.open("tx_stub_data.dat",std::ios::binary|std::ios::out); + d_cs_ofile.open("tx_stub_cs.dat",std::ios::binary|std::ios::out); + } +} + +usrp_tx_stub::~usrp_tx_stub() +{ + if(d_disk_write) { + d_ofile.close(); + d_cs_ofile.close(); + } +} + +void +usrp_tx_stub::initial_transition() +{ + +} + +void +usrp_tx_stub::handle_message(mb_message_sptr msg) +{ + pmt_t event = msg->signal(); + pmt_t port_id = msg->port_id(); + pmt_t data = msg->data(); + + // Theoretically only have 1 message to ever expect, but + // want to make sure its at least what we want + if(pmt_eq(port_id, d_cs->port_symbol())) { + + if(pmt_eqv(event, s_cmd_usrp_tx_write)) + write(data); + } +} + +void +usrp_tx_stub::write(pmt_t data) +{ + pmt_t invocation_handle = pmt_nth(0, data); + pmt_t channel = pmt_nth(1, data); + pmt_t v_packets = pmt_nth(2, data); + d_utx = boost::any_cast<usrp_standard_tx *>(pmt_any_ref(pmt_nth(3, data))); + + size_t n_bytes; + + transport_pkt *pkts = (transport_pkt *) pmt_u8vector_writeable_elements(v_packets, n_bytes); + long n_packets = static_cast<long>(std::ceil(n_bytes / (double)transport_pkt::max_pkt_size())); + + // Parse the packets looking for C/S packets and dump them to a disk if + // necessary + for(long i=0; i<n_packets; i++) { + + if(d_disk_write) { + if(pkts[i].chan() == 0x1f) + d_cs_ofile.write((const char *)&pkts[i], transport_pkt::max_pkt_size()); + else + d_ofile.write((const char *)&pkts[i], transport_pkt::max_pkt_size()); + + d_cs_ofile.flush(); + d_ofile.flush(); + } + + if(pkts[i].chan() == 0x1f) + parse_cs(invocation_handle, pkts[i]); + } + + d_cs->send(s_response_usrp_tx_write, + pmt_list3(invocation_handle, PMT_T, channel)); + + return; +} + +void +usrp_tx_stub::parse_cs(pmt_t invocation_handle, transport_pkt pkt) +{ + + long payload_len = pkt.payload_len(); + long curr_payload = 0; + + size_t ignore; + + // There is the possibility that the responses for a single USB packet full of + // CS packets will not fit back in a single USB packet, considering some + // responses are greater than their commands (read registers). + new_packet: + pmt_t v_pkt = pmt_make_u8vector(sizeof(transport_pkt), 0); + + transport_pkt *q_pkt = + (transport_pkt *) pmt_u8vector_writeable_elements(v_pkt, ignore); + + q_pkt->set_header(0, 0x1f, 0, 0); + q_pkt->set_timestamp(0xffffffff); + + // We dispatch based on the control packet type, however we can extract the + // opcode and the length immediately which is consistent in all responses. + // + // Since each control packet can have multiple responses, we keep reading the + // lengths of each subpacket until we reach the payload length. + while(curr_payload < payload_len) { + + pmt_t sub_packet = pkt.read_subpacket(curr_payload); + pmt_t op_symbol = pmt_nth(0, sub_packet); + + int len = pkt.cs_len(curr_payload); + + if(verbose) + std::cout << "[USRP_TX_STUB] Parsing subpacket " + << op_symbol << " ... length " << len << std::endl; + + //----------------- PING FIXED ------------------// + if(pmt_eq(op_symbol, s_op_ping_fixed)) { + + long rid = pmt_to_long(pmt_nth(1, sub_packet)); + long pingval = pmt_to_long(pmt_nth(2, sub_packet)); + + // Generate a reply and put it in the queue for the RX stub to read + if(!q_pkt->cs_ping_reply(rid, pingval)) + goto new_packet; + + if(verbose) + std::cout << "[USRP_TX_STUB] Generated ping response " + << "(" + << "RID: " << rid << ", " + << "VAL: " << pingval + << ")\n"; + } + + //----------------- READ REG ------------------// + if(pmt_eq(op_symbol, s_op_read_reg)) { + + long rid = pmt_to_long(pmt_nth(1, sub_packet)); + long reg_num = pmt_to_long(pmt_nth(2, sub_packet)); + long reg_val = 0xdeef; + + // Generate a reply and put it in the queue for the RX stub to read + if(!q_pkt->cs_read_reg_reply(rid, reg_num, reg_val)) + goto new_packet; + + if(verbose) + std::cout << "[USRP_TX_STUB] Generated read register response " + << "(" + << "RID: " << rid << ", " + << "REG: " << reg_num << ", " + << "VAL: " << reg_val + << ")\n"; + } + + //----------------- DELAY ------------------// + if(pmt_eq(op_symbol, s_op_delay)) { + + long ticks = pmt_to_long(pmt_nth(1, sub_packet)); + + if(verbose) + std::cout << "[USRP_TX_STUB] Received delay command " + << "(" + << "Ticks: " << ticks + << ")\n"; + } + + //----------------- WRITE REG ------------------// + if(pmt_eq(op_symbol, s_op_write_reg)) { + + pmt_t reg_num = pmt_nth(1, sub_packet); + pmt_t reg_val = pmt_nth(2, sub_packet); + + if(verbose) + std::cout << "[USRP_TX_STUB] Received write register command " + << "(" + << "RegNum: " << reg_num << ", " + << "Val: " << reg_val + << ")\n"; + } + + //----------------- WRITE REG MASK ---------------// + if(pmt_eq(op_symbol, s_op_write_reg_masked)) { + + pmt_t reg_num = pmt_nth(1, sub_packet); + pmt_t reg_val = pmt_nth(2, sub_packet); + pmt_t mask = pmt_nth(3, sub_packet); + + if(verbose) + std::cout << "[USRP_TX_STUB] Received write register command " + << "(" + << "RegNum: " << reg_num << ", " + << "Val: " << reg_val << ", " + << "Mask: " << mask + << ")\n"; + } + + //---------------- I2C WRITE ------------------// + if(pmt_eq(op_symbol, s_op_i2c_write)) { + pmt_t i2c_addr = pmt_nth(1, sub_packet); + pmt_t i2c_data = pmt_nth(2, sub_packet); + + if(verbose) + std::cout << "[USRP_TX_STUB] Received i2c write command " + << "(" + << "Addr: " << i2c_addr << ", " + << "Data: " << i2c_data + << ")\n"; + } + + //---------------- I2C READ ------------------// + if(pmt_eq(op_symbol, s_op_i2c_read)) { + long rid = pmt_to_long(pmt_nth(1, sub_packet)); + long i2c_addr = pmt_to_long(pmt_nth(2, sub_packet)); + long i2c_bytes = pmt_to_long(pmt_nth(3, sub_packet)); + + // Create data to place as a response, filled with 0xff + size_t ignore; + pmt_t i2c_data = pmt_make_u8vector(i2c_bytes, 0xff); + uint8_t *w_data = (uint8_t *) pmt_u8vector_writeable_elements(i2c_data, ignore); + + // Generate a reply and put it in the queue for the RX stub to read + if(!q_pkt->cs_i2c_read_reply(rid, i2c_addr, w_data, i2c_bytes)) + goto new_packet; + + if(verbose) + std::cout << "[USRP_TX_STUB] Received i2c read " + << "(" + << "RID: " << rid << ", " + << "Addr: " << i2c_addr << ", " + << "Bytes: " << i2c_bytes + << ")\n"; + } + + //---------------- SPI WRITE ------------------// + if(pmt_eq(op_symbol, s_op_spi_write)) { + long enables = pmt_to_long(pmt_nth(1, sub_packet)); + long format = pmt_to_long(pmt_nth(2, sub_packet)); + long opt = pmt_to_long(pmt_nth(3, sub_packet)); + pmt_t data = pmt_nth(4, sub_packet); + + if(verbose) + std::cout << "[USRP_TX_STUB] Received spi write command " + << "(" + << "Enables: " << enables << ", " + << "Format: " << format << ", " + << "Options: " << opt << ", " + << "Data: " << data + << ")\n"; + } + + //---------------- SPI READ ------------------// + if(pmt_eq(op_symbol, s_op_spi_read)) { + long rid = pmt_to_long(pmt_nth(1, sub_packet)); + long enables = pmt_to_long(pmt_nth(2, sub_packet)); + long format = pmt_to_long(pmt_nth(3, sub_packet)); + long opt = pmt_to_long(pmt_nth(4, sub_packet)); + long n_bytes = pmt_to_long(pmt_nth(5, sub_packet)); + + // Create data to place as a fake response + size_t ignore; + pmt_t spi_data = pmt_make_u8vector(n_bytes, 0xff); + uint8_t *w_data = (uint8_t *) pmt_u8vector_writeable_elements(spi_data, ignore); + + // Generate a reply and put it in the queue for the RX stub to read + if(!q_pkt->cs_spi_read_reply(rid, w_data, n_bytes)) + goto new_packet; + + if(verbose) + std::cout << "[USRP_TX_STUB] Received spi read command " + << "(" + << "RID: " << rid << ", " + << "Enables: " << enables << ", " + << "Format: " << format << ", " + << "Options: " << opt << ", " + << "Bytes: " << n_bytes + << ")\n"; + + } + + // Each subpacket has an unaccounted for 2 bytes which is the opcode + // and the length field + curr_payload += len + 2; + + // All subpackets are 32-bit aligned + int align_offset = 4 - (curr_payload % 4); + + if(align_offset != 4) + curr_payload += align_offset; + + } + + // If the packet has data in the payload, it needs queued + if(q_pkt->payload_len() > 0) + d_cs_queue.push(pmt_list2(invocation_handle, v_pkt)); + + return; +} + +REGISTER_MBLOCK_CLASS(usrp_tx_stub); diff --git a/usrp/host/lib/inband/usrp_tx_stub.h b/usrp/host/lib/inband/usrp_tx_stub.h new file mode 100644 index 000000000..52294beec --- /dev/null +++ b/usrp/host/lib/inband/usrp_tx_stub.h @@ -0,0 +1,61 @@ +/* -*- c++ -*- */ +/* + * Copyright 2007 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * GNU Radio is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3, or (at your option) + * any later version. + * + * GNU Radio is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ +#ifndef INCLUDED_USRP_TX_STUB_H +#define INCLUDED_USRP_TX_STUB_H + +#include <mb_mblock.h> +#include <vector> +#include "usrp_standard.h" +#include <fstream> +#include <usrp_inband_usb_packet.h> + +typedef usrp_inband_usb_packet transport_pkt; + +/*! + * \brief Implements the low level usb interface to the USRP + */ +class usrp_tx_stub : public mb_mblock +{ + public: + + mb_port_sptr d_cs; + usrp_standard_tx* d_utx; + + std::ofstream d_ofile; + std::ofstream d_cs_ofile; + + bool d_disk_write; + + public: + usrp_tx_stub(mb_runtime *rt, const std::string &instance_name, pmt_t user_arg); + ~usrp_tx_stub(); + void initial_transition(); + void handle_message(mb_message_sptr msg); + + private: + void write(pmt_t data); + void parse_cs(pmt_t invocation_handle, transport_pkt pkt); + +}; + + +#endif /* INCLUDED_USRP_TX_STUB_H */ + diff --git a/usrp/host/lib/inband/usrp_usb_interface.cc b/usrp/host/lib/inband/usrp_usb_interface.cc new file mode 100644 index 000000000..b2ccba81b --- /dev/null +++ b/usrp/host/lib/inband/usrp_usb_interface.cc @@ -0,0 +1,431 @@ +/* -*- c++ -*- */ +/* + * Copyright 2007 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * GNU Radio is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3, or (at your option) + * any later version. + * + * GNU Radio is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#include <usrp_usb_interface.h> + +#include <iostream> +#include <vector> +#include <usb.h> +#include <mb_class_registry.h> +#include <usrp_inband_usb_packet.h> +#include <fpga_regs_common.h> +#include "usrp_rx.h" +#include <usrp_rx_stub.h> +#include "usrp_tx.h" +#include "usrp_standard.h" +#include <stdio.h> + +typedef usrp_inband_usb_packet transport_pkt; + +#include <symbols_usrp_interface_cs.h> +#include <symbols_usrp_tx_cs.h> +#include <symbols_usrp_rx_cs.h> +static pmt_t s_shutdown = pmt_intern("%shutdown"); + +static const bool verbose = false; + + + +// need to take number of TX and RX channels as parameter +usrp_usb_interface::usrp_usb_interface(mb_runtime *rt, const std::string &instance_name, pmt_t user_arg) + : mb_mblock(rt, instance_name, user_arg), + d_fpga_debug(false), + d_fake_usrp(false), + d_interp_tx(16), + d_interp_rx(16), + d_rf_freq(10e6), + d_rbf("inband_tx_rx.rbf") +{ + // Dictionary for arguments to all of the components + pmt_t usrp_dict = user_arg; + + // Default TX/RX interface + std::string tx_interface = "usrp_tx"; + std::string rx_interface = "usrp_rx"; + + if (pmt_is_dict(usrp_dict)) { + + // The 'fake-usrp' key enables the TX and RX stubs if PMT_T + if(pmt_t fake_usrp = pmt_dict_ref(usrp_dict, + pmt_intern("fake-usrp"), + PMT_NIL)) { + if(pmt_eqv(fake_usrp, PMT_T)) { + tx_interface = "usrp_tx_stub"; + rx_interface = "usrp_rx_stub"; + d_fake_usrp=true; + } + } + + // Read the TX interpolations + if(pmt_t interp_tx = pmt_dict_ref(usrp_dict, + pmt_intern("interp-tx"), + PMT_NIL)) { + if(!pmt_eqv(interp_tx, PMT_NIL)) + d_interp_tx = pmt_to_long(interp_tx); + } + + // Read the RX interpolations + if(pmt_t interp_rx = pmt_dict_ref(usrp_dict, + pmt_intern("interp-rx"), + PMT_NIL)) { + if(!pmt_eqv(interp_rx, PMT_NIL)) + d_interp_rx = pmt_to_long(interp_rx); + } + + // Read the RBF + if(pmt_t rbf = pmt_dict_ref(usrp_dict, + pmt_intern("rbf"), + PMT_NIL)) { + if(!pmt_eqv(rbf, PMT_NIL)) + d_rbf = pmt_symbol_to_string(rbf); + } + + // The RF center frequency + if(pmt_t rf_freq = pmt_dict_ref(usrp_dict, + pmt_intern("rf-freq"), + PMT_NIL)) { + if(!pmt_eqv(rf_freq, PMT_NIL)) + d_rf_freq = pmt_to_long(rf_freq); + } + } + + if (verbose) { + std::cout << "[USRP_USB_INTERFACE] Setting USRP RBF to " + << d_rbf << std::endl; + + std::cout << "[USRP_USB_INTERFACE] Setting TX interpolation to " + << d_interp_tx << std::endl; + + std::cout << "[USRP_USB_INTERFACE] Setting RX interpolation to " + << d_interp_rx << std::endl; + + std::cout << "[USRP_USB_INTERFACE] Using TX interface: " + << tx_interface << "\n"; + + std::cout << "[USRP_USB_INTERFACE] Using RX interface: " + << rx_interface << "\n"; + + } + + d_cs = define_port("cs", "usrp-interface-cs", true, mb_port::EXTERNAL); + d_rx_cs = define_port("rx_cs", "usrp-rx-cs", false, mb_port::INTERNAL); + d_tx_cs = define_port("tx_cs", "usrp-tx-cs", false, mb_port::INTERNAL); + + // Connect to TX and RX + define_component("tx", tx_interface, PMT_F); + define_component("rx", rx_interface, PMT_F); + connect("self", "rx_cs", "rx", "cs"); + connect("self", "tx_cs", "tx", "cs"); + + // FIX ME: the code should query the FPGA to retrieve the number of channels and such + d_ntx_chan = 2; + d_nrx_chan = 2; + + d_utx = NULL; + d_urx = NULL; + + d_fpga_debug=true; // WARNING: DO NOT ENABLE WITH D'BOARDS OTHER THAN BASIC TX/RX + +} + +usrp_usb_interface::~usrp_usb_interface() +{ + +} + +void +usrp_usb_interface::initial_transition() +{ + +} + +void +usrp_usb_interface::handle_message(mb_message_sptr msg) +{ + pmt_t event = msg->signal(); // the "name" of the message + pmt_t port_id = msg->port_id(); // which port it came in on + pmt_t data = msg->data(); + pmt_t invocation_handle; + + if (pmt_eq(event, s_shutdown)) // ignore (for now) + return; + + //------------- CONTROL / STATUS -------------// + if (pmt_eq(port_id, d_cs->port_symbol())) { + + //------------ OPEN --------------// + if (pmt_eq(event, s_cmd_usrp_open)){ + handle_cmd_open(data); + return; + } + //----------- CLOSE -------------// + else if (pmt_eq(event, s_cmd_usrp_close)) { + handle_cmd_close(data); + return; + } + //---------- NTX CHAN ----------// + else if (pmt_eq(event, s_cmd_usrp_ntx_chan)) { + invocation_handle = pmt_nth(0, data); + d_cs->send(s_response_usrp_ntx_chan, + pmt_list2(invocation_handle, + pmt_from_long(d_ntx_chan))); + return; + } + //---------- NRX CHAN ----------// + else if (pmt_eq(event, s_cmd_usrp_nrx_chan)) { + invocation_handle = pmt_nth(0, data); + d_cs->send(s_response_usrp_nrx_chan, + pmt_list2(invocation_handle, + pmt_from_long(d_nrx_chan))); + return; + } + //------------ WRITE -----------// + else if(pmt_eq(event, s_cmd_usrp_write)) { + handle_cmd_write(data); + return; + } + //-------- START READING --------// + else if(pmt_eq(event, s_cmd_usrp_start_reading)) { + handle_cmd_start_reading(data); + return; + } + //-------- STOP READING --------// + else if(pmt_eq(event, s_cmd_usrp_stop_reading)) { + handle_cmd_stop_reading(data); + return; + } + + goto unhandled; + } + + //---------------- RX ------------------// + if (pmt_eq(port_id, d_rx_cs->port_symbol())) { + + // Relay reads back up + if(pmt_eq(event, s_response_usrp_rx_read)) { + d_cs->send(s_response_usrp_read, data); + return; + } + + goto unhandled; + } + + //---------------- TX ------------------// + if (pmt_eq(port_id, d_tx_cs->port_symbol())) { + + if(pmt_eq(event, s_response_usrp_tx_write)) { + + pmt_t invocation_handle = pmt_nth(0, data); + pmt_t status = pmt_nth(1, data); + pmt_t channel = pmt_nth(2, data); + + d_cs->send(s_response_usrp_write, + pmt_list3(invocation_handle, + status, + channel)); + + return; + } + + goto unhandled; + } + + unhandled: + std::cout << "[USRP_USB_INTERFACE] unhandled msg: " << msg << std::endl; +} + +void +usrp_usb_interface::handle_cmd_open(pmt_t data) +{ + pmt_t invocation_handle = pmt_nth(0, data); + long which_usrp = pmt_to_long(pmt_nth(1, data)); + pmt_t reply_data; + + if(d_fake_usrp) { + d_cs->send(s_response_usrp_open, pmt_list2(invocation_handle, PMT_T)); + return; + } + + if (verbose) + std::cout << "[USRP_USB_INTERFACE] Handling open request for USRP " << which_usrp << "\n"; + + // Open up a standard RX and TX for communication with the USRP + + d_utx = usrp_standard_tx::make(which_usrp, + d_interp_tx, + 1, // 1 channel + -1, // mux + 4096, // USB block size + 16, // nblocks for async transfers + d_rbf + ); + + if(d_utx==0) { + if (verbose) + std::cout << "[USRP_USB_INTERFACE] Failed to open TX\n"; + reply_data = pmt_list2(invocation_handle, PMT_F); + d_cs->send(s_response_usrp_open, reply_data); + return; + } + + if(!d_utx->set_tx_freq (0,d_rf_freq)) { // try setting center freq to 0 + if (verbose) + std::cout << "[USRP_USB_INTERFACE] Failed to set center frequency on TX\n"; + reply_data = pmt_list2(invocation_handle, PMT_F); + d_cs->send(s_response_usrp_open, reply_data); + return; + } + + d_utx->start(); + + if (verbose) + std::cout << "[USRP_USB_INTERFACE] Setup TX channel\n"; + + d_urx = + usrp_standard_rx::make (which_usrp, + d_interp_rx, + 1, // nchan + -1, // mux + 0, // set blank mode to start + 4096, // USB block size + 16, // number of blocks for async transfers + d_rbf); + + if(!d_urx) { + if (verbose) + std::cout << "[usrp_server] Failed to open RX\n"; + reply_data = pmt_list2(invocation_handle, PMT_F); + d_cs->send(s_response_usrp_open, reply_data); + return; + } + + if(!d_urx->set_rx_freq (0, d_rf_freq)) { + if (verbose) + std::cout << "[usrp_server] Failed to set center frequency on RX\n"; + reply_data = pmt_list2(invocation_handle, PMT_F); + d_cs->send(s_response_usrp_open, reply_data); + return; + } + + if(d_fpga_debug) { + d_utx->_write_fpga_reg(FR_DEBUG_EN,0xf); + d_utx->_write_oe(0, 0xffff, 0xffff); + d_urx->_write_oe(0, 0xffff, 0xffff); + d_utx->_write_oe(1, 0xffff, 0xffff); + d_urx->_write_oe(1, 0xffff, 0xffff); + +// while(1){ +// for(int i=0; i<0xffff; i++) +// d_urx->write_io(0, i, 0xffff); +// } + } + + if (verbose) + std::cout << "[USRP_USB_INTERFACE] Setup RX channel\n"; + + d_cs->send(s_response_usrp_open, pmt_list2(invocation_handle, PMT_T)); +} + +void +usrp_usb_interface::handle_cmd_write(pmt_t data) +{ + pmt_t invocation_handle = pmt_nth(0, data); + pmt_t channel = pmt_nth(1, data); + pmt_t pkts = pmt_nth(2, data); + + pmt_t tx_handle = pmt_make_any(d_utx); + + d_tx_cs->send(s_cmd_usrp_tx_write, + pmt_list4(invocation_handle, + channel, + pkts, + tx_handle)); + + return; +} + +void +usrp_usb_interface::handle_cmd_start_reading(pmt_t data) +{ + pmt_t invocation_handle = pmt_nth(0, data); + + if(verbose) + std::cout << "[USRP_USB_INTERFACE] Starting RX...\n"; + + if(!d_fake_usrp) + d_urx->start(); + + pmt_t rx_handle = pmt_make_any(d_urx); + + d_rx_cs->send(s_cmd_usrp_rx_start_reading, pmt_list2(PMT_NIL, rx_handle)); + + return; +} + +void +usrp_usb_interface::handle_cmd_stop_reading(pmt_t data) +{ + pmt_t invocation_handle = pmt_nth(0, data); + + if(!d_fake_usrp) { + if(verbose) + std::cout << "[USRP_USB_INTERFACE] Stopping RX...\n"; + d_urx->stop(); + } + else { + if(verbose) + std::cout << "[USRP_USB_INTERFACE] Stopping fake RX...\n"; + usrp_rx_stop = true; // extern to communicate with stub to wait + } + + return; +} + +void +usrp_usb_interface::handle_cmd_close(pmt_t data) +{ + pmt_t invocation_handle = pmt_nth(0, data); + + if(d_fake_usrp) { + d_cs->send(s_response_usrp_close, pmt_list2(invocation_handle, PMT_T)); + return; + } + + if (verbose) + std::cout << "[USRP_USB_INTERFACE] Handling close request for USRP\n"; + + delete d_utx; + d_utx = 0; + + delete d_urx; + d_urx = 0; + + d_cs->send(s_response_usrp_close, pmt_list2(invocation_handle, PMT_T)); + + shutdown_all(PMT_T); +} + + +REGISTER_MBLOCK_CLASS(usrp_usb_interface); diff --git a/usrp/host/lib/inband/usrp_usb_interface.h b/usrp/host/lib/inband/usrp_usb_interface.h new file mode 100644 index 000000000..42cda7af1 --- /dev/null +++ b/usrp/host/lib/inband/usrp_usb_interface.h @@ -0,0 +1,72 @@ +/* -*- c++ -*- */ +/* + * Copyright 2007 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * GNU Radio is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3, or (at your option) + * any later version. + * + * GNU Radio is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ +#ifndef INCLUDED_USRP_USB_INTERFACE_H +#define INCLUDED_USRP_USB_INTERFACE_H + +#include <mb_mblock.h> +#include <vector> +#include "usrp_standard.h" + +/*! + * \brief Implements the low level usb interface to the USRP + */ +class usrp_usb_interface : public mb_mblock +{ + public: + + usrp_standard_tx* d_utx; + usrp_standard_rx* d_urx; + + mb_port_sptr d_cs; + mb_port_sptr d_rx_cs; + mb_port_sptr d_tx_cs; + + long d_ntx_chan; + long d_nrx_chan; + + long d_fpga_debug; + + bool d_fake_usrp; + + long d_interp_tx; + long d_interp_rx; + + long d_rf_freq; + + std::string d_rbf; + + public: + usrp_usb_interface(mb_runtime *rt, const std::string &instance_name, pmt_t user_arg); + ~usrp_usb_interface(); + void initial_transition(); + void handle_message(mb_message_sptr msg); + + private: + void handle_cmd_open(pmt_t data); + void handle_cmd_close(pmt_t data); + void handle_cmd_write(pmt_t data); + void handle_cmd_start_reading(pmt_t data); + void handle_cmd_stop_reading(pmt_t data); + +}; + + +#endif /* INCLUDED_USRP_USB_INTERFACE_H */ |