diff options
Diffstat (limited to 'host/lib/usrp/mboard')
| -rw-r--r-- | host/lib/usrp/mboard/base.cpp | 29 | ||||
| -rw-r--r-- | host/lib/usrp/mboard/test.cpp | 188 | ||||
| -rw-r--r-- | host/lib/usrp/mboard/usrp2.cpp | 116 | ||||
| -rw-r--r-- | host/lib/usrp/mboard/usrp2/dboard_impl.cpp | 76 | ||||
| -rw-r--r-- | host/lib/usrp/mboard/usrp2/dboard_impl.hpp | 50 | ||||
| -rw-r--r-- | host/lib/usrp/mboard/usrp2/dboard_interface.cpp | 111 | ||||
| -rw-r--r-- | host/lib/usrp/mboard/usrp2/dboard_interface.hpp | 58 | ||||
| -rw-r--r-- | host/lib/usrp/mboard/usrp2/fw_common.h | 127 | ||||
| -rw-r--r-- | host/lib/usrp/mboard/usrp2/impl_base.cpp | 276 | ||||
| -rw-r--r-- | host/lib/usrp/mboard/usrp2/impl_base.hpp | 78 |
10 files changed, 1109 insertions, 0 deletions
diff --git a/host/lib/usrp/mboard/base.cpp b/host/lib/usrp/mboard/base.cpp new file mode 100644 index 000000000..f4f0324f3 --- /dev/null +++ b/host/lib/usrp/mboard/base.cpp @@ -0,0 +1,29 @@ +// +// Copyright 2010 Ettus Research LLC +// +// This program 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 of the License, or +// (at your option) any later version. +// +// This program 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, see <http://www.gnu.org/licenses/>. +// + +#include <uhd/usrp/mboard/base.hpp> +#include <stdexcept> + +using namespace uhd::usrp::mboard; + +base::base(void){ + /* NOP */ +} + +base::~base(void){ + /* NOP */ +} diff --git a/host/lib/usrp/mboard/test.cpp b/host/lib/usrp/mboard/test.cpp new file mode 100644 index 000000000..67d3c70fa --- /dev/null +++ b/host/lib/usrp/mboard/test.cpp @@ -0,0 +1,188 @@ +// +// Copyright 2010 Ettus Research LLC +// +// This program 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 of the License, or +// (at your option) any later version. +// +// This program 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, see <http://www.gnu.org/licenses/>. +// + +#include <uhd/usrp/mboard/test.hpp> +#include <uhd/props.hpp> +#include <boost/lexical_cast.hpp> +#include <boost/format.hpp> +#include <stdexcept> + +using namespace uhd; +using namespace uhd::usrp; +using namespace uhd::usrp::mboard; + +/*********************************************************************** + * dummy interface for dboards + **********************************************************************/ +class dummy_interface : public uhd::usrp::dboard::interface{ +public: + dummy_interface(void){} + ~dummy_interface(void){} + void write_aux_dac(int, int){} + int read_aux_adc(int){return 0;} + void set_atr_reg(gpio_bank_t, uint16_t, uint16_t, uint16_t){} + void set_gpio_ddr(gpio_bank_t, uint16_t, uint16_t){} + void write_gpio(gpio_bank_t, uint16_t, uint16_t){} + uint16_t read_gpio(gpio_bank_t){return 0;} + void write_i2c (int, const std::string &){} + std::string read_i2c (int, size_t){return "";} + void write_spi (spi_dev_t, spi_push_t, const std::string &){} + std::string read_spi (spi_dev_t, spi_latch_t, size_t){return "";} + double get_rx_clock_rate(void){return 0.0;} + double get_tx_clock_rate(void){return 0.0;} +}; + +/*********************************************************************** + * shell class to act as a dboard + **********************************************************************/ +class shell_dboard : public wax::obj{ +public: + enum type_t {TYPE_RX, TYPE_TX}; + shell_dboard(dboard::manager::sptr mgr, type_t type){ + _mgr = mgr; + _type = type; + } + ~shell_dboard(void){} +private: + void get(const wax::obj &key_, wax::obj &val){ + wax::obj key; std::string name; + boost::tie(key, name) = extract_named_prop(key_); + + //handle the get request conditioned on the key + switch(wax::cast<dboard_prop_t>(key)){ + case DBOARD_PROP_NAME: + val = std::string("dboard test mboard"); + return; + + case DBOARD_PROP_SUBDEV: + switch(_type){ + case TYPE_RX: + val = _mgr->get_rx_subdev(name); + return; + + case TYPE_TX: + val = _mgr->get_tx_subdev(name); + return; + } + + case DBOARD_PROP_SUBDEV_NAMES: + switch(_type){ + case TYPE_RX: + val = _mgr->get_rx_subdev_names(); + return; + + case TYPE_TX: + val = _mgr->get_tx_subdev_names(); + return; + } + + case DBOARD_PROP_CODEC: + return; + } + } + + void set(const wax::obj &, const wax::obj &){ + throw std::runtime_error("Cannot set on usrp test dboard"); + } + + type_t _type; + dboard::manager::sptr _mgr; +}; + +/*********************************************************************** + * test usrp mboard class + **********************************************************************/ +test::test(const device_addr_t &device_addr){ + //extract the number of dboards + size_t num_dboards = boost::lexical_cast<size_t>(device_addr["num_dboards"]); + //create a manager for each dboard + for (size_t i = 0; i < num_dboards; i++){ + dboard::interface::sptr ifc(new dummy_interface()); + _dboard_managers[boost::lexical_cast<std::string>(i)] = dboard::manager::sptr( + new dboard::manager(dboard::ID_BASIC_RX, dboard::ID_BASIC_TX, ifc) + ); + } +} + +test::~test(void){ + /* NOP */ +} + +void test::get(const wax::obj &key_, wax::obj &val){ + wax::obj key; std::string name; + boost::tie(key, name) = extract_named_prop(key_); + + //handle the get request conditioned on the key + switch(wax::cast<mboard_prop_t>(key)){ + case MBOARD_PROP_NAME: + val = std::string("usrp test mboard"); + return; + + case MBOARD_PROP_OTHERS: + val = prop_names_t(); //empty other props + return; + + case MBOARD_PROP_RX_DBOARD: + if (not _dboard_managers.has_key(name)) throw std::invalid_argument( + str(boost::format("Unknown rx dboard name %s") % name) + ); + //FIXME store the shell dboard within the class + //may not fix, plan to remove this test class when real usrps work + //val = wax::obj::sptr( + // new shell_dboard(_dboard_managers[name], shell_dboard::TYPE_RX) + //); + return; + + case MBOARD_PROP_RX_DBOARD_NAMES: + val = prop_names_t(_dboard_managers.get_keys()); + return; + + case MBOARD_PROP_TX_DBOARD: + if (not _dboard_managers.has_key(name)) throw std::invalid_argument( + str(boost::format("Unknown tx dboard name %s") % name) + ); + //FIXME store the shell dboard within the class + //may not fix, plan to remove this test class when real usrps work + //val = wax::obj::sptr( + // new shell_dboard(_dboard_managers[name], shell_dboard::TYPE_TX) + //); + return; + + case MBOARD_PROP_TX_DBOARD_NAMES: + val = prop_names_t(_dboard_managers.get_keys()); + return; + + case MBOARD_PROP_MTU: + case MBOARD_PROP_CLOCK_RATE: + case MBOARD_PROP_RX_DSP: + case MBOARD_PROP_RX_DSP_NAMES: + case MBOARD_PROP_TX_DSP: + case MBOARD_PROP_TX_DSP_NAMES: + case MBOARD_PROP_PPS_SOURCE: + case MBOARD_PROP_PPS_SOURCE_NAMES: + case MBOARD_PROP_PPS_POLARITY: + case MBOARD_PROP_REF_SOURCE: + case MBOARD_PROP_REF_SOURCE_NAMES: + case MBOARD_PROP_TIME_NOW: + case MBOARD_PROP_TIME_NEXT_PPS: + throw std::runtime_error("unhandled prop is usrp test mboard"); + } +} + +void test::set(const wax::obj &, const wax::obj &){ + throw std::runtime_error("Cannot set on usrp test mboard"); +} diff --git a/host/lib/usrp/mboard/usrp2.cpp b/host/lib/usrp/mboard/usrp2.cpp new file mode 100644 index 000000000..92f4daa49 --- /dev/null +++ b/host/lib/usrp/mboard/usrp2.cpp @@ -0,0 +1,116 @@ +// +// Copyright 2010 Ettus Research LLC +// +// This program 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 of the License, or +// (at your option) any later version. +// +// This program 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, see <http://www.gnu.org/licenses/>. +// + +#include <uhd/usrp/mboard/usrp2.hpp> +#include <uhd/device.hpp> +#include <uhd/transport/udp.hpp> +#include <boost/lexical_cast.hpp> +#include <boost/format.hpp> +#include <boost/thread.hpp> +#include <netinet/in.h> +#include "usrp2/impl_base.hpp" + +using namespace uhd::usrp::mboard; + +/*********************************************************************** + * Discovery over the udp transport + **********************************************************************/ +uhd::device_addrs_t usrp2::discover(const device_addr_t &hint){ + device_addrs_t usrp2_addrs; + + //create a udp transport to communicate + //TODO if an addr is not provided, search all interfaces? + std::string ctrl_port = boost::lexical_cast<std::string>(USRP2_UDP_CTRL_PORT); + uhd::transport::udp udp_transport(hint["addr"], ctrl_port, true); + + //send a hello control packet + usrp2_ctrl_data_t ctrl_data_out; + ctrl_data_out.id = htonl(USRP2_CTRL_ID_GIVE_ME_YOUR_IP_ADDR_BRO); + udp_transport.send(boost::asio::buffer(&ctrl_data_out, sizeof(ctrl_data_out))); + + //loop and recieve until the time is up + size_t num_timeouts = 0; + while(true){ + uhd::shared_iovec iov = udp_transport.recv(); + //std::cout << boost::asio::buffer_size(buff) << "\n"; + if (iov.len < sizeof(usrp2_ctrl_data_t)){ + //sleep a little so we dont burn cpu + if (num_timeouts++ > 50) break; + boost::this_thread::sleep(boost::posix_time::milliseconds(1)); + }else{ + //handle the received data + const usrp2_ctrl_data_t *ctrl_data_in = reinterpret_cast<const usrp2_ctrl_data_t *>(iov.base); + switch(ntohl(ctrl_data_in->id)){ + case USRP2_CTRL_ID_THIS_IS_MY_IP_ADDR_DUDE: + //make a boost asio ipv4 with the raw addr in host byte order + boost::asio::ip::address_v4 ip_addr(ntohl(ctrl_data_in->data.ip_addr)); + device_addr_t new_addr; + new_addr["name"] = "USRP2"; + new_addr["type"] = "udp"; + new_addr["addr"] = ip_addr.to_string(); + usrp2_addrs.push_back(new_addr); + break; + } + } + } + + return usrp2_addrs; +} + +/*********************************************************************** + * Structors + **********************************************************************/ +usrp2::usrp2(const device_addr_t &device_addr){ + //create a control transport + uhd::transport::udp::sptr ctrl_transport( + new uhd::transport::udp( + device_addr["addr"], + boost::lexical_cast<std::string>(USRP2_UDP_CTRL_PORT) + ) + ); + + //create a data transport + uhd::transport::udp::sptr data_transport( + new uhd::transport::udp( + device_addr["addr"], + boost::lexical_cast<std::string>(USRP2_UDP_DATA_PORT) + ) + ); + + //create the usrp2 implementation guts + _impl = impl_base::sptr( + new impl_base(ctrl_transport, data_transport) + ); +} + +usrp2::~usrp2(void){ + /* NOP */ +} + +/*********************************************************************** + * Get Properties + **********************************************************************/ +void usrp2::get(const wax::obj &key, wax::obj &val){ + return wax::cast<impl_base::sptr>(_impl)->get(key, val); +} + +/*********************************************************************** + * Set Properties + **********************************************************************/ +void usrp2::set(const wax::obj &key, const wax::obj &val){ + return wax::cast<impl_base::sptr>(_impl)->set(key, val); +} diff --git a/host/lib/usrp/mboard/usrp2/dboard_impl.cpp b/host/lib/usrp/mboard/usrp2/dboard_impl.cpp new file mode 100644 index 000000000..309335cc7 --- /dev/null +++ b/host/lib/usrp/mboard/usrp2/dboard_impl.cpp @@ -0,0 +1,76 @@ +// +// Copyright 2010 Ettus Research LLC +// +// This program 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 of the License, or +// (at your option) any later version. +// +// This program 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, see <http://www.gnu.org/licenses/>. +// + +#include <boost/format.hpp> +#include <uhd/utils.hpp> +#include <uhd/props.hpp> +#include <iostream> +#include "dboard_impl.hpp" +#include "dboard_interface.hpp" + +using namespace uhd; +using namespace uhd::usrp; + +dboard_impl::dboard_impl(uhd::usrp::dboard::manager::sptr mgr, type_t type){ + _mgr = mgr; + _type = type; +} + +dboard_impl::~dboard_impl(void){ + /* NOP */ +} + +void dboard_impl::get(const wax::obj &key_, wax::obj &val){ + wax::obj key; std::string name; + boost::tie(key, name) = extract_named_prop(key_); + + //handle the get request conditioned on the key + switch(wax::cast<dboard_prop_t>(key)){ + case DBOARD_PROP_NAME: + val = std::string("usrp2 dboard"); + return; + + case DBOARD_PROP_SUBDEV: + switch(_type){ + case TYPE_RX: + val = _mgr->get_rx_subdev(name); + return; + + case TYPE_TX: + val = _mgr->get_tx_subdev(name); + return; + } + + case DBOARD_PROP_SUBDEV_NAMES: + switch(_type){ + case TYPE_RX: + val = _mgr->get_rx_subdev_names(); + return; + + case TYPE_TX: + val = _mgr->get_tx_subdev_names(); + return; + } + + case DBOARD_PROP_CODEC: + throw std::runtime_error("unhandled prop in usrp2 dboard"); + } +} + +void dboard_impl::set(const wax::obj &, const wax::obj &){ + throw std::runtime_error("Cannot set on usrp2 dboard"); +} diff --git a/host/lib/usrp/mboard/usrp2/dboard_impl.hpp b/host/lib/usrp/mboard/usrp2/dboard_impl.hpp new file mode 100644 index 000000000..a05bcd07b --- /dev/null +++ b/host/lib/usrp/mboard/usrp2/dboard_impl.hpp @@ -0,0 +1,50 @@ +// +// Copyright 2010 Ettus Research LLC +// +// This program 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 of the License, or +// (at your option) any later version. +// +// This program 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, see <http://www.gnu.org/licenses/>. +// + +#include <uhd/usrp/dboard/manager.hpp> +#include <boost/utility.hpp> +#include <boost/shared_ptr.hpp> +#include "fw_common.h" + +#ifndef INCLUDED_DBOARD_IMPL_HPP +#define INCLUDED_DBOARD_IMPL_HPP + +/*! + * The usrp2 dboard implementation: + * Provide the properties access for a dboard. + * Internally, hold a dboard manager and the direction. + * The usrp2 mboard base implementation will create + * two of these classes (one for rx and one for tx). + */ +class dboard_impl : boost::noncopyable, public wax::obj{ +public: + typedef boost::shared_ptr<dboard_impl> sptr; + enum type_t {TYPE_RX, TYPE_TX}; + + dboard_impl(uhd::usrp::dboard::manager::sptr manager, type_t type); + + ~dboard_impl(void); + + void get(const wax::obj &, wax::obj &); + void set(const wax::obj &, const wax::obj &); + +private: + uhd::usrp::dboard::manager::sptr _mgr; + type_t _type; +}; + +#endif /* INCLUDED_DBOARD_IMPL_HPP */ diff --git a/host/lib/usrp/mboard/usrp2/dboard_interface.cpp b/host/lib/usrp/mboard/usrp2/dboard_interface.cpp new file mode 100644 index 000000000..05d29daef --- /dev/null +++ b/host/lib/usrp/mboard/usrp2/dboard_interface.cpp @@ -0,0 +1,111 @@ +// +// Copyright 2010 Ettus Research LLC +// +// This program 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 of the License, or +// (at your option) any later version. +// +// This program 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, see <http://www.gnu.org/licenses/>. +// + +#include <uhd/utils.hpp> +#include "dboard_interface.hpp" +#include "fw_common.h" + +/*********************************************************************** + * Structors + **********************************************************************/ +dboard_interface::dboard_interface(impl_base *impl){ + _impl = impl; +} + +dboard_interface::~dboard_interface(void){ + /* NOP */ +} + +/*********************************************************************** + * Clock Rates + **********************************************************************/ +double dboard_interface::get_rx_clock_rate(void){ + return _impl->get_master_clock_freq(); +} + +double dboard_interface::get_tx_clock_rate(void){ + return _impl->get_master_clock_freq(); +} + +/*********************************************************************** + * GPIO + **********************************************************************/ +/*! + * Static function to convert a gpio bank enum + * to an over-the-wire value for the usrp2 control. + * \param bank the dboard interface gpio bank enum + * \return an over the wire representation + */ +static uint8_t gpio_bank_to_otw(uhd::usrp::dboard::interface::gpio_bank_t bank){ + switch(bank){ + case uhd::usrp::dboard::interface::GPIO_TX_BANK: return USRP2_GPIO_BANK_TX; + case uhd::usrp::dboard::interface::GPIO_RX_BANK: return USRP2_GPIO_BANK_RX; + } + throw std::runtime_error("unknown gpio bank"); +} + +void dboard_interface::set_gpio_ddr(gpio_bank_t bank, uint16_t value, uint16_t mask){ + //setup the out data + usrp2_ctrl_data_t out_data; + out_data.id = htonl(USRP2_CTRL_ID_USE_THESE_GPIO_DDR_SETTINGS_BRO); + out_data.data.gpio_config.bank = gpio_bank_to_otw(bank); + out_data.data.gpio_config.value = htons(value); + out_data.data.gpio_config.mask = htons(mask); + + //send and recv + usrp2_ctrl_data_t in_data = _impl->ctrl_send_and_recv(out_data); + ASSERT_THROW(htonl(in_data.id) == USRP2_CTRL_ID_GOT_THE_GPIO_DDR_SETTINGS_DUDE); +} + +void dboard_interface::write_gpio(gpio_bank_t bank, uint16_t value, uint16_t mask){ + //setup the out data + usrp2_ctrl_data_t out_data; + out_data.id = htonl(USRP2_CTRL_ID_SET_YOUR_GPIO_PIN_OUTS_BRO); + out_data.data.gpio_config.bank = gpio_bank_to_otw(bank); + out_data.data.gpio_config.value = htons(value); + out_data.data.gpio_config.mask = htons(mask); + + //send and recv + usrp2_ctrl_data_t in_data = _impl->ctrl_send_and_recv(out_data); + ASSERT_THROW(htonl(in_data.id) == USRP2_CTRL_ID_I_SET_THE_GPIO_PIN_OUTS_DUDE); +} + +uint16_t dboard_interface::read_gpio(gpio_bank_t bank){ + //setup the out data + usrp2_ctrl_data_t out_data; + out_data.id = htonl(USRP2_CTRL_ID_GIVE_ME_YOUR_GPIO_PIN_VALS_BRO); + out_data.data.gpio_config.bank = gpio_bank_to_otw(bank); + + //send and recv + usrp2_ctrl_data_t in_data = _impl->ctrl_send_and_recv(out_data); + ASSERT_THROW(htonl(in_data.id) == USRP2_CTRL_ID_HERE_IS_YOUR_GPIO_PIN_VALS_DUDE); + return ntohs(in_data.data.gpio_config.value); +} + +void dboard_interface::set_atr_reg(gpio_bank_t bank, uint16_t tx_value, uint16_t rx_value, uint16_t mask){ + //setup the out data + usrp2_ctrl_data_t out_data; + out_data.id = htonl(USRP2_CTRL_ID_USE_THESE_ATR_SETTINGS_BRO); + out_data.data.atr_config.bank = gpio_bank_to_otw(bank); + out_data.data.atr_config.tx_value = htons(tx_value); + out_data.data.atr_config.rx_value = htons(rx_value); + out_data.data.atr_config.mask = htons(mask); + + //send and recv + usrp2_ctrl_data_t in_data = _impl->ctrl_send_and_recv(out_data); + ASSERT_THROW(htonl(in_data.id) == USRP2_CTRL_ID_GOT_THE_ATR_SETTINGS_DUDE); +} diff --git a/host/lib/usrp/mboard/usrp2/dboard_interface.hpp b/host/lib/usrp/mboard/usrp2/dboard_interface.hpp new file mode 100644 index 000000000..645681f43 --- /dev/null +++ b/host/lib/usrp/mboard/usrp2/dboard_interface.hpp @@ -0,0 +1,58 @@ +// +// Copyright 2010 Ettus Research LLC +// +// This program 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 of the License, or +// (at your option) any later version. +// +// This program 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, see <http://www.gnu.org/licenses/>. +// + +#include <uhd/usrp/dboard/interface.hpp> +#include "impl_base.hpp" + +#ifndef INCLUDED_DBOARD_INTERFACE_HPP +#define INCLUDED_DBOARD_INTERFACE_HPP + +class dboard_interface : public uhd::usrp::dboard::interface{ +public: + dboard_interface(impl_base *impl); + + ~dboard_interface(void); + + void write_aux_dac(int, int){} + + int read_aux_adc(int){return 0;} + + void set_atr_reg(gpio_bank_t, uint16_t, uint16_t, uint16_t); + + void set_gpio_ddr(gpio_bank_t, uint16_t, uint16_t); + + void write_gpio(gpio_bank_t, uint16_t, uint16_t); + + uint16_t read_gpio(gpio_bank_t); + + void write_i2c (int, const std::string &){} + + std::string read_i2c (int, size_t){return "";} + + void write_spi (spi_dev_t, spi_push_t, const std::string &){} + + std::string read_spi (spi_dev_t, spi_latch_t, size_t){return "";} + + double get_rx_clock_rate(void); + + double get_tx_clock_rate(void); + +private: + impl_base *_impl; +}; + +#endif /* INCLUDED_DBOARD_INTERFACE_HPP */ diff --git a/host/lib/usrp/mboard/usrp2/fw_common.h b/host/lib/usrp/mboard/usrp2/fw_common.h new file mode 100644 index 000000000..8cd15c7c3 --- /dev/null +++ b/host/lib/usrp/mboard/usrp2/fw_common.h @@ -0,0 +1,127 @@ +// +// Copyright 2010 Ettus Research LLC +// +// This program 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 of the License, or +// (at your option) any later version. +// +// This program 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, see <http://www.gnu.org/licenses/>. +// + +#ifndef INCLUDED_USRP2_FW_COMMON_H +#define INCLUDED_USRP2_FW_COMMON_H + +/*! + * Structs and constants for usrp2 communication. + * This header is shared by the firmware and host code. + * Therefore, this header may only contain valid C code. + */ +#ifdef __cplusplus +extern "C" { +#endif + +// udp ports for the usrp2 communication +// Dynamic and/or private ports: 49152-65535 +#define USRP2_UDP_CTRL_PORT 49152 +#define USRP2_UDP_DATA_PORT 49153 + +typedef enum{ + USRP2_CTRL_ID_HUH_WHAT, + //USRP2_CTRL_ID_FOR_SURE, //TODO error condition enums + //USRP2_CTRL_ID_SUX_MAN, + + USRP2_CTRL_ID_GIVE_ME_YOUR_IP_ADDR_BRO, + USRP2_CTRL_ID_THIS_IS_MY_IP_ADDR_DUDE, + USRP2_CTRL_ID_HERE_IS_A_NEW_IP_ADDR_BRO, + + USRP2_CTRL_ID_GIVE_ME_YOUR_MAC_ADDR_BRO, + USRP2_CTRL_ID_THIS_IS_MY_MAC_ADDR_DUDE, + USRP2_CTRL_ID_HERE_IS_A_NEW_MAC_ADDR_BRO, + + USRP2_CTRL_ID_GIVE_ME_YOUR_DBOARD_IDS_BRO, + USRP2_CTRL_ID_THESE_ARE_MY_DBOARD_IDS_DUDE, + + USRP2_CTRL_ID_HERES_A_NEW_CLOCK_CONFIG_BRO, + USRP2_CTRL_ID_GOT_THE_NEW_CLOCK_CONFIG_DUDE, + + USRP2_CTRL_ID_USE_THESE_GPIO_DDR_SETTINGS_BRO, + USRP2_CTRL_ID_GOT_THE_GPIO_DDR_SETTINGS_DUDE, + + USRP2_CTRL_ID_SET_YOUR_GPIO_PIN_OUTS_BRO, + USRP2_CTRL_ID_I_SET_THE_GPIO_PIN_OUTS_DUDE, + + USRP2_CTRL_ID_GIVE_ME_YOUR_GPIO_PIN_VALS_BRO, + USRP2_CTRL_ID_HERE_IS_YOUR_GPIO_PIN_VALS_DUDE, + + USRP2_CTRL_ID_USE_THESE_ATR_SETTINGS_BRO, + USRP2_CTRL_ID_GOT_THE_ATR_SETTINGS_DUDE, + + USRP2_CTRL_ID_PEACE_OUT + +} usrp2_ctrl_id_t; + +typedef enum{ + USRP2_PPS_SOURCE_SMA, + USRP2_PPS_SOURCE_MIMO +} usrp2_pps_source_t; + +typedef enum{ + USRP2_PPS_POLARITY_POS, + USRP2_PPS_POLARITY_NEG +} usrp2_pps_polarity_t; + +typedef enum{ + USRP2_REF_SOURCE_INT, + USRP2_REF_SOURCE_SMA, + USRP2_REF_SOURCE_MIMO +} usrp2_ref_source_t; + +typedef enum{ + USRP2_GPIO_BANK_RX, + USRP2_GPIO_BANK_TX +} usrp2_gpio_bank_t; + +typedef struct{ + uint32_t id; + uint32_t seq; + union{ + uint32_t ip_addr; + uint8_t mac_addr[6]; + struct { + uint16_t rx_id; + uint16_t tx_id; + } dboard_ids; + struct { + uint8_t pps_source; + uint8_t pps_polarity; + uint8_t ref_source; + uint8_t _pad; + } clock_config; + struct { + uint8_t bank; + uint8_t _pad[3]; + uint16_t value; + uint16_t mask; + } gpio_config; + struct { + uint8_t bank; + uint8_t _pad[3]; + uint16_t tx_value; + uint16_t rx_value; + uint16_t mask; + } atr_config; + } data; +} usrp2_ctrl_data_t; + +#ifdef __cplusplus +} +#endif + +#endif /* INCLUDED_USRP2_FW_COMMON_H */ diff --git a/host/lib/usrp/mboard/usrp2/impl_base.cpp b/host/lib/usrp/mboard/usrp2/impl_base.cpp new file mode 100644 index 000000000..e81b7cdb0 --- /dev/null +++ b/host/lib/usrp/mboard/usrp2/impl_base.cpp @@ -0,0 +1,276 @@ +// +// Copyright 2010 Ettus Research LLC +// +// This program 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 of the License, or +// (at your option) any later version. +// +// This program 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, see <http://www.gnu.org/licenses/>. +// + +#include <boost/format.hpp> +#include <uhd/utils.hpp> +#include <uhd/props.hpp> +#include <iostream> +#include "impl_base.hpp" +#include "dboard_interface.hpp" + +using namespace uhd; +using namespace uhd::usrp; + +/*********************************************************************** + * Structors + **********************************************************************/ +impl_base::impl_base( + uhd::transport::udp::sptr ctrl_transport, + uhd::transport::udp::sptr data_transport +){ + _ctrl_transport = ctrl_transport; + _data_transport = data_transport; + + //grab the dboard ids over the control line + usrp2_ctrl_data_t out_data; + out_data.id = htonl(USRP2_CTRL_ID_GIVE_ME_YOUR_DBOARD_IDS_BRO); + usrp2_ctrl_data_t in_data = ctrl_send_and_recv(out_data); + ASSERT_THROW(htonl(in_data.id) == USRP2_CTRL_ID_THESE_ARE_MY_DBOARD_IDS_DUDE); + std::cout << boost::format("rx id 0x%.2x, tx id 0x%.2x") + % ntohs(in_data.data.dboard_ids.rx_id) + % ntohs(in_data.data.dboard_ids.tx_id) << std::endl; + + //extract the dboard ids an convert them to enums + dboard::dboard_id_t rx_dboard_id = static_cast<dboard::dboard_id_t>( + ntohs(in_data.data.dboard_ids.rx_id) + ); + dboard::dboard_id_t tx_dboard_id = static_cast<dboard::dboard_id_t>( + ntohs(in_data.data.dboard_ids.tx_id) + ); + + //create a new dboard interface and manager + dboard::interface::sptr _dboard_interface( + new dboard_interface(this) + ); + dboard::manager::sptr dboard_manager( + new dboard::manager(rx_dboard_id, tx_dboard_id, _dboard_interface) + ); + + //load dboards + _rx_dboards[""] = dboard_impl::sptr(new dboard_impl(dboard_manager, dboard_impl::TYPE_RX)); + _tx_dboards[""] = dboard_impl::sptr(new dboard_impl(dboard_manager, dboard_impl::TYPE_TX)); + + //TOD load dsps + + //init the pps source clock config + _pps_source_dict["sma"] = USRP2_PPS_SOURCE_SMA; + _pps_source_dict["mimo"] = USRP2_PPS_SOURCE_MIMO; + _pps_source = "sma"; + + //init the pps polarity clock config + _pps_polarity_dict["pos"] = USRP2_PPS_POLARITY_POS; + _pps_polarity_dict["neg"] = USRP2_PPS_POLARITY_NEG; + _pps_polarity = "neg"; + + //init the ref source clock config + _ref_source_dict["int"] = USRP2_REF_SOURCE_INT; + _ref_source_dict["sma"] = USRP2_REF_SOURCE_SMA; + _ref_source_dict["mimo"] = USRP2_REF_SOURCE_MIMO; + _ref_source = "int"; + + //update the clock config (sends a control packet) + update_clock_config(); +} + +impl_base::~impl_base(void){ + /* NOP */ +} + +/*********************************************************************** + * Misc Access Methods + **********************************************************************/ +double impl_base::get_master_clock_freq(void){ + return 100e6; +} + +void impl_base::update_clock_config(void){ + //setup the out data + usrp2_ctrl_data_t out_data; + out_data.id = htonl(USRP2_CTRL_ID_HERES_A_NEW_CLOCK_CONFIG_BRO); + out_data.data.clock_config.pps_source = _pps_source_dict [_pps_source]; + out_data.data.clock_config.pps_polarity = _pps_polarity_dict[_pps_polarity]; + out_data.data.clock_config.ref_source = _ref_source_dict [_ref_source]; + + //send and recv + usrp2_ctrl_data_t in_data = ctrl_send_and_recv(out_data); + ASSERT_THROW(htonl(in_data.id) == USRP2_CTRL_ID_GOT_THE_NEW_CLOCK_CONFIG_DUDE); +} + +/*********************************************************************** + * Control Send/Recv + **********************************************************************/ +usrp2_ctrl_data_t impl_base::ctrl_send_and_recv(const usrp2_ctrl_data_t &out_data){ + boost::mutex::scoped_lock lock(_ctrl_mutex); + + //fill in the seq number and send + usrp2_ctrl_data_t out_copy = out_data; + out_copy.seq = htonl(++_ctrl_seq_num); + _ctrl_transport->send(boost::asio::buffer(&out_copy, sizeof(usrp2_ctrl_data_t))); + + //loop and recieve until the time is up + size_t num_timeouts = 0; + while(true){ + uhd::shared_iovec iov = _ctrl_transport->recv(); + if (iov.len < sizeof(usrp2_ctrl_data_t)){ + //sleep a little so we dont burn cpu + if (num_timeouts++ > 50) break; + boost::this_thread::sleep(boost::posix_time::milliseconds(1)); + }else{ + //handle the received data + usrp2_ctrl_data_t in_data = *reinterpret_cast<const usrp2_ctrl_data_t *>(iov.base); + if (ntohl(in_data.seq) == _ctrl_seq_num){ + return in_data; + } + //didnt get seq, continue on... + } + } + throw std::runtime_error("usrp2 no control response"); +} + +/*********************************************************************** + * Get Properties + **********************************************************************/ +void impl_base::get(const wax::obj &key_, wax::obj &val){ + wax::obj key; std::string name; + boost::tie(key, name) = extract_named_prop(key_); + + //handle the get request conditioned on the key + switch(wax::cast<mboard_prop_t>(key)){ + case MBOARD_PROP_NAME: + val = std::string("usrp2 mboard"); + return; + + case MBOARD_PROP_OTHERS: + val = prop_names_t(); //empty other props + return; + + case MBOARD_PROP_RX_DBOARD: + val = _rx_dboards[name]->get_link(); + return; + + case MBOARD_PROP_RX_DBOARD_NAMES: + val = prop_names_t(_rx_dboards.get_keys()); + return; + + case MBOARD_PROP_TX_DBOARD: + val = _tx_dboards[name]->get_link(); + return; + + case MBOARD_PROP_TX_DBOARD_NAMES: + val = prop_names_t(_tx_dboards.get_keys()); + return; + + case MBOARD_PROP_MTU: + // FIXME we dont know the real MTU... + // give them something to fragment about + val = size_t(1500); + return; + + case MBOARD_PROP_CLOCK_RATE: + val = freq_t(get_master_clock_freq()); + return; + + case MBOARD_PROP_RX_DSP: + throw std::runtime_error("unhandled prop in usrp2 mboard"); + + case MBOARD_PROP_RX_DSP_NAMES: + throw std::runtime_error("unhandled prop in usrp2 mboard"); + + case MBOARD_PROP_TX_DSP: + throw std::runtime_error("unhandled prop in usrp2 mboard"); + + case MBOARD_PROP_TX_DSP_NAMES: + throw std::runtime_error("unhandled prop in usrp2 mboard"); + + case MBOARD_PROP_PPS_SOURCE: + val = _pps_source; + return; + + case MBOARD_PROP_PPS_SOURCE_NAMES: + val = prop_names_t(_pps_source_dict.get_keys()); + return; + + case MBOARD_PROP_PPS_POLARITY: + val = _pps_polarity; + return; + + case MBOARD_PROP_REF_SOURCE: + val = _ref_source; + return; + + case MBOARD_PROP_REF_SOURCE_NAMES: + val = prop_names_t(_ref_source_dict.get_keys()); + return; + + case MBOARD_PROP_TIME_NOW: + case MBOARD_PROP_TIME_NEXT_PPS: + throw std::runtime_error("Error: trying to get write-only property on usrp2 mboard"); + + } +} + +/*********************************************************************** + * Set Properties + **********************************************************************/ +void impl_base::set(const wax::obj &key, const wax::obj &val){ + //handle the get request conditioned on the key + switch(wax::cast<mboard_prop_t>(key)){ + + case MBOARD_PROP_PPS_SOURCE:{ + std::string name = wax::cast<std::string>(val); + ASSERT_THROW(_pps_source_dict.has_key(name)); + _pps_source = name; //shadow + update_clock_config(); + } + return; + + case MBOARD_PROP_PPS_POLARITY:{ + std::string name = wax::cast<std::string>(val); + ASSERT_THROW(_pps_polarity_dict.has_key(name)); + _pps_polarity = name; //shadow + update_clock_config(); + } + return; + + case MBOARD_PROP_REF_SOURCE:{ + std::string name = wax::cast<std::string>(val); + ASSERT_THROW(_ref_source_dict.has_key(name)); + _ref_source = name; //shadow + update_clock_config(); + } + return; + + case MBOARD_PROP_NAME: + case MBOARD_PROP_OTHERS: + case MBOARD_PROP_MTU: + case MBOARD_PROP_CLOCK_RATE: + case MBOARD_PROP_RX_DSP: + case MBOARD_PROP_RX_DSP_NAMES: + case MBOARD_PROP_TX_DSP: + case MBOARD_PROP_TX_DSP_NAMES: + case MBOARD_PROP_RX_DBOARD: + case MBOARD_PROP_RX_DBOARD_NAMES: + case MBOARD_PROP_TX_DBOARD: + case MBOARD_PROP_TX_DBOARD_NAMES: + case MBOARD_PROP_PPS_SOURCE_NAMES: + case MBOARD_PROP_REF_SOURCE_NAMES: + case MBOARD_PROP_TIME_NOW: + case MBOARD_PROP_TIME_NEXT_PPS: + throw std::runtime_error("Error: trying to set read-only property on usrp2 mboard"); + + } +} diff --git a/host/lib/usrp/mboard/usrp2/impl_base.hpp b/host/lib/usrp/mboard/usrp2/impl_base.hpp new file mode 100644 index 000000000..b808cf2b1 --- /dev/null +++ b/host/lib/usrp/mboard/usrp2/impl_base.hpp @@ -0,0 +1,78 @@ +// +// Copyright 2010 Ettus Research LLC +// +// This program 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 of the License, or +// (at your option) any later version. +// +// This program 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, see <http://www.gnu.org/licenses/>. +// + +#include <boost/utility.hpp> +#include <boost/thread.hpp> +#include <boost/shared_ptr.hpp> +#include <uhd/transport/udp.hpp> +#include <uhd/dict.hpp> +#include "dboard_impl.hpp" +#include "fw_common.h" + +#ifndef INCLUDED_IMPL_BASE_HPP +#define INCLUDED_IMPL_BASE_HPP + +class impl_base : boost::noncopyable, public wax::obj{ +public: + typedef boost::shared_ptr<impl_base> sptr; + + /*! + * Create a new usrp2 impl base. + * \param ctrl_transport the udp transport for control + * \param data_transport the udp transport for data + */ + impl_base( + uhd::transport::udp::sptr ctrl_transport, + uhd::transport::udp::sptr data_transport + ); + + ~impl_base(void); + + //performs a control transaction + usrp2_ctrl_data_t ctrl_send_and_recv(const usrp2_ctrl_data_t &); + + //properties access methods + void get(const wax::obj &, wax::obj &); + void set(const wax::obj &, const wax::obj &); + + //misc access methods + double get_master_clock_freq(void); + void update_clock_config(void); + +private: + //udp transports for control and data + uhd::transport::udp::sptr _ctrl_transport; + uhd::transport::udp::sptr _data_transport; + + //private vars for dealing with send/recv control + uint32_t _ctrl_seq_num; + boost::mutex _ctrl_mutex; + + //containers for the dboard objects + uhd::dict<std::string, dboard_impl::sptr> _rx_dboards; + uhd::dict<std::string, dboard_impl::sptr> _tx_dboards; + + //shadows for various settings + std::string _pps_source, _pps_polarity, _ref_source; + + //mappings from clock config strings to over the wire enums + uhd::dict<std::string, usrp2_pps_source_t> _pps_source_dict; + uhd::dict<std::string, usrp2_pps_polarity_t> _pps_polarity_dict; + uhd::dict<std::string, usrp2_ref_source_t> _ref_source_dict; +}; + +#endif /* INCLUDED_IMPL_BASE_HPP */ |