diff options
Diffstat (limited to 'host/lib/usrp/b200/b200_impl.cpp')
| -rw-r--r-- | host/lib/usrp/b200/b200_impl.cpp | 1110 |
1 files changed, 584 insertions, 526 deletions
diff --git a/host/lib/usrp/b200/b200_impl.cpp b/host/lib/usrp/b200/b200_impl.cpp index bf95d8e6b..1da682349 100644 --- a/host/lib/usrp/b200/b200_impl.cpp +++ b/host/lib/usrp/b200/b200_impl.cpp @@ -34,60 +34,78 @@ using namespace uhd::usrp::gpio_atr; using namespace uhd::transport; namespace { - constexpr int64_t REENUMERATION_TIMEOUT_MS = 3000; +constexpr int64_t REENUMERATION_TIMEOUT_MS = 3000; } // B200 + B210: -class b200_ad9361_client_t : public ad9361_params { +class b200_ad9361_client_t : public ad9361_params +{ public: ~b200_ad9361_client_t() {} - double get_band_edge(frequency_band_t band) { + double get_band_edge(frequency_band_t band) + { switch (band) { - case AD9361_RX_BAND0: return 2.2e9; // Port C - case AD9361_RX_BAND1: return 4.0e9; // Port B - case AD9361_TX_BAND0: return 2.5e9; // Port B - default: return 0; + case AD9361_RX_BAND0: + return 2.2e9; // Port C + case AD9361_RX_BAND1: + return 4.0e9; // Port B + case AD9361_TX_BAND0: + return 2.5e9; // Port B + default: + return 0; } } - clocking_mode_t get_clocking_mode() { + clocking_mode_t get_clocking_mode() + { return clocking_mode_t::AD9361_XTAL_N_CLK_PATH; } - digital_interface_mode_t get_digital_interface_mode() { + digital_interface_mode_t get_digital_interface_mode() + { return AD9361_DDR_FDD_LVCMOS; } - digital_interface_delays_t get_digital_interface_timing() { + digital_interface_delays_t get_digital_interface_timing() + { digital_interface_delays_t delays; - delays.rx_clk_delay = 0; + delays.rx_clk_delay = 0; delays.rx_data_delay = 0xF; - delays.tx_clk_delay = 0; + delays.tx_clk_delay = 0; delays.tx_data_delay = 0xF; return delays; } }; // B205 -class b2xxmini_ad9361_client_t : public ad9361_params { +class b2xxmini_ad9361_client_t : public ad9361_params +{ public: ~b2xxmini_ad9361_client_t() {} - double get_band_edge(frequency_band_t band) { + double get_band_edge(frequency_band_t band) + { switch (band) { - case AD9361_RX_BAND0: return 0; // Set these all to - case AD9361_RX_BAND1: return 0; // zero, so RF port A - case AD9361_TX_BAND0: return 0; // is used all the time - default: return 0; // On both Rx and Tx + case AD9361_RX_BAND0: + return 0; // Set these all to + case AD9361_RX_BAND1: + return 0; // zero, so RF port A + case AD9361_TX_BAND0: + return 0; // is used all the time + default: + return 0; // On both Rx and Tx } } - clocking_mode_t get_clocking_mode() { + clocking_mode_t get_clocking_mode() + { return clocking_mode_t::AD9361_XTAL_N_CLK_PATH; } - digital_interface_mode_t get_digital_interface_mode() { + digital_interface_mode_t get_digital_interface_mode() + { return AD9361_DDR_FDD_LVCMOS; } - digital_interface_delays_t get_digital_interface_timing() { + digital_interface_delays_t get_digital_interface_timing() + { digital_interface_delays_t delays; - delays.rx_clk_delay = 0; + delays.rx_clk_delay = 0; delays.rx_data_delay = 0xF; - delays.tx_clk_delay = 0; + delays.tx_clk_delay = 0; delays.tx_data_delay = 0xF; return delays; } @@ -96,16 +114,14 @@ public: /*********************************************************************** * Helpers **********************************************************************/ -std::string check_option_valid( - const std::string &name, - const std::vector<std::string> &valid_options, - const std::string &option -) { - if (std::find(valid_options.begin(), valid_options.end(), option) == valid_options.end()) { - throw uhd::runtime_error(str( - boost::format("Invalid option chosen for: %s") - % name - )); +std::string check_option_valid(const std::string& name, + const std::vector<std::string>& valid_options, + const std::string& option) +{ + if (std::find(valid_options.begin(), valid_options.end(), option) + == valid_options.end()) { + throw uhd::runtime_error( + str(boost::format("Invalid option chosen for: %s") % name)); } return option; @@ -117,7 +133,8 @@ std::string check_option_valid( //! Look up the type of B-Series device we're currently running. // Throws a uhd::runtime_error if the USB PID and the product ID stored // in the MB EEPROM are invalid, -b200_product_t get_b200_product(const usb_device_handle::sptr& handle, const mboard_eeprom_t &mb_eeprom) +b200_product_t get_b200_product( + const usb_device_handle::sptr& handle, const mboard_eeprom_t& mb_eeprom) { // Try USB PID first uint16_t product_id = handle->get_product_id(); @@ -130,40 +147,42 @@ b200_product_t get_b200_product(const usb_device_handle::sptr& handle, const mbo } product_id = boost::lexical_cast<uint16_t>(mb_eeprom["product"]); if (not B2XX_PRODUCT_ID.has_key(product_id)) { - throw uhd::runtime_error(str( - boost::format("B200 unknown product code: 0x%04x") - % product_id - )); + throw uhd::runtime_error( + str(boost::format("B200 unknown product code: 0x%04x") % product_id)); } return B2XX_PRODUCT_ID[product_id]; } -std::vector<usb_device_handle::sptr> get_b200_device_handles(const device_addr_t &hint) +std::vector<usb_device_handle::sptr> get_b200_device_handles(const device_addr_t& hint) { std::vector<usb_device_handle::vid_pid_pair_t> vid_pid_pair_list; - if(hint.has_key("vid") && hint.has_key("pid") && hint.has_key("type") && hint["type"] == "b200") { - vid_pid_pair_list.push_back(usb_device_handle::vid_pid_pair_t(uhd::cast::hexstr_cast<uint16_t>(hint.get("vid")), - uhd::cast::hexstr_cast<uint16_t>(hint.get("pid")))); + if (hint.has_key("vid") && hint.has_key("pid") && hint.has_key("type") + && hint["type"] == "b200") { + vid_pid_pair_list.push_back(usb_device_handle::vid_pid_pair_t( + uhd::cast::hexstr_cast<uint16_t>(hint.get("vid")), + uhd::cast::hexstr_cast<uint16_t>(hint.get("pid")))); } else { vid_pid_pair_list = b200_vid_pid_pairs; } - //find the usrps and load firmware + // find the usrps and load firmware return usb_device_handle::get_device_list(vid_pid_pair_list); } -static device_addrs_t b200_find(const device_addr_t &hint) +static device_addrs_t b200_find(const device_addr_t& hint) { device_addrs_t b200_addrs; - //return an empty list of addresses when type is set to non-b200 - if (hint.has_key("type") and hint["type"] != "b200") return b200_addrs; + // return an empty list of addresses when type is set to non-b200 + if (hint.has_key("type") and hint["type"] != "b200") + return b200_addrs; - //Return an empty list of addresses when an address or resource is specified, - //since an address and resource is intended for a different, non-USB, device. - for(device_addr_t hint_i: separate_device_addr(hint)) { - if (hint_i.has_key("addr") || hint_i.has_key("resource")) return b200_addrs; + // Return an empty list of addresses when an address or resource is specified, + // since an address and resource is intended for a different, non-USB, device. + for (device_addr_t hint_i : separate_device_addr(hint)) { + if (hint_i.has_key("addr") || hint_i.has_key("resource")) + return b200_addrs; } // Important note: @@ -172,64 +191,66 @@ static device_addrs_t b200_find(const device_addr_t &hint) // so that re-enumeration after fw load can occur successfully. // This requirement is a courtesy of libusb1.0 on windows. size_t found = 0; - for(usb_device_handle::sptr handle: get_b200_device_handles(hint)) { - //extract the firmware path for the b200 + for (usb_device_handle::sptr handle : get_b200_device_handles(hint)) { + // extract the firmware path for the b200 std::string b200_fw_image; - try{ + try { b200_fw_image = hint.get("fw", B200_FW_FILE_NAME); - b200_fw_image = uhd::find_image_path(b200_fw_image, STR(UHD_IMAGES_DIR)); // FIXME - } - catch(uhd::exception &e){ + b200_fw_image = + uhd::find_image_path(b200_fw_image, STR(UHD_IMAGES_DIR)); // FIXME + } catch (uhd::exception& e) { UHD_LOGGER_WARNING("B200") << e.what(); return b200_addrs; } - UHD_LOGGER_DEBUG("B200") << "the firmware image: " << b200_fw_image ; + UHD_LOGGER_DEBUG("B200") << "the firmware image: " << b200_fw_image; usb_control::sptr control; - try{control = usb_control::make(handle, 0);} - catch(const uhd::exception &){continue;} //ignore claimed + try { + control = usb_control::make(handle, 0); + } catch (const uhd::exception&) { + continue; + } // ignore claimed - //check if fw was already loaded - if (!(handle->firmware_loaded())) - { + // check if fw was already loaded + if (!(handle->firmware_loaded())) { b200_iface::make(control)->load_firmware(b200_fw_image); } found++; } - const auto timeout_time = - std::chrono::steady_clock::now() - + std::chrono::milliseconds(REENUMERATION_TIMEOUT_MS); - //search for the device until found or timeout - while (std::chrono::steady_clock::now() < timeout_time - and b200_addrs.empty() - and found != 0) { - for(usb_device_handle::sptr handle: get_b200_device_handles(hint)) { + const auto timeout_time = std::chrono::steady_clock::now() + + std::chrono::milliseconds(REENUMERATION_TIMEOUT_MS); + // search for the device until found or timeout + while (std::chrono::steady_clock::now() < timeout_time and b200_addrs.empty() + and found != 0) { + for (usb_device_handle::sptr handle : get_b200_device_handles(hint)) { usb_control::sptr control; - try{control = usb_control::make(handle, 0);} - catch(const uhd::exception &){continue;} //ignore claimed + try { + control = usb_control::make(handle, 0); + } catch (const uhd::exception&) { + continue; + } // ignore claimed - b200_iface::sptr iface = b200_iface::make(control); + b200_iface::sptr iface = b200_iface::make(control); const mboard_eeprom_t mb_eeprom = b200_impl::get_mb_eeprom(iface); device_addr_t new_addr; - new_addr["type"] = "b200"; - new_addr["name"] = mb_eeprom["name"]; + new_addr["type"] = "b200"; + new_addr["name"] = mb_eeprom["name"]; new_addr["serial"] = handle->get_serial(); try { // Turn the 16-Bit product ID into a string representation new_addr["product"] = B2XX_STR_NAMES[get_b200_product(handle, mb_eeprom)]; - } catch (const uhd::runtime_error &) { + } catch (const uhd::runtime_error&) { // No problem if this fails -- this is just device discovery, after all. new_addr["product"] = "B2??"; } - //this is a found b200 when the hint serial and name match or blank - if ( - (not hint.has_key("name") or hint["name"] == new_addr["name"]) and - (not hint.has_key("serial") or hint["serial"] == new_addr["serial"]) - ){ + // this is a found b200 when the hint serial and name match or blank + if ((not hint.has_key("name") or hint["name"] == new_addr["name"]) + and (not hint.has_key("serial") + or hint["serial"] == new_addr["serial"])) { b200_addrs.push_back(new_addr); } } @@ -241,7 +262,7 @@ static device_addrs_t b200_find(const device_addr_t &hint) /*********************************************************************** * Make **********************************************************************/ -static device::sptr b200_make(const device_addr_t &device_addr) +static device::sptr b200_make(const device_addr_t& device_addr) { uhd::transport::usb_device_handle::sptr handle; @@ -250,14 +271,14 @@ static device::sptr b200_make(const device_addr_t &device_addr) // a third time is pointless. try { return device::sptr(new b200_impl(device_addr, handle)); - } - catch (const uhd::usb_error &) { - UHD_LOGGER_INFO("B200") << "Detected bad USB state; resetting." ; + } catch (const uhd::usb_error&) { + UHD_LOGGER_INFO("B200") << "Detected bad USB state; resetting."; libusb::device_handle::sptr dev_handle(libusb::device_handle::get_cached_handle( - std::static_pointer_cast<libusb::special_handle>(handle)->get_device() - )); - dev_handle->clear_endpoints(B200_USB_CTRL_RECV_ENDPOINT, B200_USB_CTRL_SEND_ENDPOINT); - dev_handle->clear_endpoints(B200_USB_DATA_RECV_ENDPOINT, B200_USB_DATA_SEND_ENDPOINT); + std::static_pointer_cast<libusb::special_handle>(handle)->get_device())); + dev_handle->clear_endpoints( + B200_USB_CTRL_RECV_ENDPOINT, B200_USB_CTRL_SEND_ENDPOINT); + dev_handle->clear_endpoints( + B200_USB_DATA_RECV_ENDPOINT, B200_USB_DATA_SEND_ENDPOINT); dev_handle->reset_device(); } @@ -272,84 +293,96 @@ UHD_STATIC_BLOCK(register_b200_device) /*********************************************************************** * Structors **********************************************************************/ -b200_impl::b200_impl(const uhd::device_addr_t& device_addr, usb_device_handle::sptr &handle) : - _product(B200), // Some safe value - _revision(0), - _enable_user_regs(device_addr.has_key("enable_user_regs")), - _time_source(UNKNOWN), - _tick_rate(0.0) // Forces a clock initialization at startup +b200_impl::b200_impl( + const uhd::device_addr_t& device_addr, usb_device_handle::sptr& handle) + : _product(B200) + , // Some safe value + _revision(0) + , _enable_user_regs(device_addr.has_key("enable_user_regs")) + , _time_source(UNKNOWN) + , _tick_rate(0.0) // Forces a clock initialization at startup { - _tree = property_tree::make(); - _type = device::USRP; + _tree = property_tree::make(); + _type = device::USRP; const fs_path mb_path = "/mboards/0"; - //try to match the given device address with something on the USB bus - uint16_t vid = B200_VENDOR_ID; - uint16_t pid = B200_PRODUCT_ID; + // try to match the given device address with something on the USB bus + uint16_t vid = B200_VENDOR_ID; + uint16_t pid = B200_PRODUCT_ID; bool specified_vid = false; bool specified_pid = false; - if (device_addr.has_key("vid")) - { - vid = uhd::cast::hexstr_cast<uint16_t>(device_addr.get("vid")); + if (device_addr.has_key("vid")) { + vid = uhd::cast::hexstr_cast<uint16_t>(device_addr.get("vid")); specified_vid = true; } - if (device_addr.has_key("pid")) - { - pid = uhd::cast::hexstr_cast<uint16_t>(device_addr.get("pid")); + if (device_addr.has_key("pid")) { + pid = uhd::cast::hexstr_cast<uint16_t>(device_addr.get("pid")); specified_pid = true; } - std::vector<usb_device_handle::vid_pid_pair_t> vid_pid_pair_list;//search list for devices. + std::vector<usb_device_handle::vid_pid_pair_t> + vid_pid_pair_list; // search list for devices. // Search only for specified VID and PID if both specified - if (specified_vid && specified_pid) - { - vid_pid_pair_list.push_back(usb_device_handle::vid_pid_pair_t(vid,pid)); + if (specified_vid && specified_pid) { + vid_pid_pair_list.push_back(usb_device_handle::vid_pid_pair_t(vid, pid)); } // Search for all supported PIDs limited to specified VID if only VID specified - else if (specified_vid) - { - vid_pid_pair_list.push_back(usb_device_handle::vid_pid_pair_t(vid, B200_PRODUCT_ID)); - vid_pid_pair_list.push_back(usb_device_handle::vid_pid_pair_t(vid, B200MINI_PRODUCT_ID)); - vid_pid_pair_list.push_back(usb_device_handle::vid_pid_pair_t(vid, B205MINI_PRODUCT_ID)); - vid_pid_pair_list.push_back(usb_device_handle::vid_pid_pair_t(vid, B200_PRODUCT_NI_ID)); - vid_pid_pair_list.push_back(usb_device_handle::vid_pid_pair_t(vid, B210_PRODUCT_NI_ID)); + else if (specified_vid) { + vid_pid_pair_list.push_back( + usb_device_handle::vid_pid_pair_t(vid, B200_PRODUCT_ID)); + vid_pid_pair_list.push_back( + usb_device_handle::vid_pid_pair_t(vid, B200MINI_PRODUCT_ID)); + vid_pid_pair_list.push_back( + usb_device_handle::vid_pid_pair_t(vid, B205MINI_PRODUCT_ID)); + vid_pid_pair_list.push_back( + usb_device_handle::vid_pid_pair_t(vid, B200_PRODUCT_NI_ID)); + vid_pid_pair_list.push_back( + usb_device_handle::vid_pid_pair_t(vid, B210_PRODUCT_NI_ID)); } // Search for all supported VIDs limited to specified PID if only PID specified - else if (specified_pid) - { - vid_pid_pair_list.push_back(usb_device_handle::vid_pid_pair_t(B200_VENDOR_ID,pid)); - vid_pid_pair_list.push_back(usb_device_handle::vid_pid_pair_t(B200_VENDOR_NI_ID,pid)); + else if (specified_pid) { + vid_pid_pair_list.push_back( + usb_device_handle::vid_pid_pair_t(B200_VENDOR_ID, pid)); + vid_pid_pair_list.push_back( + usb_device_handle::vid_pid_pair_t(B200_VENDOR_NI_ID, pid)); } // Search for all supported devices if neither VID nor PID specified - else - { - vid_pid_pair_list.push_back(usb_device_handle::vid_pid_pair_t(B200_VENDOR_ID, B200_PRODUCT_ID)); - vid_pid_pair_list.push_back(usb_device_handle::vid_pid_pair_t(B200_VENDOR_ID, B200MINI_PRODUCT_ID)); - vid_pid_pair_list.push_back(usb_device_handle::vid_pid_pair_t(B200_VENDOR_ID, B205MINI_PRODUCT_ID)); - vid_pid_pair_list.push_back(usb_device_handle::vid_pid_pair_t(B200_VENDOR_NI_ID, B200_PRODUCT_NI_ID)); - vid_pid_pair_list.push_back(usb_device_handle::vid_pid_pair_t(B200_VENDOR_NI_ID, B210_PRODUCT_NI_ID)); + else { + vid_pid_pair_list.push_back( + usb_device_handle::vid_pid_pair_t(B200_VENDOR_ID, B200_PRODUCT_ID)); + vid_pid_pair_list.push_back( + usb_device_handle::vid_pid_pair_t(B200_VENDOR_ID, B200MINI_PRODUCT_ID)); + vid_pid_pair_list.push_back( + usb_device_handle::vid_pid_pair_t(B200_VENDOR_ID, B205MINI_PRODUCT_ID)); + vid_pid_pair_list.push_back( + usb_device_handle::vid_pid_pair_t(B200_VENDOR_NI_ID, B200_PRODUCT_NI_ID)); + vid_pid_pair_list.push_back( + usb_device_handle::vid_pid_pair_t(B200_VENDOR_NI_ID, B210_PRODUCT_NI_ID)); } - std::vector<usb_device_handle::sptr> device_list = usb_device_handle::get_device_list(vid_pid_pair_list); + std::vector<usb_device_handle::sptr> device_list = + usb_device_handle::get_device_list(vid_pid_pair_list); - //locate the matching handle in the device list - for(usb_device_handle::sptr dev_handle: device_list) { + // locate the matching handle in the device list + for (usb_device_handle::sptr dev_handle : device_list) { try { - if (dev_handle->get_serial() == device_addr["serial"]){ + if (dev_handle->get_serial() == device_addr["serial"]) { handle = dev_handle; break; } - } catch (const uhd::exception&) { continue; } + } catch (const uhd::exception&) { + continue; + } } - UHD_ASSERT_THROW(handle.get() != NULL); //better be found + UHD_ASSERT_THROW(handle.get() != NULL); // better be found - //create control objects + // create control objects usb_control::sptr control = usb_control::make(handle, 0); - _iface = b200_iface::make(control); - this->check_fw_compat(); //check after making + _iface = b200_iface::make(control); + this->check_fw_compat(); // check after making //////////////////////////////////////////////////////////////////// // setup the mboard eeprom @@ -357,7 +390,8 @@ b200_impl::b200_impl(const uhd::device_addr_t& device_addr, usb_device_handle::s const mboard_eeprom_t mb_eeprom = get_mb_eeprom(_iface); _tree->create<mboard_eeprom_t>(mb_path / "eeprom") .set(mb_eeprom) - .add_coerced_subscriber(std::bind(&b200_impl::set_mb_eeprom, this, std::placeholders::_1)); + .add_coerced_subscriber( + std::bind(&b200_impl::set_mb_eeprom, this, std::placeholders::_1)); //////////////////////////////////////////////////////////////////// // Identify the device type @@ -366,10 +400,10 @@ b200_impl::b200_impl(const uhd::device_addr_t& device_addr, usb_device_handle::s std::string product_name; try { // This will throw if the product ID is invalid: - _product = get_b200_product(handle, mb_eeprom); + _product = get_b200_product(handle, mb_eeprom); default_file_name = B2XX_FPGA_FILE_NAME.get(_product); product_name = B2XX_STR_NAMES.get(_product); - } catch (const uhd::runtime_error &e) { + } catch (const uhd::runtime_error& e) { // The only reason we may let this pass is if the user specified // the FPGA file name: if (not device_addr.has_key("fpga")) { @@ -382,9 +416,9 @@ b200_impl::b200_impl(const uhd::device_addr_t& device_addr, usb_device_handle::s _revision = boost::lexical_cast<size_t>(mb_eeprom["revision"]); } - UHD_LOGGER_INFO("B200") << "Detected Device: " << B2XX_STR_NAMES[_product] ; + UHD_LOGGER_INFO("B200") << "Detected Device: " << B2XX_STR_NAMES[_product]; - _gpsdo_capable = (not (_product == B200MINI or _product == B205MINI)); + _gpsdo_capable = (not(_product == B200MINI or _product == B205MINI)); //////////////////////////////////////////////////////////////////// // Set up frontend mapping @@ -399,27 +433,27 @@ b200_impl::b200_impl(const uhd::device_addr_t& device_addr, usb_device_handle::s // does not have an FE2, so we don't swap FEs. // Swapped setup: - _fe1 = 1; - _fe2 = 0; + _fe1 = 1; + _fe2 = 0; _gpio_state.swap_atr = 1; // Unswapped setup: - if (_product == B200MINI or _product == B205MINI or (_product == B200 and _revision >= 5)) { - _fe1 = 0; //map radio0 to FE1 - _fe2 = 1; //map radio1 to FE2 + if (_product == B200MINI or _product == B205MINI + or (_product == B200 and _revision >= 5)) { + _fe1 = 0; // map radio0 to FE1 + _fe2 = 1; // map radio1 to FE2 _gpio_state.swap_atr = 0; // ATRs for radio0 are mapped to FE1 } //////////////////////////////////////////////////////////////////// // Load the FPGA image, then reset GPIF //////////////////////////////////////////////////////////////////// - //extract the FPGA path for the B200 + // extract the FPGA path for the B200 std::string b200_fpga_image = find_image_path( - device_addr.has_key("fpga")? device_addr["fpga"] : default_file_name - ); + device_addr.has_key("fpga") ? device_addr["fpga"] : default_file_name); uint32_t status = _iface->load_fpga(b200_fpga_image); - if(status != 0) { + if (status != 0) { throw uhd::runtime_error(str(boost::format("fx3 is in state %1%") % status)); } @@ -429,7 +463,7 @@ b200_impl::b200_impl(const uhd::device_addr_t& device_addr, usb_device_handle::s // Create control transport //////////////////////////////////////////////////////////////////// uint8_t usb_speed = _iface->get_usb_speed(); - UHD_LOGGER_INFO("B200") << "Operating over USB " << (int) usb_speed << "." ; + UHD_LOGGER_INFO("B200") << "Operating over USB " << (int)usb_speed << "."; const std::string min_frame_size = (usb_speed == 3) ? "1024" : "512"; device_addr_t ctrl_xport_args; @@ -439,32 +473,38 @@ b200_impl::b200_impl(const uhd::device_addr_t& device_addr, usb_device_handle::s ctrl_xport_args["num_send_frames"] = "16"; // This may throw a uhd::usb_error, which will be caught by b200_make(). - _ctrl_transport = usb_zero_copy::make( - handle, - B200_USB_CTRL_RECV_INTERFACE, B200_USB_CTRL_RECV_ENDPOINT, //interface, endpoint - B200_USB_CTRL_SEND_INTERFACE, B200_USB_CTRL_SEND_ENDPOINT, //interface, endpoint - ctrl_xport_args - ); - while (_ctrl_transport->get_recv_buff(0.0)){} //flush ctrl xport - _tree->create<double>(mb_path / "link_max_rate").set((usb_speed == 3) ? B200_MAX_RATE_USB3 : B200_MAX_RATE_USB2); + _ctrl_transport = usb_zero_copy::make(handle, + B200_USB_CTRL_RECV_INTERFACE, + B200_USB_CTRL_RECV_ENDPOINT, // interface, endpoint + B200_USB_CTRL_SEND_INTERFACE, + B200_USB_CTRL_SEND_ENDPOINT, // interface, endpoint + ctrl_xport_args); + while (_ctrl_transport->get_recv_buff(0.0)) { + } // flush ctrl xport + _tree->create<double>(mb_path / "link_max_rate") + .set((usb_speed == 3) ? B200_MAX_RATE_USB3 : B200_MAX_RATE_USB2); //////////////////////////////////////////////////////////////////// // Async task structure //////////////////////////////////////////////////////////////////// _async_task_data.reset(new AsyncTaskData()); - _async_task_data->async_md.reset(new async_md_type(1000/*messages deep*/)); - if (_gpsdo_capable) - { - _async_task_data->gpsdo_uart = b200_uart::make(_ctrl_transport, B200_TX_GPS_UART_SID); + _async_task_data->async_md.reset(new async_md_type(1000 /*messages deep*/)); + if (_gpsdo_capable) { + _async_task_data->gpsdo_uart = + b200_uart::make(_ctrl_transport, B200_TX_GPS_UART_SID); } - _async_task = uhd::msg_task::make(std::bind(&b200_impl::handle_async_task, this, _ctrl_transport, _async_task_data)); + _async_task = uhd::msg_task::make(std::bind( + &b200_impl::handle_async_task, this, _ctrl_transport, _async_task_data)); //////////////////////////////////////////////////////////////////// // Local control endpoint //////////////////////////////////////////////////////////////////// - _local_ctrl = radio_ctrl_core_3000::make(false/*lilE*/, _ctrl_transport, zero_copy_if::sptr()/*null*/, B200_LOCAL_CTRL_SID); + _local_ctrl = radio_ctrl_core_3000::make(false /*lilE*/, + _ctrl_transport, + zero_copy_if::sptr() /*null*/, + B200_LOCAL_CTRL_SID); _local_ctrl->hold_task(_async_task); - _async_task_data->local_ctrl = _local_ctrl; //weak + _async_task_data->local_ctrl = _local_ctrl; // weak this->check_fpga_compat(); /* Initialize the GPIOs, set the default bandsels to the lower range. Note @@ -475,30 +515,21 @@ b200_impl::b200_impl(const uhd::device_addr_t& device_addr, usb_device_handle::s //////////////////////////////////////////////////////////////////// // Create the GPSDO control //////////////////////////////////////////////////////////////////// - if (_gpsdo_capable) - { - - if ((_local_ctrl->peek32(RB32_CORE_STATUS) & 0xff) != B200_GPSDO_ST_NONE) - { + if (_gpsdo_capable) { + if ((_local_ctrl->peek32(RB32_CORE_STATUS) & 0xff) != B200_GPSDO_ST_NONE) { UHD_LOGGER_INFO("B200") << "Detecting internal GPSDO.... " << std::flush; - try - { + try { _gps = gps_ctrl::make(_async_task_data->gpsdo_uart); + } catch (std::exception& e) { + UHD_LOGGER_ERROR("B200") + << "An error occurred making GPSDO control: " << e.what(); } - catch(std::exception &e) - { - UHD_LOGGER_ERROR("B200") << "An error occurred making GPSDO control: " << e.what(); - } - if (_gps and _gps->gps_detected()) - { - for(const std::string &name: _gps->get_sensors()) - { + if (_gps and _gps->gps_detected()) { + for (const std::string& name : _gps->get_sensors()) { _tree->create<sensor_value_t>(mb_path / "sensors" / name) .set_publisher(std::bind(&gps_ctrl::get_sensor, _gps, name)); } - } - else - { + } else { _local_ctrl->poke32(TOREG(SR_CORE_GPSDO_ST), B200_GPSDO_ST_NONE); } } @@ -509,7 +540,8 @@ b200_impl::b200_impl(const uhd::device_addr_t& device_addr, usb_device_handle::s //////////////////////////////////////////////////////////////////// _tree->create<std::string>("/name").set("B-Series Device"); _tree->create<std::string>(mb_path / "name").set(product_name); - _tree->create<std::string>(mb_path / "codename").set((_product == B200MINI or _product == B205MINI) ? "Pixie" : "Sasquatch"); + _tree->create<std::string>(mb_path / "codename") + .set((_product == B200MINI or _product == B205MINI) ? "Pixie" : "Sasquatch"); //////////////////////////////////////////////////////////////////// // Create data transport @@ -519,22 +551,18 @@ b200_impl::b200_impl(const uhd::device_addr_t& device_addr, usb_device_handle::s //////////////////////////////////////////////////////////////////// device_addr_t data_xport_args; const int max_transfer = usb_speed == 3 ? 1024 : 512; - int recv_frame_size = device_addr.cast<int>( - "recv_frame_size", - B200_USB_DATA_DEFAULT_FRAME_SIZE - ); + int recv_frame_size = + device_addr.cast<int>("recv_frame_size", B200_USB_DATA_DEFAULT_FRAME_SIZE); // Check that recv_frame_size limits. if (recv_frame_size < B200_USB_DATA_MIN_RECV_FRAME_SIZE) { - UHD_LOGGER_WARNING("B200") - << "Requested recv_frame_size of " << recv_frame_size - << " is too small. It will be set to " - << B200_USB_DATA_MIN_RECV_FRAME_SIZE << "."; + UHD_LOGGER_WARNING("B200") << "Requested recv_frame_size of " << recv_frame_size + << " is too small. It will be set to " + << B200_USB_DATA_MIN_RECV_FRAME_SIZE << "."; recv_frame_size = B200_USB_DATA_MIN_RECV_FRAME_SIZE; } else if (recv_frame_size > B200_USB_DATA_MAX_RECV_FRAME_SIZE) { - UHD_LOGGER_WARNING("B200") - << "Requested recv_frame_size of " << recv_frame_size - << " is too large. It will be set to " - << B200_USB_DATA_MAX_RECV_FRAME_SIZE << "."; + UHD_LOGGER_WARNING("B200") << "Requested recv_frame_size of " << recv_frame_size + << " is too large. It will be set to " + << B200_USB_DATA_MAX_RECV_FRAME_SIZE << "."; recv_frame_size = B200_USB_DATA_MAX_RECV_FRAME_SIZE; } else if (recv_frame_size % max_transfer == 0 or recv_frame_size % 8 != 0) { // The Cypress FX3 does not properly handle recv_frame_sizes that are @@ -553,37 +581,39 @@ b200_impl::b200_impl(const uhd::device_addr_t& device_addr, usb_device_handle::s UHD_LOGGER_WARNING("B200") << "The recv_frame_size must be a multiple of 8 bytes and not a multiple of " << max_transfer << " bytes. Requested recv_frame_size of " - << device_addr["recv_frame_size"] - << " coerced to " << recv_frame_size << "."; + << device_addr["recv_frame_size"] << " coerced to " << recv_frame_size << "."; } data_xport_args["recv_frame_size"] = std::to_string(recv_frame_size); data_xport_args["num_recv_frames"] = device_addr.get("num_recv_frames", "16"); - data_xport_args["send_frame_size"] = device_addr.get("send_frame_size", std::to_string(B200_USB_DATA_DEFAULT_FRAME_SIZE)); + data_xport_args["send_frame_size"] = device_addr.get( + "send_frame_size", std::to_string(B200_USB_DATA_DEFAULT_FRAME_SIZE)); data_xport_args["num_send_frames"] = device_addr.get("num_send_frames", "16"); // This may throw a uhd::usb_error, which will be caught by b200_make(). - _data_transport = usb_zero_copy::make( - handle, // identifier - B200_USB_DATA_RECV_INTERFACE, B200_USB_DATA_RECV_ENDPOINT, //interface, endpoint - B200_USB_DATA_SEND_INTERFACE, B200_USB_DATA_SEND_ENDPOINT, //interface, endpoint - data_xport_args // param hints + _data_transport = usb_zero_copy::make(handle, // identifier + B200_USB_DATA_RECV_INTERFACE, + B200_USB_DATA_RECV_ENDPOINT, // interface, endpoint + B200_USB_DATA_SEND_INTERFACE, + B200_USB_DATA_SEND_ENDPOINT, // interface, endpoint + data_xport_args // param hints ); - while (_data_transport->get_recv_buff(0.0)){} //flush ctrl xport + while (_data_transport->get_recv_buff(0.0)) { + } // flush ctrl xport _demux = recv_packet_demuxer_3000::make(_data_transport); //////////////////////////////////////////////////////////////////// // create time and clock control objects //////////////////////////////////////////////////////////////////// _spi_iface = b200_local_spi_core::make(_local_ctrl); - if (not (_product == B200MINI or _product == B205MINI)) { + if (not(_product == B200MINI or _product == B205MINI)) { _adf4001_iface = std::make_shared<b200_ref_pll_ctrl>(_spi_iface); } //////////////////////////////////////////////////////////////////// // Init codec - turns on clocks //////////////////////////////////////////////////////////////////// - UHD_LOGGER_INFO("B200") << "Initialize CODEC control..." ; + UHD_LOGGER_INFO("B200") << "Initialize CODEC control..."; reset_codec(); ad9361_params::sptr client_settings; if (_product == B200MINI or _product == B205MINI) { @@ -598,13 +628,15 @@ b200_impl::b200_impl(const uhd::device_addr_t& device_addr, usb_device_handle::s //////////////////////////////////////////////////////////////////// { const fs_path codec_path = mb_path / ("rx_codecs") / "A"; - _tree->create<std::string>(codec_path / "name").set(product_name+" RX dual ADC"); - _tree->create<int>(codec_path / "gains"); //empty cuz gains are in frontend + _tree->create<std::string>(codec_path / "name") + .set(product_name + " RX dual ADC"); + _tree->create<int>(codec_path / "gains"); // empty cuz gains are in frontend } { const fs_path codec_path = mb_path / ("tx_codecs") / "A"; - _tree->create<std::string>(codec_path / "name").set(product_name+" TX dual DAC"); - _tree->create<int>(codec_path / "gains"); //empty cuz gains are in frontend + _tree->create<std::string>(codec_path / "name") + .set(product_name + " TX dual DAC"); + _tree->create<int>(codec_path / "gains"); // empty cuz gains are in frontend } //////////////////////////////////////////////////////////////////// @@ -613,12 +645,11 @@ b200_impl::b200_impl(const uhd::device_addr_t& device_addr, usb_device_handle::s _tree->create<double>(mb_path / "tick_rate") .set_coercer(std::bind(&b200_impl::set_tick_rate, this, std::placeholders::_1)) .set_publisher(std::bind(&b200_impl::get_tick_rate, this)) - .add_coerced_subscriber(std::bind(&b200_impl::update_tick_rate, this, std::placeholders::_1)); - _tree->create<meta_range_t>(mb_path / "tick_rate/range") - .set_publisher([this](){ - return this->_codec_ctrl->get_clock_rate_range(); - }) - ; + .add_coerced_subscriber( + std::bind(&b200_impl::update_tick_rate, this, std::placeholders::_1)); + _tree->create<meta_range_t>(mb_path / "tick_rate/range").set_publisher([this]() { + return this->_codec_ctrl->get_clock_rate_range(); + }); _tree->create<time_spec_t>(mb_path / "time" / "cmd"); _tree->create<bool>(mb_path / "auto_tick_rate").set(false); @@ -631,22 +662,27 @@ b200_impl::b200_impl(const uhd::device_addr_t& device_addr, usb_device_handle::s //////////////////////////////////////////////////////////////////// // create frontend mapping //////////////////////////////////////////////////////////////////// - std::vector<size_t> default_map(2, 0); default_map[1] = 1; // Set this to A->0 B->1 even if there's only A - _tree->create<std::vector<size_t> >(mb_path / "rx_chan_dsp_mapping").set(default_map); - _tree->create<std::vector<size_t> >(mb_path / "tx_chan_dsp_mapping").set(default_map); + std::vector<size_t> default_map(2, 0); + default_map[1] = 1; // Set this to A->0 B->1 even if there's only A + _tree->create<std::vector<size_t>>(mb_path / "rx_chan_dsp_mapping").set(default_map); + _tree->create<std::vector<size_t>>(mb_path / "tx_chan_dsp_mapping").set(default_map); _tree->create<subdev_spec_t>(mb_path / "rx_subdev_spec") - .set_coercer(std::bind(&b200_impl::coerce_subdev_spec, this, std::placeholders::_1)) + .set_coercer( + std::bind(&b200_impl::coerce_subdev_spec, this, std::placeholders::_1)) .set(subdev_spec_t()) - .add_coerced_subscriber(std::bind(&b200_impl::update_subdev_spec, this, "rx", std::placeholders::_1)); + .add_coerced_subscriber( + std::bind(&b200_impl::update_subdev_spec, this, "rx", std::placeholders::_1)); _tree->create<subdev_spec_t>(mb_path / "tx_subdev_spec") - .set_coercer(std::bind(&b200_impl::coerce_subdev_spec, this, std::placeholders::_1)) + .set_coercer( + std::bind(&b200_impl::coerce_subdev_spec, this, std::placeholders::_1)) .set(subdev_spec_t()) - .add_coerced_subscriber(std::bind(&b200_impl::update_subdev_spec, this, "tx", std::placeholders::_1)); + .add_coerced_subscriber( + std::bind(&b200_impl::update_subdev_spec, this, "tx", std::placeholders::_1)); //////////////////////////////////////////////////////////////////// // setup radio control //////////////////////////////////////////////////////////////////// - UHD_LOGGER_INFO("B200") << "Initialize Radio control..." ; + UHD_LOGGER_INFO("B200") << "Initialize Radio control..."; const size_t num_radio_chains = ((_local_ctrl->peek32(RB32_CORE_STATUS) >> 8) & 0xff); UHD_ASSERT_THROW(num_radio_chains > 0); UHD_ASSERT_THROW(num_radio_chains <= 2); @@ -656,141 +692,162 @@ b200_impl::b200_impl(const uhd::device_addr_t& device_addr, usb_device_handle::s for (size_t i = 0; i < _radio_perifs.size(); i++) this->setup_radio(i); - //now test each radio module's connection to the codec interface - for (radio_perifs_t &perif : _radio_perifs) { + // now test each radio module's connection to the codec interface + for (radio_perifs_t& perif : _radio_perifs) { _codec_mgr->loopback_self_test( - [&perif](const uint32_t value){ + [&perif](const uint32_t value) { perif.ctrl->poke32(TOREG(SR_CODEC_IDLE), value); }, - [&perif](){ - return perif.ctrl->peek64(RB64_CODEC_READBACK); - } - ); + [&perif]() { return perif.ctrl->peek64(RB64_CODEC_READBACK); }); } - //register time now and pps onto available radio cores + // register time now and pps onto available radio cores _tree->create<time_spec_t>(mb_path / "time" / "now") .set_publisher(std::bind(&time_core_3000::get_time_now, _radio_perifs[0].time64)) - .add_coerced_subscriber(std::bind(&b200_impl::set_time, this, std::placeholders::_1)) + .add_coerced_subscriber( + std::bind(&b200_impl::set_time, this, std::placeholders::_1)) .set(0.0); - //re-sync the times when the tick rate changes + // re-sync the times when the tick rate changes _tree->access<double>(mb_path / "tick_rate") .add_coerced_subscriber(std::bind(&b200_impl::sync_times, this)); _tree->create<time_spec_t>(mb_path / "time" / "pps") - .set_publisher(std::bind(&time_core_3000::get_time_last_pps, _radio_perifs[0].time64)); - for(radio_perifs_t &perif: _radio_perifs) - { + .set_publisher( + std::bind(&time_core_3000::get_time_last_pps, _radio_perifs[0].time64)); + for (radio_perifs_t& perif : _radio_perifs) { _tree->access<time_spec_t>(mb_path / "time" / "pps") - .add_coerced_subscriber(std::bind(&time_core_3000::set_time_next_pps, perif.time64, std::placeholders::_1)); + .add_coerced_subscriber(std::bind( + &time_core_3000::set_time_next_pps, perif.time64, std::placeholders::_1)); } - //setup time source props + // setup time source props const std::vector<std::string> time_sources = - (_gpsdo_capable) ? - std::vector<std::string>{"none", "internal", "external", "gpsdo"} : - std::vector<std::string>{"none", "internal", "external"}; - _tree->create<std::vector<std::string> >(mb_path / "time_source" / "options") + (_gpsdo_capable) + ? std::vector<std::string>{"none", "internal", "external", "gpsdo"} + : std::vector<std::string>{"none", "internal", "external"}; + _tree->create<std::vector<std::string>>(mb_path / "time_source" / "options") .set(time_sources); _tree->create<std::string>(mb_path / "time_source" / "value") - .set_coercer(std::bind(&check_option_valid, "time source", time_sources, std::placeholders::_1)) - .add_coerced_subscriber(std::bind(&b200_impl::update_time_source, this, std::placeholders::_1)); - //setup reference source props + .set_coercer(std::bind( + &check_option_valid, "time source", time_sources, std::placeholders::_1)) + .add_coerced_subscriber( + std::bind(&b200_impl::update_time_source, this, std::placeholders::_1)); + // setup reference source props const std::vector<std::string> clock_sources = - (_gpsdo_capable) ? - std::vector<std::string>{"internal", "external", "gpsdo"} : - std::vector<std::string>{"internal", "external"}; - _tree->create<std::vector<std::string> >(mb_path / "clock_source" / "options") + (_gpsdo_capable) ? std::vector<std::string>{"internal", "external", "gpsdo"} + : std::vector<std::string>{"internal", "external"}; + _tree->create<std::vector<std::string>>(mb_path / "clock_source" / "options") .set(clock_sources); _tree->create<std::string>(mb_path / "clock_source" / "value") - .set_coercer(std::bind(&check_option_valid, "clock source", clock_sources, std::placeholders::_1)) - .add_coerced_subscriber(std::bind(&b200_impl::update_clock_source, this, std::placeholders::_1)); + .set_coercer(std::bind( + &check_option_valid, "clock source", clock_sources, std::placeholders::_1)) + .add_coerced_subscriber( + std::bind(&b200_impl::update_clock_source, this, std::placeholders::_1)); //////////////////////////////////////////////////////////////////// // front panel gpio //////////////////////////////////////////////////////////////////// - _radio_perifs[0].fp_gpio = gpio_atr_3000::make(_radio_perifs[0].ctrl, TOREG(SR_FP_GPIO), RB32_FP_GPIO); - for(const gpio_attr_map_t::value_type attr: gpio_attr_map) - { switch (attr.first){ - case usrp::gpio_atr::GPIO_SRC: - _tree->create<std::vector<std::string>>(mb_path / "gpio" / "FP0" / attr.second) - .set(std::vector<std::string>(32, usrp::gpio_atr::default_attr_value_map.at(attr.first))) - .add_coerced_subscriber([this](const std::vector<std::string>&){ - throw uhd::runtime_error("This device does not support setting the GPIO_SRC attribute."); - }); - break; - case usrp::gpio_atr::GPIO_CTRL: - case usrp::gpio_atr::GPIO_DDR: - _tree->create<std::vector<std::string>>(mb_path / "gpio" / "FP0" / attr.second) - .set(std::vector<std::string>(32, usrp::gpio_atr::default_attr_value_map.at(attr.first))) - .add_coerced_subscriber([this, attr](const std::vector<std::string> str_val){ - uint32_t val = 0; - for(size_t i = 0 ; i < str_val.size() ; i++){ - val += usrp::gpio_atr::gpio_attr_value_pair.at(attr.second).at(str_val[i])<<i; - } - _radio_perifs[0].fp_gpio->set_gpio_attr(attr.first, val); - }); - break; - case usrp::gpio_atr::GPIO_READBACK: - _tree->create<uint32_t>(mb_path / "gpio" / "FP0" / "READBACK") - .set_publisher(std::bind(&gpio_atr_3000::read_gpio, _radio_perifs[0].fp_gpio)); - break; - default: - _tree->create<uint32_t>(mb_path / "gpio" / "FP0" / attr.second) + _radio_perifs[0].fp_gpio = + gpio_atr_3000::make(_radio_perifs[0].ctrl, TOREG(SR_FP_GPIO), RB32_FP_GPIO); + for (const gpio_attr_map_t::value_type attr : gpio_attr_map) { + switch (attr.first) { + case usrp::gpio_atr::GPIO_SRC: + _tree + ->create<std::vector<std::string>>( + mb_path / "gpio" / "FP0" / attr.second) + .set(std::vector<std::string>( + 32, usrp::gpio_atr::default_attr_value_map.at(attr.first))) + .add_coerced_subscriber([this](const std::vector<std::string>&) { + throw uhd::runtime_error("This device does not support setting " + "the GPIO_SRC attribute."); + }); + break; + case usrp::gpio_atr::GPIO_CTRL: + case usrp::gpio_atr::GPIO_DDR: + _tree + ->create<std::vector<std::string>>( + mb_path / "gpio" / "FP0" / attr.second) + .set(std::vector<std::string>( + 32, usrp::gpio_atr::default_attr_value_map.at(attr.first))) + .add_coerced_subscriber([this, attr]( + const std::vector<std::string> str_val) { + uint32_t val = 0; + for (size_t i = 0; i < str_val.size(); i++) { + val += usrp::gpio_atr::gpio_attr_value_pair.at(attr.second) + .at(str_val[i]) + << i; + } + _radio_perifs[0].fp_gpio->set_gpio_attr(attr.first, val); + }); + break; + case usrp::gpio_atr::GPIO_READBACK: + _tree->create<uint32_t>(mb_path / "gpio" / "FP0" / "READBACK") + .set_publisher( + std::bind(&gpio_atr_3000::read_gpio, _radio_perifs[0].fp_gpio)); + break; + default: + _tree->create<uint32_t>(mb_path / "gpio" / "FP0" / attr.second) .set(0) - .add_coerced_subscriber(std::bind(&gpio_atr_3000::set_gpio_attr, _radio_perifs[0].fp_gpio, attr.first, std::placeholders::_1)); - } + .add_coerced_subscriber(std::bind(&gpio_atr_3000::set_gpio_attr, + _radio_perifs[0].fp_gpio, + attr.first, + std::placeholders::_1)); + } } //////////////////////////////////////////////////////////////////// // dboard eeproms but not really //////////////////////////////////////////////////////////////////// dboard_eeprom_t db_eeprom; - _tree->create<dboard_eeprom_t>(mb_path / "dboards" / "A" / "rx_eeprom").set(db_eeprom); - _tree->create<dboard_eeprom_t>(mb_path / "dboards" / "A" / "tx_eeprom").set(db_eeprom); - _tree->create<dboard_eeprom_t>(mb_path / "dboards" / "A" / "gdb_eeprom").set(db_eeprom); + _tree->create<dboard_eeprom_t>(mb_path / "dboards" / "A" / "rx_eeprom") + .set(db_eeprom); + _tree->create<dboard_eeprom_t>(mb_path / "dboards" / "A" / "tx_eeprom") + .set(db_eeprom); + _tree->create<dboard_eeprom_t>(mb_path / "dboards" / "A" / "gdb_eeprom") + .set(db_eeprom); //////////////////////////////////////////////////////////////////// // do some post-init tasks //////////////////////////////////////////////////////////////////// // Init the clock rate and the auto mcr appropriately if (not device_addr.has_key("master_clock_rate")) { - UHD_LOGGER_INFO("B200") << "Setting master clock rate selection to 'automatic'." ; + UHD_LOGGER_INFO("B200") << "Setting master clock rate selection to 'automatic'."; } // We can automatically choose a master clock rate, but not if the user specifies one - const double default_tick_rate = device_addr.cast<double>("master_clock_rate", ad936x_manager::DEFAULT_TICK_RATE); + const double default_tick_rate = + device_addr.cast<double>("master_clock_rate", ad936x_manager::DEFAULT_TICK_RATE); _tree->access<double>(mb_path / "tick_rate").set(default_tick_rate); - _tree->access<bool>(mb_path / "auto_tick_rate").set(not device_addr.has_key("master_clock_rate")); + _tree->access<bool>(mb_path / "auto_tick_rate") + .set(not device_addr.has_key("master_clock_rate")); - //subdev spec contains full width of selections + // subdev spec contains full width of selections subdev_spec_t rx_spec, tx_spec; - for(const std::string &fe: _tree->list(mb_path / "dboards" / "A" / "rx_frontends")) - { + for (const std::string& fe : + _tree->list(mb_path / "dboards" / "A" / "rx_frontends")) { rx_spec.push_back(subdev_spec_pair_t("A", fe)); } - for(const std::string &fe: _tree->list(mb_path / "dboards" / "A" / "tx_frontends")) - { + for (const std::string& fe : + _tree->list(mb_path / "dboards" / "A" / "tx_frontends")) { tx_spec.push_back(subdev_spec_pair_t("A", fe)); } _tree->access<subdev_spec_t>(mb_path / "rx_subdev_spec").set(rx_spec); _tree->access<subdev_spec_t>(mb_path / "tx_subdev_spec").set(tx_spec); - //init to internal clock and time source + // init to internal clock and time source _tree->access<std::string>(mb_path / "clock_source/value").set("internal"); _tree->access<std::string>(mb_path / "time_source/value").set("internal"); // Set the DSP chains to some safe value for (size_t i = 0; i < _radio_perifs.size(); i++) { - _radio_perifs[i].ddc->set_host_rate(default_tick_rate / ad936x_manager::DEFAULT_DECIM); - _radio_perifs[i].duc->set_host_rate(default_tick_rate / ad936x_manager::DEFAULT_INTERP); + _radio_perifs[i].ddc->set_host_rate( + default_tick_rate / ad936x_manager::DEFAULT_DECIM); + _radio_perifs[i].duc->set_host_rate( + default_tick_rate / ad936x_manager::DEFAULT_INTERP); } } b200_impl::~b200_impl(void) { - UHD_SAFE_CALL - ( - _async_task.reset(); - ) + UHD_SAFE_CALL(_async_task.reset();) } /*********************************************************************** @@ -798,7 +855,7 @@ b200_impl::~b200_impl(void) **********************************************************************/ void b200_impl::setup_radio(const size_t dspno) { - radio_perifs_t &perif = _radio_perifs[dspno]; + radio_perifs_t& perif = _radio_perifs[dspno]; const fs_path mb_path = "/mboards/0"; //////////////////////////////////////////////////////////////////// @@ -810,16 +867,15 @@ void b200_impl::setup_radio(const size_t dspno) // radio control //////////////////////////////////////////////////////////////////// perif.ctrl = radio_ctrl_core_3000::make( - false/*lilE*/, - _ctrl_transport, - zero_copy_if::sptr()/*null*/, - sid); + false /*lilE*/, _ctrl_transport, zero_copy_if::sptr() /*null*/, sid); perif.ctrl->hold_task(_async_task); - _async_task_data->radio_ctrl[dspno] = perif.ctrl; //weak + _async_task_data->radio_ctrl[dspno] = perif.ctrl; // weak _tree->access<time_spec_t>(mb_path / "time" / "cmd") - .add_coerced_subscriber(std::bind(&radio_ctrl_core_3000::set_time, perif.ctrl, std::placeholders::_1)); + .add_coerced_subscriber(std::bind( + &radio_ctrl_core_3000::set_time, perif.ctrl, std::placeholders::_1)); _tree->access<double>(mb_path / "tick_rate") - .add_coerced_subscriber(std::bind(&radio_ctrl_core_3000::set_tick_rate, perif.ctrl, std::placeholders::_1)); + .add_coerced_subscriber(std::bind( + &radio_ctrl_core_3000::set_tick_rate, perif.ctrl, std::placeholders::_1)); this->register_loopback_self_test(perif.ctrl); //////////////////////////////////////////////////////////////////// @@ -830,19 +886,17 @@ void b200_impl::setup_radio(const size_t dspno) // create rx dsp control objects perif.framer = rx_vita_core_3000::make(perif.ctrl, TOREG(SR_RX_CTRL)); perif.ddc = rx_dsp_core_3000::make(perif.ctrl, TOREG(SR_RX_DSP), true /*is_b200?*/); - perif.ddc->set_link_rate(10e9/8); //whatever + perif.ddc->set_link_rate(10e9 / 8); // whatever perif.ddc->set_mux(usrp::fe_connection_t(dspno == 1 ? "IbQb" : "IQ")); perif.ddc->set_freq(rx_dsp_core_3000::DEFAULT_CORDIC_FREQ); perif.deframer = tx_vita_core_3000::make_no_radio_buff(perif.ctrl, TOREG(SR_TX_CTRL)); - perif.duc = tx_dsp_core_3000::make(perif.ctrl, TOREG(SR_TX_DSP)); - perif.duc->set_link_rate(10e9/8); //whatever + perif.duc = tx_dsp_core_3000::make(perif.ctrl, TOREG(SR_TX_DSP)); + perif.duc->set_link_rate(10e9 / 8); // whatever perif.duc->set_freq(tx_dsp_core_3000::DEFAULT_CORDIC_FREQ); if (_enable_user_regs) { UHD_LOG_DEBUG("B200", "Enabling user settings registers"); - perif.user_settings = user_settings_core_3000::make(perif.ctrl, - TOREG(SR_USER_SR_BASE), - TOREG(SR_USER_RB_ADDR) - ); + perif.user_settings = user_settings_core_3000::make( + perif.ctrl, TOREG(SR_USER_SR_BASE), TOREG(SR_USER_RB_ADDR)); if (!perif.user_settings) { const std::string error_msg = "Failed to create user settings bus!"; UHD_LOG_ERROR("B200", error_msg); @@ -865,21 +919,30 @@ void b200_impl::setup_radio(const size_t dspno) perif.ddc->populate_subtree(_tree->subtree(rx_dsp_path)); _tree->create<bool>(rx_dsp_path / "rate" / "set").set(false); _tree->access<double>(rx_dsp_path / "rate" / "value") - .set_coercer(std::bind(&b200_impl::coerce_rx_samp_rate, this, perif.ddc, dspno, std::placeholders::_1)) - .add_coerced_subscriber([this, rx_dsp_path](const double){ + .set_coercer(std::bind(&b200_impl::coerce_rx_samp_rate, + this, + perif.ddc, + dspno, + std::placeholders::_1)) + .add_coerced_subscriber([this, rx_dsp_path](const double) { if (this->_tree) { - this->_tree->access<bool>(rx_dsp_path / "rate" / "set") - .set(true); + this->_tree->access<bool>(rx_dsp_path / "rate" / "set").set(true); } }) - .add_coerced_subscriber(std::bind(&b200_impl::update_rx_samp_rate, this, dspno, std::placeholders::_1)) - ; + .add_coerced_subscriber(std::bind( + &b200_impl::update_rx_samp_rate, this, dspno, std::placeholders::_1)); _tree->create<stream_cmd_t>(rx_dsp_path / "stream_cmd") - .add_coerced_subscriber(std::bind(&rx_vita_core_3000::issue_stream_command, perif.framer, std::placeholders::_1)); + .add_coerced_subscriber(std::bind(&rx_vita_core_3000::issue_stream_command, + perif.framer, + std::placeholders::_1)); _tree->access<double>(mb_path / "tick_rate") - .add_coerced_subscriber(std::bind(&rx_vita_core_3000::set_tick_rate, perif.framer, std::placeholders::_1)) - .add_coerced_subscriber(std::bind(&b200_impl::update_rx_dsp_tick_rate, this, std::placeholders::_1, perif.ddc, rx_dsp_path)) - ; + .add_coerced_subscriber(std::bind( + &rx_vita_core_3000::set_tick_rate, perif.framer, std::placeholders::_1)) + .add_coerced_subscriber(std::bind(&b200_impl::update_rx_dsp_tick_rate, + this, + std::placeholders::_1, + perif.ddc, + rx_dsp_path)); //////////////////////////////////////////////////////////////////// // create tx dsp control objects @@ -888,54 +951,58 @@ void b200_impl::setup_radio(const size_t dspno) perif.duc->populate_subtree(_tree->subtree(tx_dsp_path)); _tree->create<bool>(tx_dsp_path / "rate" / "set").set(false); _tree->access<double>(tx_dsp_path / "rate" / "value") - .set_coercer(std::bind(&b200_impl::coerce_tx_samp_rate, this, perif.duc, dspno, std::placeholders::_1)) - .add_coerced_subscriber([this, tx_dsp_path](const double){ + .set_coercer(std::bind(&b200_impl::coerce_tx_samp_rate, + this, + perif.duc, + dspno, + std::placeholders::_1)) + .add_coerced_subscriber([this, tx_dsp_path](const double) { if (this->_tree) { - this->_tree->access<bool>(tx_dsp_path / "rate" / "set") - .set(true); + this->_tree->access<bool>(tx_dsp_path / "rate" / "set").set(true); } }) - .add_coerced_subscriber(std::bind(&b200_impl::update_tx_samp_rate, this, dspno, std::placeholders::_1)) - ; + .add_coerced_subscriber(std::bind( + &b200_impl::update_tx_samp_rate, this, dspno, std::placeholders::_1)); _tree->access<double>(mb_path / "tick_rate") - .add_coerced_subscriber(std::bind(&b200_impl::update_tx_dsp_tick_rate, this, std::placeholders::_1, perif.duc, tx_dsp_path)) - ; + .add_coerced_subscriber(std::bind(&b200_impl::update_tx_dsp_tick_rate, + this, + std::placeholders::_1, + perif.duc, + tx_dsp_path)); //////////////////////////////////////////////////////////////////// // create RF frontend interfacing //////////////////////////////////////////////////////////////////// for (direction_t dir : std::vector<direction_t>{RX_DIRECTION, TX_DIRECTION}) { - const std::string x = (dir == RX_DIRECTION) ? "rx" : "tx"; - const std::string key = std::string(((dir == RX_DIRECTION) ? "RX" : "TX")) + std::string(((dspno == _fe1) ? "1" : "2")); - const fs_path rf_fe_path - = mb_path / "dboards" / "A" / (x + "_frontends") / (dspno ? "B" : "A"); + const std::string x = (dir == RX_DIRECTION) ? "rx" : "tx"; + const std::string key = std::string(((dir == RX_DIRECTION) ? "RX" : "TX")) + + std::string(((dspno == _fe1) ? "1" : "2")); + const fs_path rf_fe_path = + mb_path / "dboards" / "A" / (x + "_frontends") / (dspno ? "B" : "A"); // This will connect all the AD936x-specific items - _codec_mgr->populate_frontend_subtree( - _tree->subtree(rf_fe_path), key, dir - ); + _codec_mgr->populate_frontend_subtree(_tree->subtree(rf_fe_path), key, dir); // Now connect all the b200_impl-specific items _tree->create<sensor_value_t>(rf_fe_path / "sensors" / "lo_locked") - .set_publisher(std::bind(&b200_impl::get_fe_pll_locked, this, dir == TX_DIRECTION)) - ; + .set_publisher( + std::bind(&b200_impl::get_fe_pll_locked, this, dir == TX_DIRECTION)); _tree->access<double>(rf_fe_path / "freq" / "value") - .add_coerced_subscriber(std::bind(&b200_impl::update_bandsel, this, key, std::placeholders::_1)) - ; - if (dir == RX_DIRECTION) - { + .add_coerced_subscriber( + std::bind(&b200_impl::update_bandsel, this, key, std::placeholders::_1)); + if (dir == RX_DIRECTION) { static const std::vector<std::string> ants{"TX/RX", "RX2"}; - _tree->create<std::vector<std::string> >(rf_fe_path / "antenna" / "options").set(ants); + _tree->create<std::vector<std::string>>(rf_fe_path / "antenna" / "options") + .set(ants); _tree->create<std::string>(rf_fe_path / "antenna" / "value") - .add_coerced_subscriber(std::bind(&b200_impl::update_antenna_sel, this, dspno, std::placeholders::_1)) - .set("RX2") - ; + .add_coerced_subscriber(std::bind( + &b200_impl::update_antenna_sel, this, dspno, std::placeholders::_1)) + .set("RX2"); - } - else if (dir == TX_DIRECTION) - { + } else if (dir == TX_DIRECTION) { static const std::vector<std::string> ants(1, "TX/RX"); - _tree->create<std::vector<std::string> >(rf_fe_path / "antenna" / "options").set(ants); + _tree->create<std::vector<std::string>>(rf_fe_path / "antenna" / "options") + .set(ants); _tree->create<std::string>(rf_fe_path / "antenna" / "value").set("TX/RX"); } @@ -955,75 +1022,71 @@ void b200_impl::register_loopback_self_test(wb_iface::sptr iface) bool test_fail = false; UHD_LOGGER_INFO("B200") << "Performing register loopback test... "; size_t hash = size_t(time(NULL)); - for (size_t i = 0; i < 100; i++) - { + for (size_t i = 0; i < 100; i++) { boost::hash_combine(hash, i); iface->poke32(TOREG(SR_TEST), uint32_t(hash)); test_fail = iface->peek32(RB32_TEST) != uint32_t(hash); - if (test_fail) break; //exit loop on any failure + if (test_fail) + break; // exit loop on any failure } - UHD_LOGGER_INFO("B200") << "Register loopback test " << ((test_fail)? "failed" : "passed") ; + UHD_LOGGER_INFO("B200") << "Register loopback test " + << ((test_fail) ? "failed" : "passed"); } /*********************************************************************** * Sample and tick rate comprehension below **********************************************************************/ -void b200_impl::enforce_tick_rate_limits(size_t chan_count, double tick_rate, const std::string &direction /*= ""*/) +void b200_impl::enforce_tick_rate_limits( + size_t chan_count, double tick_rate, const std::string& direction /*= ""*/) { const size_t max_chans = 2; - if (chan_count > max_chans) - { + if (chan_count > max_chans) { throw uhd::value_error(boost::str( - boost::format("cannot not setup %d %s channels (maximum is %d)") - % chan_count - % (direction.empty() ? "data" : direction) - % max_chans - )); - } - else - { - const double max_tick_rate = ad9361_device_t::AD9361_MAX_CLOCK_RATE / ((chan_count <= 1) ? 1 : 2); - if (tick_rate - max_tick_rate >= 1.0) - { + boost::format("cannot not setup %d %s channels (maximum is %d)") % chan_count + % (direction.empty() ? "data" : direction) % max_chans)); + } else { + const double max_tick_rate = + ad9361_device_t::AD9361_MAX_CLOCK_RATE / ((chan_count <= 1) ? 1 : 2); + if (tick_rate - max_tick_rate >= 1.0) { throw uhd::value_error(boost::str( - boost::format("current master clock rate (%.6f MHz) exceeds maximum possible master clock rate (%.6f MHz) when using %d %s channels") - % (tick_rate/1e6) - % (max_tick_rate/1e6) - % chan_count - % (direction.empty() ? "data" : direction) - )); + boost::format( + "current master clock rate (%.6f MHz) exceeds maximum possible " + "master clock rate (%.6f MHz) when using %d %s channels") + % (tick_rate / 1e6) % (max_tick_rate / 1e6) % chan_count + % (direction.empty() ? "data" : direction))); } - const double min_tick_rate = ad9361_device_t::AD9361_MIN_CLOCK_RATE / ((chan_count <= 1) ? 1 : 2); - if (min_tick_rate - tick_rate >= 1.0) - { + const double min_tick_rate = + ad9361_device_t::AD9361_MIN_CLOCK_RATE / ((chan_count <= 1) ? 1 : 2); + if (min_tick_rate - tick_rate >= 1.0) { throw uhd::value_error(boost::str( - boost::format("current master clock rate (%.6f MHz) is less than minimum possible master clock rate (%.6f MHz) when using %d %s channels") - % (tick_rate/1e6) - % (min_tick_rate/1e6) - % chan_count - % (direction.empty() ? "data" : direction) - )); + boost::format( + "current master clock rate (%.6f MHz) is less than minimum possible " + "master clock rate (%.6f MHz) when using %d %s channels") + % (tick_rate / 1e6) % (min_tick_rate / 1e6) % chan_count + % (direction.empty() ? "data" : direction))); } } } double b200_impl::set_tick_rate(const double new_tick_rate) { - UHD_LOGGER_INFO("B200") << (boost::format("Asking for clock rate %.6f MHz... ") % (new_tick_rate/1e6)) << std::flush; - check_tick_rate_with_current_streamers(new_tick_rate); // Defined in b200_io_impl.cpp + UHD_LOGGER_INFO("B200") << (boost::format("Asking for clock rate %.6f MHz... ") + % (new_tick_rate / 1e6)) + << std::flush; + check_tick_rate_with_current_streamers(new_tick_rate); // Defined in b200_io_impl.cpp // Make sure the clock rate is actually changed before doing // the full Monty of setting regs and loopback tests etc. if (std::abs(new_tick_rate - _tick_rate) < 1.0) { - UHD_LOGGER_INFO("B200") << "OK" ; + UHD_LOGGER_INFO("B200") << "OK"; return _tick_rate; } _tick_rate = _codec_ctrl->set_clock_rate(new_tick_rate); - UHD_LOGGER_INFO("B200") << (boost::format("Actually got clock rate %.6f MHz.") % (_tick_rate/1e6)) ; + UHD_LOGGER_INFO("B200") << (boost::format("Actually got clock rate %.6f MHz.") + % (_tick_rate / 1e6)); - for(radio_perifs_t &perif: _radio_perifs) - { + for (radio_perifs_t& perif : _radio_perifs) { perif.time64->set_tick_rate(_tick_rate); perif.time64->self_test(); } @@ -1036,76 +1099,72 @@ double b200_impl::set_tick_rate(const double new_tick_rate) void b200_impl::check_fw_compat(void) { - uint16_t compat_num = _iface->get_compat_num(); - uint32_t compat_major = (uint32_t) (compat_num >> 8); - uint32_t compat_minor = (uint32_t) (compat_num & 0xFF); - - if (compat_major != B200_FW_COMPAT_NUM_MAJOR){ - throw uhd::runtime_error(str(boost::format( - "Expected firmware compatibility number %d.%d, but got %d.%d:\n" - "The firmware build is not compatible with the host code build.\n" - "%s" - ) % int(B200_FW_COMPAT_NUM_MAJOR) % int(B200_FW_COMPAT_NUM_MINOR) - % compat_major % compat_minor % print_utility_error("uhd_images_downloader.py"))); + uint16_t compat_num = _iface->get_compat_num(); + uint32_t compat_major = (uint32_t)(compat_num >> 8); + uint32_t compat_minor = (uint32_t)(compat_num & 0xFF); + + if (compat_major != B200_FW_COMPAT_NUM_MAJOR) { + throw uhd::runtime_error(str( + boost::format( + "Expected firmware compatibility number %d.%d, but got %d.%d:\n" + "The firmware build is not compatible with the host code build.\n" + "%s") + % int(B200_FW_COMPAT_NUM_MAJOR) % int(B200_FW_COMPAT_NUM_MINOR) % compat_major + % compat_minor % print_utility_error("uhd_images_downloader.py"))); } - _tree->create<std::string>("/mboards/0/fw_version").set(str(boost::format("%u.%u") - % compat_major % compat_minor)); + _tree->create<std::string>("/mboards/0/fw_version") + .set(str(boost::format("%u.%u") % compat_major % compat_minor)); } void b200_impl::check_fpga_compat(void) { - const uint64_t compat = _local_ctrl->peek64(0); - const uint32_t signature = uint32_t(compat >> 32); + const uint64_t compat = _local_ctrl->peek64(0); + const uint32_t signature = uint32_t(compat >> 32); const uint16_t compat_major = uint16_t(compat >> 16); const uint16_t compat_minor = uint16_t(compat & 0xffff); - if (signature != 0xACE0BA5E) throw uhd::runtime_error( - "b200::check_fpga_compat signature register readback failed"); - - const uint16_t expected = ((_product == B200MINI or _product == B205MINI) ? B205_FPGA_COMPAT_NUM : B200_FPGA_COMPAT_NUM); - if (compat_major != expected) - { - throw uhd::runtime_error(str(boost::format( - "Expected FPGA compatibility number %d, but got %d:\n" - "The FPGA build is not compatible with the host code build.\n" - "%s" - ) % int(expected) % compat_major % print_utility_error("uhd_images_downloader.py"))); + if (signature != 0xACE0BA5E) + throw uhd::runtime_error( + "b200::check_fpga_compat signature register readback failed"); + + const uint16_t expected = ((_product == B200MINI or _product == B205MINI) + ? B205_FPGA_COMPAT_NUM + : B200_FPGA_COMPAT_NUM); + if (compat_major != expected) { + throw uhd::runtime_error(str( + boost::format("Expected FPGA compatibility number %d, but got %d:\n" + "The FPGA build is not compatible with the host code build.\n" + "%s") + % int(expected) % compat_major + % print_utility_error("uhd_images_downloader.py"))); } - _tree->create<std::string>("/mboards/0/fpga_version").set(str(boost::format("%u.%u") - % compat_major % compat_minor)); + _tree->create<std::string>("/mboards/0/fpga_version") + .set(str(boost::format("%u.%u") % compat_major % compat_minor)); } /*********************************************************************** * Reference time and clock **********************************************************************/ -void b200_impl::update_clock_source(const std::string &source) +void b200_impl::update_clock_source(const std::string& source) { // For B205, ref_sel selects whether or not to lock to the external clock source - if (_product == B200MINI or _product == B205MINI) - { - if (source == "external" and _time_source == EXTERNAL) - { - throw uhd::value_error("external reference cannot be both a clock source and a time source"); + if (_product == B200MINI or _product == B205MINI) { + if (source == "external" and _time_source == EXTERNAL) { + throw uhd::value_error( + "external reference cannot be both a clock source and a time source"); } - if (source == "internal") - { - if (_gpio_state.ref_sel != 0) - { + if (source == "internal") { + if (_gpio_state.ref_sel != 0) { _gpio_state.ref_sel = 0; this->update_gpio_state(); } - } - else if (source == "external") - { - if (_gpio_state.ref_sel != 1) - { + } else if (source == "external") { + if (_gpio_state.ref_sel != 1) { _gpio_state.ref_sel = 1; this->update_gpio_state(); } - } - else - { + } else { throw uhd::key_error("update_clock_source: unknown source: " + source); } return; @@ -1113,42 +1172,35 @@ void b200_impl::update_clock_source(const std::string &source) // For all other devices, ref_sel selects the external or gpsdo clock source // and the ADF4001 selects whether to lock to it or not - if (source == "internal") - { + if (source == "internal") { _adf4001_iface->set_lock_to_ext_ref(false); - } - else if (source == "external") - { - if (_gpio_state.ref_sel != 0) - { + } else if (source == "external") { + if (_gpio_state.ref_sel != 0) { _gpio_state.ref_sel = 0; this->update_gpio_state(); } _adf4001_iface->set_lock_to_ext_ref(true); - } - else if (source == "gpsdo") - { + } else if (source == "gpsdo") { if (not _gps or not _gps->gps_detected()) { - throw uhd::key_error("update_clock_source: gpsdo selected, but no gpsdo detected!"); + throw uhd::key_error( + "update_clock_source: gpsdo selected, but no gpsdo detected!"); } - if (_gpio_state.ref_sel != 1) - { + if (_gpio_state.ref_sel != 1) { _gpio_state.ref_sel = 1; this->update_gpio_state(); } _adf4001_iface->set_lock_to_ext_ref(true); - } - else - { + } else { throw uhd::key_error("update_clock_source: unknown source: " + source); } } -void b200_impl::update_time_source(const std::string &source) +void b200_impl::update_time_source(const std::string& source) { - if ((_product == B200MINI or _product == B205MINI) and source == "external" and _gpio_state.ref_sel == 1) - { - throw uhd::value_error("external reference cannot be both a time source and a clock source"); + if ((_product == B200MINI or _product == B205MINI) and source == "external" + and _gpio_state.ref_sel == 1) { + throw uhd::value_error( + "external reference cannot be both a time source and a clock source"); } // We assume source is valid for this device (if it's gone through @@ -1164,8 +1216,7 @@ void b200_impl::update_time_source(const std::string &source) value = GPSDO; else throw uhd::key_error("update_time_source: unknown source: " + source); - if (_time_source != value) - { + if (_time_source != value) { _local_ctrl->poke32(TOREG(SR_CORE_SYNC), value); _time_source = value; } @@ -1173,7 +1224,7 @@ void b200_impl::update_time_source(const std::string &source) void b200_impl::set_time(const uhd::time_spec_t& t) { - for(radio_perifs_t &perif: _radio_perifs) + for (radio_perifs_t& perif : _radio_perifs) perif.time64->set_time_sync(t); _local_ctrl->poke32(TOREG(SR_CORE_SYNC), 1 << 2 | uint32_t(_time_source)); _local_ctrl->poke32(TOREG(SR_CORE_SYNC), _time_source); @@ -1195,27 +1246,27 @@ void b200_impl::update_bandsel(const std::string& which, double freq) return; } - if(which[0] == 'R') { - if(freq < 2.2e9) { + if (which[0] == 'R') { + if (freq < 2.2e9) { _gpio_state.rx_bandsel_a = 0; _gpio_state.rx_bandsel_b = 0; _gpio_state.rx_bandsel_c = 1; - } else if((freq >= 2.2e9) && (freq < 4e9)) { + } else if ((freq >= 2.2e9) && (freq < 4e9)) { _gpio_state.rx_bandsel_a = 0; _gpio_state.rx_bandsel_b = 1; _gpio_state.rx_bandsel_c = 0; - } else if((freq >= 4e9) && (freq <= 6e9)) { + } else if ((freq >= 4e9) && (freq <= 6e9)) { _gpio_state.rx_bandsel_a = 1; _gpio_state.rx_bandsel_b = 0; _gpio_state.rx_bandsel_c = 0; } else { UHD_THROW_INVALID_CODE_PATH(); } - } else if(which[0] == 'T') { - if(freq < 2.5e9) { + } else if (which[0] == 'T') { + if (freq < 2.5e9) { _gpio_state.tx_bandsel_a = 0; _gpio_state.tx_bandsel_b = 1; - } else if((freq >= 2.5e9) && (freq <= 6e9)) { + } else if ((freq >= 2.5e9) && (freq <= 6e9)) { _gpio_state.tx_bandsel_a = 1; _gpio_state.tx_bandsel_b = 0; } else { @@ -1238,53 +1289,54 @@ void b200_impl::reset_codec() void b200_impl::update_gpio_state(void) { - const uint32_t misc_word = 0 - | (_gpio_state.swap_atr << 8) - | (_gpio_state.tx_bandsel_a << 7) - | (_gpio_state.tx_bandsel_b << 6) - | (_gpio_state.rx_bandsel_a << 5) - | (_gpio_state.rx_bandsel_b << 4) - | (_gpio_state.rx_bandsel_c << 3) - | (_gpio_state.codec_arst << 2) - | (_gpio_state.mimo << 1) - | (_gpio_state.ref_sel << 0) - ; + const uint32_t misc_word = + 0 | (_gpio_state.swap_atr << 8) | (_gpio_state.tx_bandsel_a << 7) + | (_gpio_state.tx_bandsel_b << 6) | (_gpio_state.rx_bandsel_a << 5) + | (_gpio_state.rx_bandsel_b << 4) | (_gpio_state.rx_bandsel_c << 3) + | (_gpio_state.codec_arst << 2) | (_gpio_state.mimo << 1) + | (_gpio_state.ref_sel << 0); _local_ctrl->poke32(TOREG(SR_CORE_MISC), misc_word); } void b200_impl::update_atrs(void) { - if (_radio_perifs.size() > _fe1 and _radio_perifs[_fe1].atr) - { - radio_perifs_t &perif = _radio_perifs[_fe1]; - const bool enb_rx = bool(perif.rx_streamer.lock()); - const bool enb_tx = bool(perif.tx_streamer.lock()); - const bool is_rx2 = perif.ant_rx2; - const uint32_t rxonly = (enb_rx)? ((is_rx2)? STATE_RX1_RX2 : STATE_RX1_TXRX) : STATE_OFF; - const uint32_t txonly = (enb_tx)? (STATE_TX1_TXRX) : STATE_OFF; - uint32_t fd = STATE_OFF; - if (enb_rx and enb_tx) fd = STATE_FDX1_TXRX; - if (enb_rx and not enb_tx) fd = rxonly; - if (not enb_rx and enb_tx) fd = txonly; + if (_radio_perifs.size() > _fe1 and _radio_perifs[_fe1].atr) { + radio_perifs_t& perif = _radio_perifs[_fe1]; + const bool enb_rx = bool(perif.rx_streamer.lock()); + const bool enb_tx = bool(perif.tx_streamer.lock()); + const bool is_rx2 = perif.ant_rx2; + const uint32_t rxonly = (enb_rx) ? ((is_rx2) ? STATE_RX1_RX2 : STATE_RX1_TXRX) + : STATE_OFF; + const uint32_t txonly = (enb_tx) ? (STATE_TX1_TXRX) : STATE_OFF; + uint32_t fd = STATE_OFF; + if (enb_rx and enb_tx) + fd = STATE_FDX1_TXRX; + if (enb_rx and not enb_tx) + fd = rxonly; + if (not enb_rx and enb_tx) + fd = txonly; gpio_atr_3000::sptr atr = perif.atr; atr->set_atr_reg(ATR_REG_IDLE, STATE_OFF); atr->set_atr_reg(ATR_REG_RX_ONLY, rxonly); atr->set_atr_reg(ATR_REG_TX_ONLY, txonly); atr->set_atr_reg(ATR_REG_FULL_DUPLEX, fd); } - if (_radio_perifs.size() > _fe2 and _radio_perifs[_fe2].atr) - { - radio_perifs_t &perif = _radio_perifs[_fe2]; - const bool enb_rx = bool(perif.rx_streamer.lock()); - const bool enb_tx = bool(perif.tx_streamer.lock()); - const bool is_rx2 = perif.ant_rx2; - const uint32_t rxonly = (enb_rx)? ((is_rx2)? STATE_RX2_RX2 : STATE_RX2_TXRX) : STATE_OFF; - const uint32_t txonly = (enb_tx)? (STATE_TX2_TXRX) : STATE_OFF; - uint32_t fd = STATE_OFF; - if (enb_rx and enb_tx) fd = STATE_FDX2_TXRX; - if (enb_rx and not enb_tx) fd = rxonly; - if (not enb_rx and enb_tx) fd = txonly; + if (_radio_perifs.size() > _fe2 and _radio_perifs[_fe2].atr) { + radio_perifs_t& perif = _radio_perifs[_fe2]; + const bool enb_rx = bool(perif.rx_streamer.lock()); + const bool enb_tx = bool(perif.tx_streamer.lock()); + const bool is_rx2 = perif.ant_rx2; + const uint32_t rxonly = (enb_rx) ? ((is_rx2) ? STATE_RX2_RX2 : STATE_RX2_TXRX) + : STATE_OFF; + const uint32_t txonly = (enb_tx) ? (STATE_TX2_TXRX) : STATE_OFF; + uint32_t fd = STATE_OFF; + if (enb_rx and enb_tx) + fd = STATE_FDX2_TXRX; + if (enb_rx and not enb_tx) + fd = rxonly; + if (not enb_rx and enb_tx) + fd = txonly; gpio_atr_3000::sptr atr = perif.atr; atr->set_atr_reg(ATR_REG_IDLE, STATE_OFF); atr->set_atr_reg(ATR_REG_RX_ONLY, rxonly); @@ -1293,38 +1345,44 @@ void b200_impl::update_atrs(void) } } -void b200_impl::update_antenna_sel(const size_t which, const std::string &ant) +void b200_impl::update_antenna_sel(const size_t which, const std::string& ant) { - if (ant != "TX/RX" and ant != "RX2") throw uhd::value_error("b200: unknown RX antenna option: " + ant); + if (ant != "TX/RX" and ant != "RX2") + throw uhd::value_error("b200: unknown RX antenna option: " + ant); _radio_perifs[which].ant_rx2 = (ant == "RX2"); this->update_atrs(); } void b200_impl::update_enables(void) { - //extract settings from state variables - const bool enb_tx1 = (_radio_perifs.size() > _fe1) and bool(_radio_perifs[_fe1].tx_streamer.lock()); - const bool enb_rx1 = (_radio_perifs.size() > _fe1) and bool(_radio_perifs[_fe1].rx_streamer.lock()); - const bool enb_tx2 = (_radio_perifs.size() > _fe2) and bool(_radio_perifs[_fe2].tx_streamer.lock()); - const bool enb_rx2 = (_radio_perifs.size() > _fe2) and bool(_radio_perifs[_fe2].rx_streamer.lock()); - const size_t num_rx = (enb_rx1?1:0) + (enb_rx2?1:0); - const size_t num_tx = (enb_tx1?1:0) + (enb_tx2?1:0); - const bool mimo = num_rx == 2 or num_tx == 2; - - if ((num_rx + num_tx) == 3) - { - throw uhd::runtime_error("b200: 2 RX 1 TX and 1 RX 2 TX configurations not possible"); + // extract settings from state variables + const bool enb_tx1 = (_radio_perifs.size() > _fe1) + and bool(_radio_perifs[_fe1].tx_streamer.lock()); + const bool enb_rx1 = (_radio_perifs.size() > _fe1) + and bool(_radio_perifs[_fe1].rx_streamer.lock()); + const bool enb_tx2 = (_radio_perifs.size() > _fe2) + and bool(_radio_perifs[_fe2].tx_streamer.lock()); + const bool enb_rx2 = (_radio_perifs.size() > _fe2) + and bool(_radio_perifs[_fe2].rx_streamer.lock()); + const size_t num_rx = (enb_rx1 ? 1 : 0) + (enb_rx2 ? 1 : 0); + const size_t num_tx = (enb_tx1 ? 1 : 0) + (enb_tx2 ? 1 : 0); + const bool mimo = num_rx == 2 or num_tx == 2; + + if ((num_rx + num_tx) == 3) { + throw uhd::runtime_error( + "b200: 2 RX 1 TX and 1 RX 2 TX configurations not possible"); } - //setup the active chains in the codec + // setup the active chains in the codec _codec_ctrl->set_active_chains(enb_tx1, enb_tx2, enb_rx1, enb_rx2); - if ((num_rx + num_tx) == 0) _codec_ctrl->set_active_chains(true, false, true, false); //enable something + if ((num_rx + num_tx) == 0) + _codec_ctrl->set_active_chains(true, false, true, false); // enable something - //figure out if mimo is enabled based on new state - _gpio_state.mimo = (mimo)? 1 : 0; + // figure out if mimo is enabled based on new state + _gpio_state.mimo = (mimo) ? 1 : 0; update_gpio_state(); - //atrs change based on enables + // atrs change based on enables this->update_atrs(); } |