ehmry/genode
ehmry/genode
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
70ae53fe3c
genode/base/include/util/mmio.h

401 lines
11 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 13:29:03 +01: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 02:42:45 +01: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 13:29:03 +01: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 12:56:45 +01: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 13:29:03 +01:00
#ifndef _BASE__INCLUDE__UTIL__MMIO_H_
#define _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 21:05:49 +01: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 13:29:03 +01: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 09:47:23 +01: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 13:29:03 +01: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 18:55:24 +01:00
template <typename _ACCESS_T>
inline void _write(off_t const o, _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 13:29:03 +01: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 18:55:24 +01:00
template <typename _ACCESS_T>
inline _ACCESS_T _read(off_t const o) 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 13:29:03 +01: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 02:42:45 +01: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 13:29:03 +01: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 18:55:24 +01:00
* An integer like region within a MMIO region.
*
* \param _OFFSET Offset of the region relative to the base
* of the compound MMIO.
* \param _ACCESS_WIDTH Bit width of the region.
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 09:47:23 +01: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 18:55:24 +01: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 13:29:03 +01: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 18:55:24 +01:00
template <off_t _OFFSET, unsigned long _ACCESS_WIDTH>
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 13:29:03 +01: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 18:55:24 +01:00
enum {
OFFSET = _OFFSET,
ACCESS_WIDTH = _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 13:29:03 +01: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 18:55:24 +01:00
* A region within a 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 02:42:45 +01: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 18:55:24 +01:00
* \param _SHIFT Bit shift of the first bit within the compound register
* \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 13:29:03 +01: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 18:55:24 +01:00
template <unsigned long _SHIFT, unsigned long _WIDTH>
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 13:29:03 +01:00
{
/**
* Back reference to containing 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 18:55:24 +01:00
typedef Register<OFFSET, ACCESS_WIDTH> 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 13:29:03 +01: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 02:42:45 +01: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 13:29:03 +01: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 02:42:45 +01: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 18:55:24 +01:00
* An array of successive equally structured regions
*
* \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
* \param _ITEM_WIDTH Bit width of a 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 02:42:45 +01: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 18:55:24 +01: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 02:42:45 +01: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 18:55:24 +01:00
template <off_t _OFFSET, unsigned long _ACCESS_WIDTH, unsigned long _ITEMS, unsigned long _ITEM_WIDTH>
struct Register_array : public Register<_OFFSET, _ACCESS_WIDTH>
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 02:42:45 +01: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 18:55:24 +01:00
typedef typename Trait::Uint_type<_ACCESS_WIDTH>::template Divisor<_ITEM_WIDTH> 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 02:42:45 +01:00
enum {
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 18:55:24 +01: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 02:42:45 +01: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 13:29:03 +01: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 18:55:24 +01:00
typedef typename Register<OFFSET, ACCESS_WIDTH>::access_t access_t;
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 02:42:45 +01: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 18:55:24 +01: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 02:42:45 +01: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 18:55:24 +01: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 02:42:45 +01: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 18:55:24 +01:00
template <unsigned long _SHIFT, unsigned long _SIZE>
struct Bitfield : public Register<OFFSET, ACCESS_WIDTH>::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 02:42:45 +01: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 13:29:03 +01: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 02:42:45 +01:00
* Back reference to containing 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 13:29:03 +01: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 18:55:24 +01:00
typedef Register_array<OFFSET, ACCESS_WIDTH, ITEMS, ITEM_WIDTH> 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 13:29:03 +01: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 02:42:45 +01:00
/**
* Calculate the MMIO-relative offset 'offset' and shift 'shift'
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 18:55:24 +01:00
* within the according 'access_t' instance to access item '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 02:42:45 +01:00
*/
static inline void access_dest(off_t & offset, unsigned long & shift,
unsigned long const index)
{
unsigned long const bit_off = index << 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 18:55:24 +01: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 02:42:45 +01: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 18:55:24 +01: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 02:42:45 +01: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 13:29:03 +01: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 02:42:45 +01: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 13:29:03 +01:00
/**
* Typed address of register 'REGISTER'
*/
template <typename 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 18:55:24 +01:00
inline typename REGISTER::access_t volatile * typed_addr() 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 13:29:03 +01:00
/**
* Read the whole register 'REGISTER'
*/
template <typename 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 18:55:24 +01:00
inline typename REGISTER::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 13:29:03 +01: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 02:42:45 +01: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 09:47:23 +01: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 02:42:45 +01:00
*/
template <typename 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 18:55:24 +01:00
inline void write(typename REGISTER::access_t const 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 02:42:45 +01: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 09:47:23 +01: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 02:42:45 +01: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 13:29:03 +01: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 09:47:23 +01: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 13:29:03 +01: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 09:47:23 +01: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 18:55:24 +01: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 13:29:03 +01: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 09:47:23 +01: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 13:29:03 +01: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 09:47:23 +01: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 18:55:24 +01: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 13:29:03 +01: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 02:42:45 +01: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 13:29:03 +01: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 09:47:23 +01: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 13:29:03 +01: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 09:47:23 +01: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 18:55:24 +01: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 13:29:03 +01: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 09:47:23 +01: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 13:29:03 +01: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 09:47:23 +01: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 18:55:24 +01: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 13:29:03 +01: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 02:42:45 +01: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 09:47:23 +01: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 02:42:45 +01: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 13:29:03 +01: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 09:47:23 +01: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 13:29:03 +01: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 09:47:23 +01:00
template <typename ARRAY_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 18:55:24 +01: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 13:29:03 +01: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 09:47:23 +01: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 13:29:03 +01: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 09:47:23 +01:00
template <typename ARRAY_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 18:55:24 +01:00
inline void 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 13:29:03 +01: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 18:55:24 +01:00
template <typename ACCESS_T>
void Genode::Mmio::_write(off_t const o, 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 13:29:03 +01: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 18:55:24 +01:00
*(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 13:29:03 +01: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 18:55:24 +01:00
template <typename ACCESS_T>
ACCESS_T Genode::Mmio::_read(off_t const o) 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 13:29:03 +01: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 18:55:24 +01:00
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 13:29:03 +01: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 02:42:45 +01:00
/*************************
** 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 13:29:03 +01:00
template <typename 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 18:55:24 +01:00
typename REGISTER::access_t volatile * Genode::Mmio::typed_addr() 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 13:29:03 +01: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 18:55:24 +01:00
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 13:29:03 +01:00
}
template <typename 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 18:55:24 +01:00
typename REGISTER::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 13:29:03 +01: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 18:55:24 +01:00
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 13:29:03 +01: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 02:42:45 +01:00
template <typename 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 18:55:24 +01:00
void Genode::Mmio::write(typename REGISTER::access_t const 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 02:42:45 +01: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 18:55:24 +01:00
_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 02:42:45 +01: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 09:47:23 +01: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 02:42:45 +01: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 09:47:23 +01: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 18:55:24 +01: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 13:29:03 +01: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 09:47:23 +01: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 18:55:24 +01:00
typedef typename Register::access_t access_t;
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 13:29:03 +01: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 18:55:24 +01:00
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 13:29:03 +01: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 09:47:23 +01: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 18:55:24 +01: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 13:29:03 +01: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 09:47:23 +01: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 18:55:24 +01:00
typedef typename Register::access_t access_t;
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 13:29:03 +01: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 18:55:24 +01:00
access_t new_reg = read<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 09:47:23 +01:00
BITFIELD::clear(new_reg);
BITFIELD::set(new_reg, 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 13:29:03 +01: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 02:42:45 +01:00
write<Register>(new_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 13:29:03 +01: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 02:42:45 +01: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 09:47:23 +01: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 18:55:24 +01: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 13:29:03 +01: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 02:42:45 +01:00
/**
* Handle array overflow
*/
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 09:47:23 +01: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 13:29:03 +01: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 02:42:45 +01:00
off_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 13:29:03 +01: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 02:42:45 +01: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 18:55:24 +01:00
* Optimize access if item width equals access width
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 02:42:45 +01: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 18:55:24 +01:00
if (REGISTER_ARRAY::ITEM_WIDTH == REGISTER_ARRAY::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 13:29:03 +01: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 09:47:23 +01: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 18:55:24 +01: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 13:29:03 +01: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 02:42:45 +01:00
} 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 13:29:03 +01: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 02:42:45 +01:00
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 09:47:23 +01:00
REGISTER_ARRAY::access_dest(offset, shift, index);
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 18:55:24 +01: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 02:42:45 +01: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 13:29:03 +01: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 09:47:23 +01: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 18:55:24 +01: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 13:29:03 +01: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 02:42:45 +01:00
/**
* Avoid array overflow
*/
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 09:47:23 +01: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 13:29:03 +01: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 02:42:45 +01:00
off_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 13:29:03 +01: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 02:42:45 +01: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 18:55:24 +01:00
* Optimize access if item width equals access width
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 02:42:45 +01: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 18:55:24 +01:00
if (REGISTER_ARRAY::ITEM_WIDTH == REGISTER_ARRAY::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 13:29:03 +01: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 09:47:23 +01: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 18:55:24 +01: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 13:29:03 +01: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 02:42:45 +01:00
} 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 13:29:03 +01: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 02:42:45 +01:00
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 09:47:23 +01: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 13:29:03 +01: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 02:42:45 +01:00
/**
* Insert new value into old register value
*/
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 18:55:24 +01:00
typename REGISTER_ARRAY::access_t new_reg = _read<typename REGISTER_ARRAY::access_t>(offset);
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 09:47:23 +01:00
new_reg &= ~(REGISTER_ARRAY::ITEM_MASK << shift);
new_reg |= (value & REGISTER_ARRAY::ITEM_MASK) << 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 02:42:45 +01: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 18:55:24 +01:00
_write<typename REGISTER_ARRAY::access_t>(offset, new_reg);
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 02:42:45 +01: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 13:29:03 +01: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 09:47:23 +01: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 02:42:45 +01: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 09:47:23 +01:00
template <typename ARRAY_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 18:55:24 +01:00
void Genode::Mmio::write(typename ARRAY_BITFIELD::Compound_array::access_t const 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 02:42:45 +01:00
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 13:29:03 +01: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 09:47:23 +01:00
typedef typename ARRAY_BITFIELD::Compound_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 13:29:03 +01: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 18:55:24 +01:00
typename Register_array::access_t new_reg = read<Register_array>(index);
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 09:47:23 +01:00
ARRAY_BITFIELD::clear(new_reg);
ARRAY_BITFIELD::set(new_reg, 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 13:29:03 +01: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 09:47:23 +01:00
write<Register_array>(new_reg, 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 02:42:45 +01: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 13:29:03 +01: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 09:47:23 +01:00
template <typename ARRAY_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 18:55:24 +01: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 02:42:45 +01: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 09:47:23 +01: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 18:55:24 +01:00
typedef typename Array::access_t access_t;
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 13:29:03 +01: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 09:47:23 +01: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 13:29:03 +01: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 21:05:49 +01:00
Reference in New Issue Copy Permalink