uhd::soft_regmap_t Class Reference

#include <uhd/utils/soft_register.hpp>

Inheritance diagram for uhd::soft_regmap_t:

Public Member Functions
	soft_regmap_t (const std::string &name)
	~soft_regmap_t () override
UHD_INLINE const std::string &	get_name () const override
void	initialize (wb_iface &iface, bool sync=false)
void	flush ()
void	refresh ()
soft_register_base &	lookup (const std::string &name) const override
std::vector< std::string >	enumerate () const override
Public Member Functions inherited from uhd::soft_regmap_accessor_t
virtual	~soft_regmap_accessor_t ()
virtual soft_register_base &	lookup (const std::string &path) const =0
virtual std::vector< std::string >	enumerate () const =0
virtual const std::string &	get_name () const =0

Protected Types
enum	visibility_t { PUBLIC , PRIVATE }

Protected Member Functions
UHD_INLINE void	add_to_map (soft_register_base &reg, const std::string &name, const visibility_t visible=PRIVATE)

Additional Inherited Members
Public Types inherited from uhd::soft_regmap_accessor_t
typedef std::shared_ptr< soft_regmap_accessor_t >	sptr

Detailed Description

A regmap is a collection of registers that share the same bus (control iface). A regmap must have an identifier. A regmap must manage storage for each register. The recommended way to use a regmap is to define individual registers within the scope of the regmap and instantiate them in the ragmap. Soft register object that holds offset, soft-copy and the control iface. Methods give convenient field-level access to soft-copy and the ability to do read-modify-write operations.

Member Enumeration Documentation

visibility_t

enum uhd::soft_regmap_t::visibility_t

protected

Enumerator
PUBLIC
PRIVATE

Constructor & Destructor Documentation

soft_regmap_t()

uhd::soft_regmap_t::soft_regmap_t ( const std::string &  name )

inline

~soft_regmap_t()

uhd::soft_regmap_t::~soft_regmap_t ( )

inlineoverride

Member Function Documentation

add_to_map()

UHD_INLINE void uhd::soft_regmap_t::add_to_map ( soft_register_base &  reg, const std::string &  name, const visibility_t  visible = PRIVATE  )

inlineprotected

Add a register to this map with an identifier "name" and visibility

enumerate()

std::vector< std::string > uhd::soft_regmap_t::enumerate ( ) const

inlineoverridevirtual

Enumerate all the registers in this map. Return fully qualified paths.

Implements uhd::soft_regmap_accessor_t.

flush()

void uhd::soft_regmap_t::flush ( )

inline

Flush all registers to hardware. The order of writing is the same as the order in which registers were added to the map.

get_name()

UHD_INLINE const std::string & uhd::soft_regmap_t::get_name ( ) const

inlineoverridevirtual

Get the name of this register map

Implements uhd::soft_regmap_accessor_t.

initialize()

void uhd::soft_regmap_t::initialize ( wb_iface &  iface, bool  sync = false  )

inline

Initialize all registers in this register map using a bus. Optionally synchronize the register with hardware. The order of initialization is the same as the order in which registers were added to the map.

lookup()

soft_register_base & uhd::soft_regmap_t::lookup ( const std::string &  name ) const

inlineoverridevirtual

Lookup a register object by name. If a register with "name" is not found, runtime_error is thrown

Implements uhd::soft_regmap_accessor_t.

refresh()

void uhd::soft_regmap_t::refresh ( )

inline

Refresh all register soft-copies from hardware. The order of reading is the same as the order in which registers were added to the map.

---

The documentation for this class was generated from the following file:

• soft_register.hpp