ExternalVendorCode/genode
1
0
Fork 0
mirror of https://github.com/genodelabs/genode.git synced 2024-12-20 06:07:59 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
f01f42fdd7
genode/base/include/util/mmio.h

439 lines
12 KiB
C
Raw Normal View History

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