UVM Register Base Classes

Construct a register base class, providing a name and a parent.

Match the UVM engine

Given a name, return the field info structure for that field.

Given a tag name, return ALL the fields for this register that have that tag.

Given a name, return 1, if this is a name of a field in this register.  Return 0 otherwise.

Given a name, return 1, if any field has this tag in this register.  Return 0 otherwise.

Given a field name, add the tag to the list of tags for this field.

Define a new field.  Provide the name, the reset value and the access policy.  See also: set_access_policy_field_by_name()

Where “access” is one of

”RW” Read-Write “RO” Read-only “WO” Write-only “W1C”, “RW1C” Write-1-to-Clear “W0S”, “RW0S” Write-0-to-Set “R2C”, “RC”, “RCW” Clear-on-Read “R2S”, “RS”, “RSW” Set-on-Read

Like has_field, but spit out an error if not defined.

Dump the field info structure for all the fields.  Most useful in debug.

Provide a current value, passed in as ‘x’.  Provide a new value, passed in as ‘v’.  Provide the name of the field in ‘name’.  The FULL bit vector value, ‘x’, will be treated like a packed struct, and then the named field within the bit vector (packed struct) will be assigned the new value, ‘v’.  Note - Returns the WHOLE Bit-vector, not simply the field value.

Provide a current value, passed in as ‘x’.  Provide the name of the field in ‘name’.  The FULL bit vector value, ‘x’, will be treated like a packed struct, and then the named field within the bit vector (packed struct) will be returned.  Note - Returns the FIELD value only (not the whole Bit-vector).

Check to make sure the field as defined can hold the defined reset value.

Return the full pathname of the register. ie. top.i2.apb.d2.reg3

Return the short name for the register, like “REG1”. virtual function string get_name(); return register_name; endfunction

Set the short name for the register, like “REG1”.  This function is mostly used when using the factory, since the factory create() call will call the register constructor as new() - since a register is a transaction.  Overrides uvm_object::set_name()

Should be implemented in the extended class.  Return a pretty string representing the register.

DEPRECATED: Just use get_parent().

Return the uvm_named_object that “contains” this register.  This is similar to ‘parent’, but not strictly enforced.

Return the number of bits this register contains.

Set the data value as a raw 32 bit vector.

Return the data value as a raw 32 bit vector.

Set the data value as a raw 64 bit vector.

Return the data value as a raw 64 bit vector.

Calls read_data32() in the extended class.

Calls write_data32() in the extended class.

Calls read_data64() in the extended class.

Calls write_data64() in the extended class.

DEPRECATED.  Use poke_data32();

DEPRECATED.  Use peek_data32();

DEPRECATED.  Use poke_data64();

DEPRECATED.  Use peek_data64();

Must be implemented in the extended class.

Must be implemented in the extended class.

Must be implemented in the extended class.

Must be implemented in the extended class.

Return the data value as a list of bytes.

Return the data value as a list of bytes.  Note : Return value is through the parameter list.

Return the data value as a list of bytes.  Note : Return value is through the parameter list.

Should be implemented in the extended class.  The implementation will usually call the covergroup sample function.

Should be implemented in the extended class.  Causes the register to take the resetValue.

Setup the special mirroring code.  This assignment causes peek(), poke() and sample() to be re-directed in this register to the register pointed to by ‘s’.  See peek(), poke() and sample() implementations below.

Unlock the lock, by “putting back” n keys. put() can be passed an argument, n for the number of keys, but usually no argument is passed, and the default of 1 is used. put() is a function and cannot block.  The lock will have the number of keys added back to it.

Lock the lock, by “getting” n keys.  If there are NOT enough keys available, then this task will not return (it blocks) until there are enough keys available. get() can be passed an argument, n for the number of keys, but usually no argument is passed, and the default of 1 is used.

Like get() above, but if the lock would fail (block), then a zero is returned instead of actually blocking.  In the failure case, no keys are “gotten” and a 0 is returned.  If there are enough keys - if the get() would not block, n keys will be gotten and a 1 returned. try_get() can be passed an argument, n for the number of keys, but usually no argument is passed, and the default of 1 is used.

Return the number of bits in this type.

Convenience function that makes sure the width you supply (n) will fit into the space of the data.

This code is NOT implemented in a library base class.  This code is implemented in the user’s extended class.  This implementation is here in case the user did not implement the by name code, and will never use it.  In that case, this function will never be called.  If it ever is called, then it is an error.

Given a mask name and a field name, set the field to value v in that mask.

Given an “access policy”, interrpret it into the proper mask settings.

User callable function to return the value of a field.

User callable function to set the value of a field.

User callable function to return the value of a field.

User callable function to set the value of a field.

User callable function to reset a field by name

User callable function to reset a field which has the given tag name.

Check to make sure the register can return at least 32 bits.  Then return 32 bits.  Returns the RAW value.

