ExternalVendorCode/genode
1
0
Fork 0
mirror of https://github.com/genodelabs/genode.git synced 2024-12-19 21:57:55 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
e6b72030d3
genode/base/include/util/mmio.h

476 lines
15 KiB
C
Raw Normal View History

First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
/*
Replace 'Subreg_array' with 'Reg_array'. 'Reg_array' contains items whose width can be the width of the register storage type at a max. Nethertheless they can be smaller and iterate all subregs that are covered by the item width. The array uses as much successive instances of its storage type as needed. The test 'run/util_mmio' also tests these new features heavily.
2012-01-14 01:42:45 +00:00
* \brief Generic MMIO access framework
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
* \author Martin stein
* \date 2011-10-26
*/
Complement test for MMIO framework The run script 'run/util_mmio.run' runs a test over basic functionalities of 'Mmio::Register' and 'Mmio::Register::Subreg'. The test covers the functions 'read' and 'bits', 'set', 'clear' and 'get'. Inline function in 'Mmio::Register::Subreg' whose definition otherwise looks ugly.
2012-01-10 11:56:45 +00:00
/*
* Copyright (C) 2011-2012 Genode Labs GmbH
*
* This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2.
*/
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
#ifndef _BASE__INCLUDE__UTIL__MMIO_H_
#define _BASE__INCLUDE__UTIL__MMIO_H_
Boolean fields and strict write on Registers/MMIO
2012-05-24 09:56:54 +00:00
/* Genode includes */
Extract more generic parts from 'Genode::Mmio' To accommodate CPU registers, which have a structured layout but don't depend on a region base address, this patch introduces the generic 'Genode::Register' and 'Genode::Subreg' to 'register.h'. 'Mmio::Register' and 'Mmio::Subreg' inherit from them.
2012-01-09 20:05:49 +00:00
#include <util/register.h>
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
namespace Genode
{
/**
* A continuous MMIO region
*/
class Mmio
{
protected:
/**
Beautify class names in 'register.h' and 'mmio.h' Replace 'Reg_array' in 'Genode::Mmio' by 'Register_array' and 'Subreg' in 'Genode::Register', 'Genode::Mmio::Register'and 'Genode::Mmio::Register_array' by 'Bitfield'. Update and beautify comments in the according headers and test programs.
2012-01-17 08:47:23 +00:00
* Write typed 'value' to MMIO base + 'o'
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
*/
Simplify interface of the MMIO framework, ref #69 Parameterize register and bitfield templates to always take their bitwidth instead of the according types or width exponents as arguments.
2012-01-17 17:55:24 +00:00
template <typename _ACCESS_T>
Boolean fields and strict write on Registers/MMIO
2012-05-24 09:56:54 +00:00
inline void _write(off_t const o, _ACCESS_T const value) {
*(_ACCESS_T volatile *)((addr_t)base + o) = value; }
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
/**
* Read typed from MMIO base + 'o'
*/
Simplify interface of the MMIO framework, ref #69 Parameterize register and bitfield templates to always take their bitwidth instead of the according types or width exponents as arguments.
2012-01-17 17:55:24 +00:00
template <typename _ACCESS_T>
Boolean fields and strict write on Registers/MMIO
2012-05-24 09:56:54 +00:00
inline _ACCESS_T _read(off_t const o) const {
return *(_ACCESS_T volatile *)((addr_t)base + o); }
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
public:
Replace 'Subreg_array' with 'Reg_array'. 'Reg_array' contains items whose width can be the width of the register storage type at a max. Nethertheless they can be smaller and iterate all subregs that are covered by the item width. The array uses as much successive instances of its storage type as needed. The test 'run/util_mmio' also tests these new features heavily.
2012-01-14 01:42:45 +00:00
enum { BYTE_WIDTH_LOG2 = 3, BYTE_WIDTH = 1 << BYTE_WIDTH_LOG2 };
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
/**
Simplify interface of the MMIO framework, ref #69 Parameterize register and bitfield templates to always take their bitwidth instead of the according types or width exponents as arguments.
2012-01-17 17:55:24 +00:00
* An integer like region within a MMIO region.
*
Boolean fields and strict write on Registers/MMIO
2012-05-24 09:56:54 +00:00
* \param _OFFSET Offset of the region relative to the
* base of the compound MMIO
* \param _ACCESS_WIDTH Bit width of the region, for a list of
* supported widths see 'Genode::Register'
* \param _STRICT_WRITE If set to 0, when writing a bitfield, we
* read the register value, update the bits
* on it, and write it back to the register.
* If set to 1 we take an empty register
* value instead, apply the bitfield on it,
* and write it to the register. This can
* be useful if you have registers that have
* different means on reads and writes.
Beautify class names in 'register.h' and 'mmio.h' Replace 'Reg_array' in 'Genode::Mmio' by 'Register_array' and 'Subreg' in 'Genode::Register', 'Genode::Mmio::Register'and 'Genode::Mmio::Register_array' by 'Bitfield'. Update and beautify comments in the according headers and test programs.
2012-01-17 08:47:23 +00:00
*
Review doc and style for release. ref #69
2012-02-22 15:14:41 +00:00
* \detail See 'Genode::Register'
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
*/
Boolean fields and strict write on Registers/MMIO
2012-05-24 09:56:54 +00:00
template <off_t _OFFSET, unsigned long _ACCESS_WIDTH,
bool _STRICT_WRITE = false>
Simplify interface of the MMIO framework, ref #69 Parameterize register and bitfield templates to always take their bitwidth instead of the according types or width exponents as arguments.
2012-01-17 17:55:24 +00:00
struct Register : public Genode::Register<_ACCESS_WIDTH>
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
{
Simplify interface of the MMIO framework, ref #69 Parameterize register and bitfield templates to always take their bitwidth instead of the according types or width exponents as arguments.
2012-01-17 17:55:24 +00:00
enum {
OFFSET = _OFFSET,
ACCESS_WIDTH = _ACCESS_WIDTH,
Boolean fields and strict write on Registers/MMIO
2012-05-24 09:56:54 +00:00
STRICT_WRITE = _STRICT_WRITE,
Simplify interface of the MMIO framework, ref #69 Parameterize register and bitfield templates to always take their bitwidth instead of the according types or width exponents as arguments.
2012-01-17 17:55:24 +00:00
};
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
/**
Simplify interface of the MMIO framework, ref #69 Parameterize register and bitfield templates to always take their bitwidth instead of the according types or width exponents as arguments.
2012-01-17 17:55:24 +00:00
* A region within a register
Review doc and style for release. ref #69
2012-02-22 15:14:41 +00:00
*
* \param _SHIFT Bit shift of the first bit within the
* compound register
Simplify interface of the MMIO framework, ref #69 Parameterize register and bitfield templates to always take their bitwidth instead of the according types or width exponents as arguments.
2012-01-17 17:55:24 +00:00
* \param _WIDTH Bit width of the region
*
* \detail See 'Genode::Register::Bitfield'
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
*/
Simplify interface of the MMIO framework, ref #69 Parameterize register and bitfield templates to always take their bitwidth instead of the according types or width exponents as arguments.
2012-01-17 17:55:24 +00:00
template <unsigned long _SHIFT, unsigned long _WIDTH>
Review doc and style for release. ref #69
2012-02-22 15:14:41 +00:00
struct Bitfield :
public Genode::Register<ACCESS_WIDTH>::template Bitfield<_SHIFT, _WIDTH>
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
{
Boolean fields and strict write on Registers/MMIO
2012-05-24 09:56:54 +00:00
/* Back reference to containing register */
typedef Register<OFFSET, ACCESS_WIDTH, STRICT_WRITE> Compound_reg;
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
};
Replace 'Subreg_array' with 'Reg_array'. 'Reg_array' contains items whose width can be the width of the register storage type at a max. Nethertheless they can be smaller and iterate all subregs that are covered by the item width. The array uses as much successive instances of its storage type as needed. The test 'run/util_mmio' also tests these new features heavily.
2012-01-14 01:42:45 +00:00
};
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
Replace 'Subreg_array' with 'Reg_array'. 'Reg_array' contains items whose width can be the width of the register storage type at a max. Nethertheless they can be smaller and iterate all subregs that are covered by the item width. The array uses as much successive instances of its storage type as needed. The test 'run/util_mmio' also tests these new features heavily.
2012-01-14 01:42:45 +00:00
/**
Simplify interface of the MMIO framework, ref #69 Parameterize register and bitfield templates to always take their bitwidth instead of the according types or width exponents as arguments.
2012-01-17 17:55:24 +00:00
* An array of successive equally structured regions
*
Review doc and style for release. ref #69
2012-02-22 15:14:41 +00:00
* \param _OFFSET Offset of the first region relative to
* the base of the compound MMIO.
* \param _ACCESS_WIDTH Bit width of a single access, must be at
* least the item width.
* \param _ITEMS How many times the region gets iterated
* successive
Simplify interface of the MMIO framework, ref #69 Parameterize register and bitfield templates to always take their bitwidth instead of the according types or width exponents as arguments.
2012-01-17 17:55:24 +00:00
* \param _ITEM_WIDTH Bit width of a region
Boolean fields and strict write on Registers/MMIO
2012-05-24 09:56:54 +00:00
* \param _STRICT_WRITE If set to 0, when writing a bitfield, we
* read the register value, update the bits
* on it, and write it back to the register.
* If set to 1, we take an empty register
* value instead, apply the bitfield on it,
* and write it to the register. This can
* be useful if you have registers that have
* different means on reads and writes.
* Please note that ACCESS_WIDTH is decisive
* for the range of such strictness.
Replace 'Subreg_array' with 'Reg_array'. 'Reg_array' contains items whose width can be the width of the register storage type at a max. Nethertheless they can be smaller and iterate all subregs that are covered by the item width. The array uses as much successive instances of its storage type as needed. The test 'run/util_mmio' also tests these new features heavily.
2012-01-14 01:42:45 +00:00
*
Review doc and style for release. ref #69
2012-02-22 15:14:41 +00:00
* \detail The array takes all inner structures, wich are covered
* by an item width and iterates them successive. Such
* structures that are partially exceed an item range are
* read and written also partially. Structures that are
* completely out of the item range are read as '0' and
* trying to overwrite them has no effect. The array is
* not limited to its access width, it extends to the
* memory region of its successive items. Trying to read
* out read with an item index out of the array range
* returns '0', trying to write to such indices has no
* effect
Replace 'Subreg_array' with 'Reg_array'. 'Reg_array' contains items whose width can be the width of the register storage type at a max. Nethertheless they can be smaller and iterate all subregs that are covered by the item width. The array uses as much successive instances of its storage type as needed. The test 'run/util_mmio' also tests these new features heavily.
2012-01-14 01:42:45 +00:00
*/
Review doc and style for release. ref #69
2012-02-22 15:14:41 +00:00
template <off_t _OFFSET, unsigned long _ACCESS_WIDTH,
Boolean fields and strict write on Registers/MMIO
2012-05-24 09:56:54 +00:00
unsigned long _ITEMS, unsigned long _ITEM_WIDTH,
bool _STRICT_WRITE = false>
struct Register_array : public Register<_OFFSET, _ACCESS_WIDTH,
_STRICT_WRITE>
Replace 'Subreg_array' with 'Reg_array'. 'Reg_array' contains items whose width can be the width of the register storage type at a max. Nethertheless they can be smaller and iterate all subregs that are covered by the item width. The array uses as much successive instances of its storage type as needed. The test 'run/util_mmio' also tests these new features heavily.
2012-01-14 01:42:45 +00:00
{
Review doc and style for release. ref #69
2012-02-22 15:14:41 +00:00
typedef
typename Trait::Uint_type<_ACCESS_WIDTH>::template Divisor<_ITEM_WIDTH>
Item;
Simplify interface of the MMIO framework, ref #69 Parameterize register and bitfield templates to always take their bitwidth instead of the according types or width exponents as arguments.
2012-01-17 17:55:24 +00:00
Replace 'Subreg_array' with 'Reg_array'. 'Reg_array' contains items whose width can be the width of the register storage type at a max. Nethertheless they can be smaller and iterate all subregs that are covered by the item width. The array uses as much successive instances of its storage type as needed. The test 'run/util_mmio' also tests these new features heavily.
2012-01-14 01:42:45 +00:00
enum {
Boolean fields and strict write on Registers/MMIO
2012-05-24 09:56:54 +00:00
STRICT_WRITE = _STRICT_WRITE,
Simplify interface of the MMIO framework, ref #69 Parameterize register and bitfield templates to always take their bitwidth instead of the according types or width exponents as arguments.
2012-01-17 17:55:24 +00:00
OFFSET = _OFFSET,
ACCESS_WIDTH = _ACCESS_WIDTH,
ITEMS = _ITEMS,
ITEM_WIDTH = _ITEM_WIDTH,
ITEM_WIDTH_LOG2 = Item::WIDTH_LOG2,
Replace 'Subreg_array' with 'Reg_array'. 'Reg_array' contains items whose width can be the width of the register storage type at a max. Nethertheless they can be smaller and iterate all subregs that are covered by the item width. The array uses as much successive instances of its storage type as needed. The test 'run/util_mmio' also tests these new features heavily.
2012-01-14 01:42:45 +00:00
MAX_INDEX = ITEMS - 1,
ITEM_MASK = (1 << ITEM_WIDTH) - 1,
};
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
Boolean fields and strict write on Registers/MMIO
2012-05-24 09:56:54 +00:00
typedef
typename Register<OFFSET, ACCESS_WIDTH, STRICT_WRITE>::access_t
Review doc and style for release. ref #69
2012-02-22 15:14:41 +00:00
access_t;
Simplify interface of the MMIO framework, ref #69 Parameterize register and bitfield templates to always take their bitwidth instead of the according types or width exponents as arguments.
2012-01-17 17:55:24 +00:00
Replace 'Subreg_array' with 'Reg_array'. 'Reg_array' contains items whose width can be the width of the register storage type at a max. Nethertheless they can be smaller and iterate all subregs that are covered by the item width. The array uses as much successive instances of its storage type as needed. The test 'run/util_mmio' also tests these new features heavily.
2012-01-14 01:42:45 +00:00
/**
Simplify interface of the MMIO framework, ref #69 Parameterize register and bitfield templates to always take their bitwidth instead of the according types or width exponents as arguments.
2012-01-17 17:55:24 +00:00
* A bitregion within a register array item
*
* \param _SHIFT Bit shift of the first bit within an item
* \param _WIDTH Bit width of the region
Replace 'Subreg_array' with 'Reg_array'. 'Reg_array' contains items whose width can be the width of the register storage type at a max. Nethertheless they can be smaller and iterate all subregs that are covered by the item width. The array uses as much successive instances of its storage type as needed. The test 'run/util_mmio' also tests these new features heavily.
2012-01-14 01:42:45 +00:00
*
Review doc and style for release. ref #69
2012-02-22 15:14:41 +00:00
* \detail See 'Genode::Register::Bitfield'
Replace 'Subreg_array' with 'Reg_array'. 'Reg_array' contains items whose width can be the width of the register storage type at a max. Nethertheless they can be smaller and iterate all subregs that are covered by the item width. The array uses as much successive instances of its storage type as needed. The test 'run/util_mmio' also tests these new features heavily.
2012-01-14 01:42:45 +00:00
*/
Simplify interface of the MMIO framework, ref #69 Parameterize register and bitfield templates to always take their bitwidth instead of the according types or width exponents as arguments.
2012-01-17 17:55:24 +00:00
template <unsigned long _SHIFT, unsigned long _SIZE>
Review doc and style for release. ref #69
2012-02-22 15:14:41 +00:00
struct Bitfield :
Boolean fields and strict write on Registers/MMIO
2012-05-24 09:56:54 +00:00
public Register<OFFSET, ACCESS_WIDTH, STRICT_WRITE>::template Bitfield<_SHIFT, _SIZE>
Replace 'Subreg_array' with 'Reg_array'. 'Reg_array' contains items whose width can be the width of the register storage type at a max. Nethertheless they can be smaller and iterate all subregs that are covered by the item width. The array uses as much successive instances of its storage type as needed. The test 'run/util_mmio' also tests these new features heavily.
2012-01-14 01:42:45 +00:00
{
Boolean fields and strict write on Registers/MMIO
2012-05-24 09:56:54 +00:00
/* Back reference to containing register array */
typedef Register_array<OFFSET, ACCESS_WIDTH, ITEMS,
ITEM_WIDTH, STRICT_WRITE>
Review doc and style for release. ref #69
2012-02-22 15:14:41 +00:00
Compound_array;
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
};
Replace 'Subreg_array' with 'Reg_array'. 'Reg_array' contains items whose width can be the width of the register storage type at a max. Nethertheless they can be smaller and iterate all subregs that are covered by the item width. The array uses as much successive instances of its storage type as needed. The test 'run/util_mmio' also tests these new features heavily.
2012-01-14 01:42:45 +00:00
/**
Review doc and style for release. ref #69
2012-02-22 15:14:41 +00:00
* Calculate destination of an array-item access
*
* \param offset Gets overridden with the offset of the
* access type instance, that contains the
* access destination, relative to the MMIO
* base
* \param shift Gets overridden with the shift of the
* destination within the access type instance
* targeted by 'offset'
* \param index Index of the targeted array item
Replace 'Subreg_array' with 'Reg_array'. 'Reg_array' contains items whose width can be the width of the register storage type at a max. Nethertheless they can be smaller and iterate all subregs that are covered by the item width. The array uses as much successive instances of its storage type as needed. The test 'run/util_mmio' also tests these new features heavily.
2012-01-14 01:42:45 +00:00
*/
Review doc and style for release. ref #69
2012-02-22 15:14:41 +00:00
static inline void access_dest(off_t & offset,
unsigned long & shift,
Replace 'Subreg_array' with 'Reg_array'. 'Reg_array' contains items whose width can be the width of the register storage type at a max. Nethertheless they can be smaller and iterate all subregs that are covered by the item width. The array uses as much successive instances of its storage type as needed. The test 'run/util_mmio' also tests these new features heavily.
2012-01-14 01:42:45 +00:00
unsigned long const index)
{
unsigned long const bit_off = index << ITEM_WIDTH_LOG2;
Review doc and style for release. ref #69
2012-02-22 15:14:41 +00:00
offset = (off_t) ((bit_off >> BYTE_WIDTH_LOG2)
& ~(sizeof(access_t)-1) );
Replace 'Subreg_array' with 'Reg_array'. 'Reg_array' contains items whose width can be the width of the register storage type at a max. Nethertheless they can be smaller and iterate all subregs that are covered by the item width. The array uses as much successive instances of its storage type as needed. The test 'run/util_mmio' also tests these new features heavily.
2012-01-14 01:42:45 +00:00
shift = bit_off - ( offset << BYTE_WIDTH_LOG2 );
Simplify interface of the MMIO framework, ref #69 Parameterize register and bitfield templates to always take their bitwidth instead of the according types or width exponents as arguments.
2012-01-17 17:55:24 +00:00
offset += OFFSET;
Replace 'Subreg_array' with 'Reg_array'. 'Reg_array' contains items whose width can be the width of the register storage type at a max. Nethertheless they can be smaller and iterate all subregs that are covered by the item width. The array uses as much successive instances of its storage type as needed. The test 'run/util_mmio' also tests these new features heavily.
2012-01-14 01:42:45 +00:00
}
};
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
addr_t const base;
/**
* Constructor
*/
Replace 'Subreg_array' with 'Reg_array'. 'Reg_array' contains items whose width can be the width of the register storage type at a max. Nethertheless they can be smaller and iterate all subregs that are covered by the item width. The array uses as much successive instances of its storage type as needed. The test 'run/util_mmio' also tests these new features heavily.
2012-01-14 01:42:45 +00:00
inline Mmio(addr_t mmio_base) : base(mmio_base) { }
/*************************
** Access to registers **
*************************/
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
/**
* Typed address of register 'REGISTER'
*/
template <typename REGISTER>
Boolean fields and strict write on Registers/MMIO
2012-05-24 09:56:54 +00:00
inline typename REGISTER::access_t volatile * typed_addr() const {
return (typename REGISTER::access_t volatile *)
base + REGISTER::OFFSET; }
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
/**
* Read the whole register 'REGISTER'
*/
template <typename REGISTER>
Boolean fields and strict write on Registers/MMIO
2012-05-24 09:56:54 +00:00
inline typename REGISTER::access_t read() const {
return _read<typename REGISTER::access_t>(REGISTER::OFFSET); }
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
Replace 'Subreg_array' with 'Reg_array'. 'Reg_array' contains items whose width can be the width of the register storage type at a max. Nethertheless they can be smaller and iterate all subregs that are covered by the item width. The array uses as much successive instances of its storage type as needed. The test 'run/util_mmio' also tests these new features heavily.
2012-01-14 01:42:45 +00:00
/**
Beautify class names in 'register.h' and 'mmio.h' Replace 'Reg_array' in 'Genode::Mmio' by 'Register_array' and 'Subreg' in 'Genode::Register', 'Genode::Mmio::Register'and 'Genode::Mmio::Register_array' by 'Bitfield'. Update and beautify comments in the according headers and test programs.
2012-01-17 08:47:23 +00:00
* Write 'value' to the register 'REGISTER'
Replace 'Subreg_array' with 'Reg_array'. 'Reg_array' contains items whose width can be the width of the register storage type at a max. Nethertheless they can be smaller and iterate all subregs that are covered by the item width. The array uses as much successive instances of its storage type as needed. The test 'run/util_mmio' also tests these new features heavily.
2012-01-14 01:42:45 +00:00
*/
template <typename REGISTER>
Boolean fields and strict write on Registers/MMIO
2012-05-24 09:56:54 +00:00
inline void write(typename REGISTER::access_t const value) {
_write<typename REGISTER::access_t>(REGISTER::OFFSET, value); }
Replace 'Subreg_array' with 'Reg_array'. 'Reg_array' contains items whose width can be the width of the register storage type at a max. Nethertheless they can be smaller and iterate all subregs that are covered by the item width. The array uses as much successive instances of its storage type as needed. The test 'run/util_mmio' also tests these new features heavily.
2012-01-14 01:42:45 +00:00
Beautify class names in 'register.h' and 'mmio.h' Replace 'Reg_array' in 'Genode::Mmio' by 'Register_array' and 'Subreg' in 'Genode::Register', 'Genode::Mmio::Register'and 'Genode::Mmio::Register_array' by 'Bitfield'. Update and beautify comments in the according headers and test programs.
2012-01-17 08:47:23 +00:00
/******************************************
** Access to bitfields within registers **
******************************************/
Replace 'Subreg_array' with 'Reg_array'. 'Reg_array' contains items whose width can be the width of the register storage type at a max. Nethertheless they can be smaller and iterate all subregs that are covered by the item width. The array uses as much successive instances of its storage type as needed. The test 'run/util_mmio' also tests these new features heavily.
2012-01-14 01:42:45 +00:00
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
/**
Beautify class names in 'register.h' and 'mmio.h' Replace 'Reg_array' in 'Genode::Mmio' by 'Register_array' and 'Subreg' in 'Genode::Register', 'Genode::Mmio::Register'and 'Genode::Mmio::Register_array' by 'Bitfield'. Update and beautify comments in the according headers and test programs.
2012-01-17 08:47:23 +00:00
* Read the bitfield 'BITFIELD'
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
*/
Beautify class names in 'register.h' and 'mmio.h' Replace 'Reg_array' in 'Genode::Mmio' by 'Register_array' and 'Subreg' in 'Genode::Register', 'Genode::Mmio::Register'and 'Genode::Mmio::Register_array' by 'Bitfield'. Update and beautify comments in the according headers and test programs.
2012-01-17 08:47:23 +00:00
template <typename BITFIELD>
Simplify interface of the MMIO framework, ref #69 Parameterize register and bitfield templates to always take their bitwidth instead of the according types or width exponents as arguments.
2012-01-17 17:55:24 +00:00
inline typename BITFIELD::Compound_reg::access_t read() const;
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
/**
Beautify class names in 'register.h' and 'mmio.h' Replace 'Reg_array' in 'Genode::Mmio' by 'Register_array' and 'Subreg' in 'Genode::Register', 'Genode::Mmio::Register'and 'Genode::Mmio::Register_array' by 'Bitfield'. Update and beautify comments in the according headers and test programs.
2012-01-17 08:47:23 +00:00
* Write value to the bitfield 'BITFIELD'
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
*/
Beautify class names in 'register.h' and 'mmio.h' Replace 'Reg_array' in 'Genode::Mmio' by 'Register_array' and 'Subreg' in 'Genode::Register', 'Genode::Mmio::Register'and 'Genode::Mmio::Register_array' by 'Bitfield'. Update and beautify comments in the according headers and test programs.
2012-01-17 08:47:23 +00:00
template <typename BITFIELD>
Review doc and style for release. ref #69
2012-02-22 15:14:41 +00:00
inline void
write(typename BITFIELD::Compound_reg::access_t const value);
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
Replace 'Subreg_array' with 'Reg_array'. 'Reg_array' contains items whose width can be the width of the register storage type at a max. Nethertheless they can be smaller and iterate all subregs that are covered by the item width. The array uses as much successive instances of its storage type as needed. The test 'run/util_mmio' also tests these new features heavily.
2012-01-14 01:42:45 +00:00
/*******************************
** Access to register arrays **
*******************************/
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
/**
Beautify class names in 'register.h' and 'mmio.h' Replace 'Reg_array' in 'Genode::Mmio' by 'Register_array' and 'Subreg' in 'Genode::Register', 'Genode::Mmio::Register'and 'Genode::Mmio::Register_array' by 'Bitfield'. Update and beautify comments in the according headers and test programs.
2012-01-17 08:47:23 +00:00
* Read the whole item 'index' of the array 'REGISTER_ARRAY'
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
*/
Beautify class names in 'register.h' and 'mmio.h' Replace 'Reg_array' in 'Genode::Mmio' by 'Register_array' and 'Subreg' in 'Genode::Register', 'Genode::Mmio::Register'and 'Genode::Mmio::Register_array' by 'Bitfield'. Update and beautify comments in the according headers and test programs.
2012-01-17 08:47:23 +00:00
template <typename REGISTER_ARRAY>
Review doc and style for release. ref #69
2012-02-22 15:14:41 +00:00
inline typename REGISTER_ARRAY::access_t
read(unsigned long const index) const;
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
/**
Review doc and style for release. ref #69
2012-02-22 15:14:41 +00:00
* Write 'value' to item 'index' of the array 'REGISTER_ARRAY'
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
*/
Beautify class names in 'register.h' and 'mmio.h' Replace 'Reg_array' in 'Genode::Mmio' by 'Register_array' and 'Subreg' in 'Genode::Register', 'Genode::Mmio::Register'and 'Genode::Mmio::Register_array' by 'Bitfield'. Update and beautify comments in the according headers and test programs.
2012-01-17 08:47:23 +00:00
template <typename REGISTER_ARRAY>
Simplify interface of the MMIO framework, ref #69 Parameterize register and bitfield templates to always take their bitwidth instead of the according types or width exponents as arguments.
2012-01-17 17:55:24 +00:00
inline void write(typename REGISTER_ARRAY::access_t const value,
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
unsigned long const index);
Replace 'Subreg_array' with 'Reg_array'. 'Reg_array' contains items whose width can be the width of the register storage type at a max. Nethertheless they can be smaller and iterate all subregs that are covered by the item width. The array uses as much successive instances of its storage type as needed. The test 'run/util_mmio' also tests these new features heavily.
2012-01-14 01:42:45 +00:00
Beautify class names in 'register.h' and 'mmio.h' Replace 'Reg_array' in 'Genode::Mmio' by 'Register_array' and 'Subreg' in 'Genode::Register', 'Genode::Mmio::Register'and 'Genode::Mmio::Register_array' by 'Bitfield'. Update and beautify comments in the according headers and test programs.
2012-01-17 08:47:23 +00:00
/*****************************************************
** Access to bitfields within register array items **
*****************************************************/
Replace 'Subreg_array' with 'Reg_array'. 'Reg_array' contains items whose width can be the width of the register storage type at a max. Nethertheless they can be smaller and iterate all subregs that are covered by the item width. The array uses as much successive instances of its storage type as needed. The test 'run/util_mmio' also tests these new features heavily.
2012-01-14 01:42:45 +00:00
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
/**
Review doc and style for release. ref #69
2012-02-22 15:14:41 +00:00
* Read the bitfield 'ARRAY_BITFIELD' of item 'index' of the
* compound reg array
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
*/
Beautify class names in 'register.h' and 'mmio.h' Replace 'Reg_array' in 'Genode::Mmio' by 'Register_array' and 'Subreg' in 'Genode::Register', 'Genode::Mmio::Register'and 'Genode::Mmio::Register_array' by 'Bitfield'. Update and beautify comments in the according headers and test programs.
2012-01-17 08:47:23 +00:00
template <typename ARRAY_BITFIELD>
Review doc and style for release. ref #69
2012-02-22 15:14:41 +00:00
inline typename ARRAY_BITFIELD::Compound_array::access_t
read(unsigned long const index) const;
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
/**
Review doc and style for release. ref #69
2012-02-22 15:14:41 +00:00
* Write 'value' to bitfield 'ARRAY_BITFIELD' of item 'index' of
* the compound reg array
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
*/
Beautify class names in 'register.h' and 'mmio.h' Replace 'Reg_array' in 'Genode::Mmio' by 'Register_array' and 'Subreg' in 'Genode::Register', 'Genode::Mmio::Register'and 'Genode::Mmio::Register_array' by 'Bitfield'. Update and beautify comments in the according headers and test programs.
2012-01-17 08:47:23 +00:00
template <typename ARRAY_BITFIELD>
Review doc and style for release. ref #69
2012-02-22 15:14:41 +00:00
inline void
write(typename ARRAY_BITFIELD::Compound_array::access_t const value,
long unsigned const index);
Add bitfield polling support to MMIO framework
2012-07-03 11:06:29 +00:00
/*********************************
** Polling for bitfield states **
*********************************/
/**
* Interface for delaying the execution of a calling thread
*/
struct Delayer
{
/**
* Delay the execution of the caller for the specified amount
* of microseconds
*/
virtual void usleep(unsigned us) = 0;
};
/**
* Wait until the 'BITFIELD' contains the specified 'value'
*
* \param value value to wait for
* \param delayer sleeping facility to be used when the
* value is not reached yet
* \param max_attempts number of bitfield probing attempts
* \param us number of microseconds between attempts
*/
template <typename BITFIELD>
inline bool
wait_for(typename BITFIELD::Compound_reg::access_t const value,
Delayer &delayer,
unsigned max_attempts = 500,
unsigned us = 1000)
{
for (unsigned i = 0; i < max_attempts; i++, delayer.usleep(us))
if (read<BITFIELD>() == value)
return true;
return false;
}
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
};
}
Beautify class names in 'register.h' and 'mmio.h' Replace 'Reg_array' in 'Genode::Mmio' by 'Register_array' and 'Subreg' in 'Genode::Register', 'Genode::Mmio::Register'and 'Genode::Mmio::Register_array' by 'Bitfield'. Update and beautify comments in the according headers and test programs.
2012-01-17 08:47:23 +00:00
/******************************************
** Access to bitfields within registers **
******************************************/
Replace 'Subreg_array' with 'Reg_array'. 'Reg_array' contains items whose width can be the width of the register storage type at a max. Nethertheless they can be smaller and iterate all subregs that are covered by the item width. The array uses as much successive instances of its storage type as needed. The test 'run/util_mmio' also tests these new features heavily.
2012-01-14 01:42:45 +00:00
Beautify class names in 'register.h' and 'mmio.h' Replace 'Reg_array' in 'Genode::Mmio' by 'Register_array' and 'Subreg' in 'Genode::Register', 'Genode::Mmio::Register'and 'Genode::Mmio::Register_array' by 'Bitfield'. Update and beautify comments in the according headers and test programs.
2012-01-17 08:47:23 +00:00
template <typename BITFIELD>
Simplify interface of the MMIO framework, ref #69 Parameterize register and bitfield templates to always take their bitwidth instead of the according types or width exponents as arguments.
2012-01-17 17:55:24 +00:00
typename BITFIELD::Compound_reg::access_t Genode::Mmio::read() const
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
{
Beautify class names in 'register.h' and 'mmio.h' Replace 'Reg_array' in 'Genode::Mmio' by 'Register_array' and 'Subreg' in 'Genode::Register', 'Genode::Mmio::Register'and 'Genode::Mmio::Register_array' by 'Bitfield'. Update and beautify comments in the according headers and test programs.
2012-01-17 08:47:23 +00:00
typedef typename BITFIELD::Compound_reg Register;
Simplify interface of the MMIO framework, ref #69 Parameterize register and bitfield templates to always take their bitwidth instead of the according types or width exponents as arguments.
2012-01-17 17:55:24 +00:00
typedef typename Register::access_t access_t;
return BITFIELD::get(_read<access_t>(Register::OFFSET));
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
}
Beautify class names in 'register.h' and 'mmio.h' Replace 'Reg_array' in 'Genode::Mmio' by 'Register_array' and 'Subreg' in 'Genode::Register', 'Genode::Mmio::Register'and 'Genode::Mmio::Register_array' by 'Bitfield'. Update and beautify comments in the according headers and test programs.
2012-01-17 08:47:23 +00:00
template <typename BITFIELD>
Simplify interface of the MMIO framework, ref #69 Parameterize register and bitfield templates to always take their bitwidth instead of the according types or width exponents as arguments.
2012-01-17 17:55:24 +00:00
void Genode::Mmio::write(typename BITFIELD::Compound_reg::access_t const value)
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
{
Boolean fields and strict write on Registers/MMIO
2012-05-24 09:56:54 +00:00
/* Initialize the pattern that is written finally to the register */
Beautify class names in 'register.h' and 'mmio.h' Replace 'Reg_array' in 'Genode::Mmio' by 'Register_array' and 'Subreg' in 'Genode::Register', 'Genode::Mmio::Register'and 'Genode::Mmio::Register_array' by 'Bitfield'. Update and beautify comments in the according headers and test programs.
2012-01-17 08:47:23 +00:00
typedef typename BITFIELD::Compound_reg Register;
Boolean fields and strict write on Registers/MMIO
2012-05-24 09:56:54 +00:00
typename Register::access_t write_value;
if (Register::STRICT_WRITE)
{
/* We must only apply the bitfield to an empty write pattern */
write_value = 0;
} else {
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
Boolean fields and strict write on Registers/MMIO
2012-05-24 09:56:54 +00:00
/* We've got to apply the bitfield to the old register value */
write_value = read<Register>();
BITFIELD::clear(write_value);
}
/* Apply bitfield value and override register */
BITFIELD::set(write_value, value);
write<Register>(write_value);
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
}
Replace 'Subreg_array' with 'Reg_array'. 'Reg_array' contains items whose width can be the width of the register storage type at a max. Nethertheless they can be smaller and iterate all subregs that are covered by the item width. The array uses as much successive instances of its storage type as needed. The test 'run/util_mmio' also tests these new features heavily.
2012-01-14 01:42:45 +00:00
/************************************
** Access to register array items **
************************************/
Beautify class names in 'register.h' and 'mmio.h' Replace 'Reg_array' in 'Genode::Mmio' by 'Register_array' and 'Subreg' in 'Genode::Register', 'Genode::Mmio::Register'and 'Genode::Mmio::Register_array' by 'Bitfield'. Update and beautify comments in the according headers and test programs.
2012-01-17 08:47:23 +00:00
template <typename REGISTER_ARRAY>
Review doc and style for release. ref #69
2012-02-22 15:14:41 +00:00
typename REGISTER_ARRAY::access_t
Genode::Mmio::read(unsigned long const index) const
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
{
Boolean fields and strict write on Registers/MMIO
2012-05-24 09:56:54 +00:00
/* Reads outside the array return 0 */
Beautify class names in 'register.h' and 'mmio.h' Replace 'Reg_array' in 'Genode::Mmio' by 'Register_array' and 'Subreg' in 'Genode::Register', 'Genode::Mmio::Register'and 'Genode::Mmio::Register_array' by 'Bitfield'. Update and beautify comments in the according headers and test programs.
2012-01-17 08:47:23 +00:00
if (index > REGISTER_ARRAY::MAX_INDEX) return 0;
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
Boolean fields and strict write on Registers/MMIO
2012-05-24 09:56:54 +00:00
/* If item width equals access width we optimize the access */
Replace 'Subreg_array' with 'Reg_array'. 'Reg_array' contains items whose width can be the width of the register storage type at a max. Nethertheless they can be smaller and iterate all subregs that are covered by the item width. The array uses as much successive instances of its storage type as needed. The test 'run/util_mmio' also tests these new features heavily.
2012-01-14 01:42:45 +00:00
off_t offset;
Simplify interface of the MMIO framework, ref #69 Parameterize register and bitfield templates to always take their bitwidth instead of the according types or width exponents as arguments.
2012-01-17 17:55:24 +00:00
if (REGISTER_ARRAY::ITEM_WIDTH == REGISTER_ARRAY::ACCESS_WIDTH) {
Review doc and style for release. ref #69
2012-02-22 15:14:41 +00:00
offset = REGISTER_ARRAY::OFFSET
+ (index << REGISTER_ARRAY::ITEM_WIDTH_LOG2);
Simplify interface of the MMIO framework, ref #69 Parameterize register and bitfield templates to always take their bitwidth instead of the according types or width exponents as arguments.
2012-01-17 17:55:24 +00:00
return _read<typename REGISTER_ARRAY::access_t>(offset);
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
Boolean fields and strict write on Registers/MMIO
2012-05-24 09:56:54 +00:00
/* Access width and item width differ */
Replace 'Subreg_array' with 'Reg_array'. 'Reg_array' contains items whose width can be the width of the register storage type at a max. Nethertheless they can be smaller and iterate all subregs that are covered by the item width. The array uses as much successive instances of its storage type as needed. The test 'run/util_mmio' also tests these new features heavily.
2012-01-14 01:42:45 +00:00
} else {
long unsigned shift;
Beautify class names in 'register.h' and 'mmio.h' Replace 'Reg_array' in 'Genode::Mmio' by 'Register_array' and 'Subreg' in 'Genode::Register', 'Genode::Mmio::Register'and 'Genode::Mmio::Register_array' by 'Bitfield'. Update and beautify comments in the according headers and test programs.
2012-01-17 08:47:23 +00:00
REGISTER_ARRAY::access_dest(offset, shift, index);
Review doc and style for release. ref #69
2012-02-22 15:14:41 +00:00
return (_read<typename REGISTER_ARRAY::access_t>(offset) >> shift)
& REGISTER_ARRAY::ITEM_MASK;
Replace 'Subreg_array' with 'Reg_array'. 'Reg_array' contains items whose width can be the width of the register storage type at a max. Nethertheless they can be smaller and iterate all subregs that are covered by the item width. The array uses as much successive instances of its storage type as needed. The test 'run/util_mmio' also tests these new features heavily.
2012-01-14 01:42:45 +00:00
}
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
}
Beautify class names in 'register.h' and 'mmio.h' Replace 'Reg_array' in 'Genode::Mmio' by 'Register_array' and 'Subreg' in 'Genode::Register', 'Genode::Mmio::Register'and 'Genode::Mmio::Register_array' by 'Bitfield'. Update and beautify comments in the according headers and test programs.
2012-01-17 08:47:23 +00:00
template <typename REGISTER_ARRAY>
Simplify interface of the MMIO framework, ref #69 Parameterize register and bitfield templates to always take their bitwidth instead of the according types or width exponents as arguments.
2012-01-17 17:55:24 +00:00
void Genode::Mmio::write(typename REGISTER_ARRAY::access_t const value,
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
unsigned long const index)
{
Boolean fields and strict write on Registers/MMIO
2012-05-24 09:56:54 +00:00
/* Writes outside the array are ignored */
Beautify class names in 'register.h' and 'mmio.h' Replace 'Reg_array' in 'Genode::Mmio' by 'Register_array' and 'Subreg' in 'Genode::Register', 'Genode::Mmio::Register'and 'Genode::Mmio::Register_array' by 'Bitfield'. Update and beautify comments in the according headers and test programs.
2012-01-17 08:47:23 +00:00
if (index > REGISTER_ARRAY::MAX_INDEX) return;
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
Boolean fields and strict write on Registers/MMIO
2012-05-24 09:56:54 +00:00
/* If item width equals access width we optimize the access */
Replace 'Subreg_array' with 'Reg_array'. 'Reg_array' contains items whose width can be the width of the register storage type at a max. Nethertheless they can be smaller and iterate all subregs that are covered by the item width. The array uses as much successive instances of its storage type as needed. The test 'run/util_mmio' also tests these new features heavily.
2012-01-14 01:42:45 +00:00
off_t offset;
Simplify interface of the MMIO framework, ref #69 Parameterize register and bitfield templates to always take their bitwidth instead of the according types or width exponents as arguments.
2012-01-17 17:55:24 +00:00
if (REGISTER_ARRAY::ITEM_WIDTH == REGISTER_ARRAY::ACCESS_WIDTH) {
Review doc and style for release. ref #69
2012-02-22 15:14:41 +00:00
offset = REGISTER_ARRAY::OFFSET
+ (index << REGISTER_ARRAY::ITEM_WIDTH_LOG2);
Simplify interface of the MMIO framework, ref #69 Parameterize register and bitfield templates to always take their bitwidth instead of the according types or width exponents as arguments.
2012-01-17 17:55:24 +00:00
_write<typename REGISTER_ARRAY::access_t>(offset, value);
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
Boolean fields and strict write on Registers/MMIO
2012-05-24 09:56:54 +00:00
/* Access width and item width differ */
Replace 'Subreg_array' with 'Reg_array'. 'Reg_array' contains items whose width can be the width of the register storage type at a max. Nethertheless they can be smaller and iterate all subregs that are covered by the item width. The array uses as much successive instances of its storage type as needed. The test 'run/util_mmio' also tests these new features heavily.
2012-01-14 01:42:45 +00:00
} else {
long unsigned shift;
Beautify class names in 'register.h' and 'mmio.h' Replace 'Reg_array' in 'Genode::Mmio' by 'Register_array' and 'Subreg' in 'Genode::Register', 'Genode::Mmio::Register'and 'Genode::Mmio::Register_array' by 'Bitfield'. Update and beautify comments in the according headers and test programs.
2012-01-17 08:47:23 +00:00
REGISTER_ARRAY::access_dest(offset, shift, index);
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
Boolean fields and strict write on Registers/MMIO
2012-05-24 09:56:54 +00:00
/* Insert new value into old register value */
typename REGISTER_ARRAY::access_t write_value;
if (REGISTER_ARRAY::STRICT_WRITE)
{
/* We must only apply the bitfield to an empty write pattern */
write_value = 0;
} else {
/* We've got to apply the bitfield to the old register value */
write_value = _read<typename REGISTER_ARRAY::access_t>(offset);
write_value &= ~(REGISTER_ARRAY::ITEM_MASK << shift);
}
/* Apply bitfield value and override register */
write_value |= (value & REGISTER_ARRAY::ITEM_MASK) << shift;
_write<typename REGISTER_ARRAY::access_t>(offset, write_value);
Replace 'Subreg_array' with 'Reg_array'. 'Reg_array' contains items whose width can be the width of the register storage type at a max. Nethertheless they can be smaller and iterate all subregs that are covered by the item width. The array uses as much successive instances of its storage type as needed. The test 'run/util_mmio' also tests these new features heavily.
2012-01-14 01:42:45 +00:00
}
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
}
Beautify class names in 'register.h' and 'mmio.h' Replace 'Reg_array' in 'Genode::Mmio' by 'Register_array' and 'Subreg' in 'Genode::Register', 'Genode::Mmio::Register'and 'Genode::Mmio::Register_array' by 'Bitfield'. Update and beautify comments in the according headers and test programs.
2012-01-17 08:47:23 +00:00
/*****************************************************
** Access to bitfields within register array items **
*****************************************************/
Replace 'Subreg_array' with 'Reg_array'. 'Reg_array' contains items whose width can be the width of the register storage type at a max. Nethertheless they can be smaller and iterate all subregs that are covered by the item width. The array uses as much successive instances of its storage type as needed. The test 'run/util_mmio' also tests these new features heavily.
2012-01-14 01:42:45 +00:00
Beautify class names in 'register.h' and 'mmio.h' Replace 'Reg_array' in 'Genode::Mmio' by 'Register_array' and 'Subreg' in 'Genode::Register', 'Genode::Mmio::Register'and 'Genode::Mmio::Register_array' by 'Bitfield'. Update and beautify comments in the according headers and test programs.
2012-01-17 08:47:23 +00:00
template <typename ARRAY_BITFIELD>
Review doc and style for release. ref #69
2012-02-22 15:14:41 +00:00
void
Genode::Mmio::write(typename ARRAY_BITFIELD::Compound_array::access_t const value,
long unsigned const index)
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
{
Boolean fields and strict write on Registers/MMIO
2012-05-24 09:56:54 +00:00
/* Initialize the pattern that is finally written to the register */
Beautify class names in 'register.h' and 'mmio.h' Replace 'Reg_array' in 'Genode::Mmio' by 'Register_array' and 'Subreg' in 'Genode::Register', 'Genode::Mmio::Register'and 'Genode::Mmio::Register_array' by 'Bitfield'. Update and beautify comments in the according headers and test programs.
2012-01-17 08:47:23 +00:00
typedef typename ARRAY_BITFIELD::Compound_array Register_array;
Boolean fields and strict write on Registers/MMIO
2012-05-24 09:56:54 +00:00
typename Register_array::access_t write_value;
if (Register_array::STRICT_WRITE)
{
/* We must only apply the bitfield to an empty write pattern */
write_value = 0;
} else {
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
Boolean fields and strict write on Registers/MMIO
2012-05-24 09:56:54 +00:00
/* We've got to apply the bitfield to the old register value */
write_value = read<Register_array>(index);
ARRAY_BITFIELD::clear(write_value);
}
/* Apply bitfield value and override register */
ARRAY_BITFIELD::set(write_value, value);
write<Register_array>(write_value, index);
Replace 'Subreg_array' with 'Reg_array'. 'Reg_array' contains items whose width can be the width of the register storage type at a max. Nethertheless they can be smaller and iterate all subregs that are covered by the item width. The array uses as much successive instances of its storage type as needed. The test 'run/util_mmio' also tests these new features heavily.
2012-01-14 01:42:45 +00:00
}
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
Beautify class names in 'register.h' and 'mmio.h' Replace 'Reg_array' in 'Genode::Mmio' by 'Register_array' and 'Subreg' in 'Genode::Register', 'Genode::Mmio::Register'and 'Genode::Mmio::Register_array' by 'Bitfield'. Update and beautify comments in the according headers and test programs.
2012-01-17 08:47:23 +00:00
template <typename ARRAY_BITFIELD>
Review doc and style for release. ref #69
2012-02-22 15:14:41 +00:00
typename ARRAY_BITFIELD::Compound_array::access_t
Genode::Mmio::read(long unsigned const index) const
Replace 'Subreg_array' with 'Reg_array'. 'Reg_array' contains items whose width can be the width of the register storage type at a max. Nethertheless they can be smaller and iterate all subregs that are covered by the item width. The array uses as much successive instances of its storage type as needed. The test 'run/util_mmio' also tests these new features heavily.
2012-01-14 01:42:45 +00:00
{
Beautify class names in 'register.h' and 'mmio.h' Replace 'Reg_array' in 'Genode::Mmio' by 'Register_array' and 'Subreg' in 'Genode::Register', 'Genode::Mmio::Register'and 'Genode::Mmio::Register_array' by 'Bitfield'. Update and beautify comments in the according headers and test programs.
2012-01-17 08:47:23 +00:00
typedef typename ARRAY_BITFIELD::Compound_array Array;
Simplify interface of the MMIO framework, ref #69 Parameterize register and bitfield templates to always take their bitwidth instead of the according types or width exponents as arguments.
2012-01-17 17:55:24 +00:00
typedef typename Array::access_t access_t;
Beautify class names in 'register.h' and 'mmio.h' Replace 'Reg_array' in 'Genode::Mmio' by 'Register_array' and 'Subreg' in 'Genode::Register', 'Genode::Mmio::Register'and 'Genode::Mmio::Register_array' by 'Bitfield'. Update and beautify comments in the according headers and test programs.
2012-01-17 08:47:23 +00:00
return ARRAY_BITFIELD::get(read<Array>(index));
First version of generic MMIO access framework The MMIO access framework consists of an abstraction for a contiguous MMIO area with a base address set dynamically. Within this class 'Mmio' are declarations for 'Register' and 'Subreg'. These two can be parameterized statically via template parameters to create arbitrary MMIO structures. Whereas 'Register' relies to a POD like subregion of 'Mmio', 'Subreg' relies to a MMIO region within a specific 'Register' and therefore is smaller or equal then the storage type of its superior 'Register'. Furthermore with 'Reg_array' and 'Subreg_array', there exists the possibility to handle arrays of uniform contiguous registers or subregs by index. 'Subreg_array' therefore abstracts from the width boundary of its superior 'Register' and handles a steady distance between its members in addition. Both also check array size limits. Related to issue #69.
2012-01-09 12:29:03 +00:00
}
#endif /* _BASE__INCLUDE__UTIL__MMIO_H_ */
Extract more generic parts from 'Genode::Mmio' To accommodate CPU registers, which have a structured layout but don't depend on a region base address, this patch introduces the generic 'Genode::Register' and 'Genode::Subreg' to 'register.h'. 'Mmio::Register' and 'Mmio::Subreg' inherit from them.
2012-01-09 20:05:49 +00:00
Reference in New Issue Copy Permalink