diff options
Diffstat (limited to 'host/lib/usrp')
-rw-r--r-- | host/lib/usrp/dboard/base.cpp | 89 | ||||
-rw-r--r-- | host/lib/usrp/dboard/basic.cpp | 56 | ||||
-rw-r--r-- | host/lib/usrp/dboard/dboards.hpp | 53 | ||||
-rw-r--r-- | host/lib/usrp/dboard/id.cpp | 39 | ||||
-rw-r--r-- | host/lib/usrp/dboard/interface.cpp | 28 | ||||
-rw-r--r-- | host/lib/usrp/dboard/manager.cpp | 205 | ||||
-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 | ||||
-rw-r--r-- | host/lib/usrp/usrp.cpp | 98 |
17 files changed, 1677 insertions, 0 deletions
diff --git a/host/lib/usrp/dboard/base.cpp b/host/lib/usrp/dboard/base.cpp new file mode 100644 index 000000000..de8db323a --- /dev/null +++ b/host/lib/usrp/dboard/base.cpp @@ -0,0 +1,89 @@ +// +// 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/base.hpp> +#include <stdexcept> + +using namespace uhd::usrp::dboard; + +/*********************************************************************** + * base dboard base class + **********************************************************************/ +base::base(ctor_args_t const& args){ + boost::tie(_subdev_name, _dboard_interface) = args; +} + +base::~base(void){ + /* NOP */ +} + +std::string base::get_subdev_name(void){ + return _subdev_name; +} + +interface::sptr base::get_interface(void){ + return _dboard_interface; +} + +/*********************************************************************** + * xcvr dboard base class + **********************************************************************/ +xcvr_base::xcvr_base(ctor_args_t const& args) : base(args){ + /* NOP */ +} + +xcvr_base::~xcvr_base(void){ + /* NOP */ +} + +/*********************************************************************** + * rx dboard base class + **********************************************************************/ +rx_base::rx_base(ctor_args_t const& args) : base(args){ + /* NOP */ +} + +rx_base::~rx_base(void){ + /* NOP */ +} + +void rx_base::tx_get(const wax::obj &, wax::obj &){ + throw std::runtime_error("cannot call tx_get on a rx dboard"); +} + +void rx_base::tx_set(const wax::obj &, const wax::obj &){ + throw std::runtime_error("cannot call tx_set on a rx dboard"); +} + +/*********************************************************************** + * tx dboard base class + **********************************************************************/ +tx_base::tx_base(ctor_args_t const& args) : base(args){ + /* NOP */ +} + +tx_base::~tx_base(void){ + /* NOP */ +} + +void tx_base::rx_get(const wax::obj &, wax::obj &){ + throw std::runtime_error("cannot call rx_get on a tx dboard"); +} + +void tx_base::rx_set(const wax::obj &, const wax::obj &){ + throw std::runtime_error("cannot call rx_set on a tx dboard"); +} diff --git a/host/lib/usrp/dboard/basic.cpp b/host/lib/usrp/dboard/basic.cpp new file mode 100644 index 000000000..35512aa5f --- /dev/null +++ b/host/lib/usrp/dboard/basic.cpp @@ -0,0 +1,56 @@ +// +// 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 "dboards.hpp" + +/*********************************************************************** + * Basic RX dboard + **********************************************************************/ +basic_rx::basic_rx(ctor_args_t const& args) : rx_base(args){ + /* NOP */ +} + +basic_rx::~basic_rx(void){ + /* NOP */ +} + +void basic_rx::rx_get(const wax::obj &, wax::obj &){ + /* TODO */ +} + +void basic_rx::rx_set(const wax::obj &, const wax::obj &){ + /* TODO */ +} + +/*********************************************************************** + * Basic TX dboard + **********************************************************************/ +basic_tx::basic_tx(ctor_args_t const& args) : tx_base(args){ + /* NOP */ +} + +basic_tx::~basic_tx(void){ + /* NOP */ +} + +void basic_tx::tx_get(const wax::obj &, wax::obj &){ + /* TODO */ +} + +void basic_tx::tx_set(const wax::obj &, const wax::obj &){ + /* TODO */ +} diff --git a/host/lib/usrp/dboard/dboards.hpp b/host/lib/usrp/dboard/dboards.hpp new file mode 100644 index 000000000..0e740856f --- /dev/null +++ b/host/lib/usrp/dboard/dboards.hpp @@ -0,0 +1,53 @@ +// +// 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_LOCAL_DBOARDS_HPP +#define INCLUDED_LOCAL_DBOARDS_HPP + +#include <uhd/usrp/dboard/base.hpp> + +using namespace uhd::usrp::dboard; + +/*********************************************************************** + * The basic boards: + **********************************************************************/ +class basic_rx : public rx_base{ +public: + static base::sptr make(ctor_args_t const& args){ + return base::sptr(new basic_rx(args)); + } + basic_rx(ctor_args_t const& args); + ~basic_rx(void); + + void rx_get(const wax::obj &key, wax::obj &val); + void rx_set(const wax::obj &key, const wax::obj &val); +}; + +class basic_tx : public tx_base{ +public: + static base::sptr make(ctor_args_t const& args){ + return base::sptr(new basic_tx(args)); + } + basic_tx(ctor_args_t const& args); + ~basic_tx(void); + + void tx_get(const wax::obj &key, wax::obj &val); + void tx_set(const wax::obj &key, const wax::obj &val); + +}; + +#endif /* INCLUDED_LOCAL_DBOARDS_HPP */ diff --git a/host/lib/usrp/dboard/id.cpp b/host/lib/usrp/dboard/id.cpp new file mode 100644 index 000000000..80162240e --- /dev/null +++ b/host/lib/usrp/dboard/id.cpp @@ -0,0 +1,39 @@ +// +// 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/id.hpp> +#include <boost/format.hpp> +#include <uhd/dict.hpp> + +using namespace uhd::usrp::dboard; + +std::ostream& operator<<(std::ostream &os, const dboard_id_t &id){ + //map the dboard ids to string representations + uhd::dict<dboard_id_t, std::string> id_to_str; + id_to_str[ID_NONE] = "none"; + id_to_str[ID_BASIC_TX] = "basic tx"; + id_to_str[ID_BASIC_RX] = "basic rx"; + + //get the string representation + if (id_to_str.has_key(id)){ + os << id_to_str[id]; + } + else{ + os << boost::format("dboard id %u") % unsigned(id); + } + return os; +} diff --git a/host/lib/usrp/dboard/interface.cpp b/host/lib/usrp/dboard/interface.cpp new file mode 100644 index 000000000..837c76d0a --- /dev/null +++ b/host/lib/usrp/dboard/interface.cpp @@ -0,0 +1,28 @@ +// +// 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> + +using namespace uhd::usrp::dboard; + +interface::interface(void){ + /* NOP */ +} + +interface::~interface(void){ + /* NOP */ +} diff --git a/host/lib/usrp/dboard/manager.cpp b/host/lib/usrp/dboard/manager.cpp new file mode 100644 index 000000000..4a675fd0b --- /dev/null +++ b/host/lib/usrp/dboard/manager.cpp @@ -0,0 +1,205 @@ +// +// 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/assign/list_of.hpp> +#include <boost/format.hpp> +#include <boost/foreach.hpp> +#include "dboards.hpp" + +using namespace uhd; +using namespace uhd::usrp::dboard; +using namespace boost::assign; + +/*********************************************************************** + * register internal dboards + * + * Register internal/known dboards located in this build tree. + * Each board should have entries below mapping an id to a constructor. + * The xcvr type boards should register both rx and tx sides. + * + * This function will be called before new boards are registered. + * This allows for internal boards to be externally overridden. + * This function will also be called when creating a new manager + * to ensure that the maps are filled with the entries below. + **********************************************************************/ +static void register_internal_dboards(void){ + //ensure that this function can only be called once per instance + static bool called = false; + if (called) return; called = true; + //register the known dboards (dboard id, constructor, subdev names) + manager::register_subdevs(ID_NONE, &basic_tx::make, list_of("")); //for none, make a basic tx + manager::register_subdevs(ID_NONE, &basic_rx::make, list_of("ab")); //for none, make a basic rx (one subdev) + manager::register_subdevs(ID_BASIC_TX, &basic_tx::make, list_of("")); + manager::register_subdevs(ID_BASIC_RX, &basic_rx::make, list_of("a")("b")("ab")); +} + +/*********************************************************************** + * storage and registering for dboards + **********************************************************************/ +//map a dboard id to a dboard constructor +static uhd::dict<dboard_id_t, manager::dboard_ctor_t> id_to_ctor_map; + +//map a dboard constructor to subdevice names +static uhd::dict<manager::dboard_ctor_t, prop_names_t> ctor_to_names_map; + +void manager::register_subdevs( + dboard_id_t dboard_id, + dboard_ctor_t dboard_ctor, + const prop_names_t &subdev_names +){ + register_internal_dboards(); //always call first + id_to_ctor_map[dboard_id] = dboard_ctor; + ctor_to_names_map[dboard_ctor] = subdev_names; +} + +/*********************************************************************** + * internal helper classes + **********************************************************************/ +/*! + * A special wax proxy object that forwards calls to a subdev. + * A sptr to an instance will be used in the properties structure. + */ +class subdev_proxy : boost::noncopyable, public wax::obj{ +public: + typedef boost::shared_ptr<subdev_proxy> sptr; + enum type_t{RX_TYPE, TX_TYPE}; + + //structors + subdev_proxy(base::sptr subdev, type_t type) + : _subdev(subdev), _type(type){ + /* NOP */ + } + + ~subdev_proxy(void){ + /* NOP */ + } + +private: + base::sptr _subdev; + type_t _type; + + //forward the get calls to the rx or tx + void get(const wax::obj &key, wax::obj &val){ + switch(_type){ + case RX_TYPE: return _subdev->rx_get(key, val); + case TX_TYPE: return _subdev->tx_get(key, val); + } + } + + //forward the set calls to the rx or tx + void set(const wax::obj &key, const wax::obj &val){ + switch(_type){ + case RX_TYPE: return _subdev->rx_set(key, val); + case TX_TYPE: return _subdev->tx_set(key, val); + } + } +}; + +/*********************************************************************** + * dboard manager methods + **********************************************************************/ +static manager::dboard_ctor_t const& get_dboard_ctor( + dboard_id_t dboard_id, + std::string const& xx_type +){ + //verify that there is a registered constructor for this id + if (not id_to_ctor_map.has_key(dboard_id)){ + throw std::runtime_error(str( + boost::format("Unknown %s dboard id: 0x%04x") % xx_type % dboard_id + )); + } + //return the dboard constructor for this id + return id_to_ctor_map[dboard_id]; +} + +manager::manager( + dboard_id_t rx_dboard_id, + dboard_id_t tx_dboard_id, + interface::sptr dboard_interface +){ + register_internal_dboards(); //always call first + const dboard_ctor_t rx_dboard_ctor = get_dboard_ctor(rx_dboard_id, "rx"); + const dboard_ctor_t tx_dboard_ctor = get_dboard_ctor(tx_dboard_id, "tx"); + //make xcvr subdevs (make one subdev for both rx and tx dboards) + if (rx_dboard_ctor == tx_dboard_ctor){ + BOOST_FOREACH(std::string name, ctor_to_names_map[rx_dboard_ctor]){ + base::sptr xcvr_dboard = rx_dboard_ctor( + base::ctor_args_t(name, dboard_interface) + ); + //create a rx proxy for this xcvr board + _rx_dboards[name] = subdev_proxy::sptr( + new subdev_proxy(xcvr_dboard, subdev_proxy::RX_TYPE) + ); + //create a tx proxy for this xcvr board + _tx_dboards[name] = subdev_proxy::sptr( + new subdev_proxy(xcvr_dboard, subdev_proxy::TX_TYPE) + ); + } + } + //make tx and rx subdevs (separate subdevs for rx and tx dboards) + else{ + //make the rx subdevs + BOOST_FOREACH(std::string name, ctor_to_names_map[rx_dboard_ctor]){ + base::sptr rx_dboard = rx_dboard_ctor( + base::ctor_args_t(name, dboard_interface) + ); + //create a rx proxy for this rx board + _rx_dboards[name] = subdev_proxy::sptr( + new subdev_proxy(rx_dboard, subdev_proxy::RX_TYPE) + ); + } + //make the tx subdevs + BOOST_FOREACH(std::string name, ctor_to_names_map[tx_dboard_ctor]){ + base::sptr tx_dboard = tx_dboard_ctor( + base::ctor_args_t(name, dboard_interface) + ); + //create a tx proxy for this tx board + _tx_dboards[name] = subdev_proxy::sptr( + new subdev_proxy(tx_dboard, subdev_proxy::TX_TYPE) + ); + } + } +} + +manager::~manager(void){ + /* NOP */ +} + +prop_names_t manager::get_rx_subdev_names(void){ + return _rx_dboards.get_keys(); +} + +prop_names_t manager::get_tx_subdev_names(void){ + return _tx_dboards.get_keys(); +} + +wax::obj manager::get_rx_subdev(const std::string &subdev_name){ + if (not _rx_dboards.has_key(subdev_name)) throw std::invalid_argument( + str(boost::format("Unknown rx subdev name %s") % subdev_name) + ); + //get a link to the rx subdev proxy + return wax::cast<subdev_proxy::sptr>(_rx_dboards[subdev_name])->get_link(); +} + +wax::obj manager::get_tx_subdev(const std::string &subdev_name){ + if (not _tx_dboards.has_key(subdev_name)) throw std::invalid_argument( + str(boost::format("Unknown tx subdev name %s") % subdev_name) + ); + //get a link to the tx subdev proxy + return wax::cast<subdev_proxy::sptr>(_tx_dboards[subdev_name])->get_link(); +} 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 */ diff --git a/host/lib/usrp/usrp.cpp b/host/lib/usrp/usrp.cpp new file mode 100644 index 000000000..86a40ebd8 --- /dev/null +++ b/host/lib/usrp/usrp.cpp @@ -0,0 +1,98 @@ +// +// 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/usrp.hpp> +#include <uhd/usrp/mboard/usrp2.hpp> +#include <uhd/usrp/mboard/test.hpp> +#include <boost/format.hpp> +#include <boost/bind.hpp> +#include <stdexcept> + +using namespace uhd::usrp; + +/*********************************************************************** + * default callbacks for the send and recv + * these should be replaced with callbacks from the mboard object + **********************************************************************/ +static void send_raw_default(const std::vector<boost::asio::const_buffer> &){ + throw std::runtime_error("No callback registered for send raw"); +} + +static uhd::shared_iovec recv_raw_default(void){ + throw std::runtime_error("No callback registered for recv raw"); +} + +/*********************************************************************** + * the usrp device wrapper + **********************************************************************/ +usrp::usrp(const device_addr_t &device_addr){ + //set the default callbacks, the code below should replace them + _send_raw_cb = boost::bind(&send_raw_default, _1); + _recv_raw_cb = boost::bind(&recv_raw_default); + + //create mboard based on the device addr + if (not device_addr.has_key("type")){ + //TODO nothing + } + else if (device_addr["type"] == "test"){ + _mboards[""] = mboard::base::sptr(new mboard::test(device_addr)); + } + else if (device_addr["type"] == "udp"){ + _mboards[""] = mboard::base::sptr(new mboard::usrp2(device_addr)); + } +} + +usrp::~usrp(void){ + /* NOP */ +} + +void usrp::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<device_prop_t>(key)){ + case DEVICE_PROP_NAME: + val = std::string("usrp device"); + return; + + case DEVICE_PROP_MBOARD: + if (not _mboards.has_key(name)) throw std::invalid_argument( + str(boost::format("Unknown mboard name %s") % name) + ); + //turn the mboard sptr object into a wax::obj::sptr + //this allows the properties access through the wax::proxy + val = _mboards[name]->get_link(); + return; + + case DEVICE_PROP_MBOARD_NAMES: + val = prop_names_t(_mboards.get_keys()); + return; + } +} + +void usrp::set(const wax::obj &, const wax::obj &){ + throw std::runtime_error("Cannot set in usrp device"); +} + +void usrp::send_raw(const std::vector<boost::asio::const_buffer> &buffs){ + return _send_raw_cb(buffs); +} + +uhd::shared_iovec usrp::recv_raw(void){ + return _recv_raw_cb(); +} |