First check to make sure that there are at least 32 bits, then call poke() to assign data.

Check to make sure the register can return at least 64 bits.  Then return 64 bits.  Returns the RAW value.

First check to make sure that there are at least 64 bits, then call poke() to assign data.

Returns the masked value.  Not the RAW value.

Writes the masked value.  Not the RAW value.

Returns the masked value.  Not the RAW value.

Writes the masked value.  Not the RAW value.

This function is called when a “READ” transaction is detected.  When this function executes, it first checks the data passed in with the current value in the shadow.  If the data matches, then the new data is written to the shadow, just in case there are side-effects or other field behavior.  This write to the shadow is updating the shadow with the currently read value from the real register.  After the compare, if the data didn’t match, then an error message is issued.  Before the routine returns, it issues a “register read()” call, which is a trick to have the shadow register publish itself on the read analysis ports.  This is done for any monitor that might be monitoring the register and wants to keep track of reads.

This function is called when a “WRITE” transaction is detected.  When this function executes, it simply ‘writes’ the new value to the shadow.

First check to make sure that there are at least 32 bits, then call bus_read_bv() to do the real work.

First check to make sure that there are at least 32 bits, then call bus_write_bv() to do the real work.

An alias for bus_read_bv() which takes an array of bytes as input.

An alias for bus_write_bv() which takes an array of bytes as input.

This is an alias for bus_write().

This is an alias for read().

This is an alias for get_dataN().

Construct the analysis ports.  This code is separate because there are occasions where the analysis ports are not needed.  Note: container is NOT used.

Construct the register, given a name, a parent and a reset value.  The name is normally a full path name of the parent combined with a short name for the register : { p.get_full_name(), “reg1” } The parent can be NULL, in which case no analysis ports will be created.

Set the value of the register to the reset value.  Use poke(), so that all masks and behavior are bypassed.  No notification is performed.

Use this function to set the default reset value.  TODO: Move into base class (using bit vector) TODO: Allow for N types of reset.  (soft and hard)

Calculate the new value, based on the old value, the local mask, and the register masks.

Calculate the new value, based on the old value, the new value, the local mask, and the register masks.

Read the masked data without notify.  This function can be overridden by extended registers to implement new behaviors.

Write masked data without notify.  This function can be overridden by extended registers to implement new behaviors.

Read masked data with notify.

Write masked data with notify.

”Raw” interface to write data.  No masking or notification is performed.

”Raw” interface to read data.  No masking or notification is performed.

Compare the data field using the compare mask.  Return 1 if the new_data matches the existing value.  Return 0 otherwise.

Same functionality as compare_data(), but a register is passed in, instead of the register data value.  To use custom masks or other fancy compare, override this function.

Implement this is the design specific register.

Match the UVM engine

Given a name, lookup the name from ‘here’.  This name is a name relative to the register container we are in currently - this register map or this register file - for example.  The name will normally be a path name containing path separators and names - “rf1.dut2.blkA.blkleaf”

Return the list of all registers in this address map

For all the registers, call the reset() function

Call print_fields() on every register contained in this register_file/register_map.

Print information about the address map, arranged by address

Print information about the address map, arranged by name

Print information about the address map.

add_register() maps a register using the full path name. add_register_alias() allows an additional name, or alias to also be mapped (it is NOT actually a new mapping - the “alias mapping” just points to the existing full name mapping.

Delete all the mapping data structures for this register container.  This is usually only done when you plan to rebuild the mappings - for example when you change some set of constraints which will have the affect of changing the mappings.

1.  Delete the mappings.  2. Change the constraints, randomize.  3. Rebuild the mappings.

Add a register with ‘name’ and an offset (or address).  The register has been previously constructed elsewhere.

Note : ‘name’ is always (should always) be register.get_fullname().

The “mapped_register” construct is entered into two search tables: 1.  Search by name.  The array ‘nameSpace[]’ is a search by name associative array.  2. Search by address.  The array ‘addrSpace[]’ is a search by address associative array.

Add a register file to this register map.  All addresses in the “copied-in” register file are incremented by ‘addr’ before being stored in the address map of this object.

Add a register map to this register map.  All addresses in the “copied-in” map are incremented by ‘addr’ before being stored in the address map of this object.

Shortcut for adding a register with a large address range.

Given a register name, provide ALL the addresses of the register.  Returns a list of addresses.

Given a register name, provide a single mapped address.

Given a register name, return the corresponding register handle.

Given an offset, provide the register mapped there.

Return the currently registered register map from the configuration.

Pass in a place to go find the config.  If the place (variable ‘c’) is NULL, then use uvm_top.

Example usages

get_register_map() Looks for “register_map” in the top.

get_register_map(.c(my_component)) Looks for “register_map” in my_component.

get_register_map(“map”, my_component); Looks for “map” in my_component.

Return the currently registered register map from the configuration.