Hey Johannes,
I could not get it out of my mind. What do you think of the following
solution scheme:
~~~util/io_space.h~~~
template <typename IO>
class Io_space
{
..
public:
Io_space(IO &io) ..
template .. struct Register ..;
template .. struct Register_array ..;
template .. read(..) { .. _io._read(..); .. }
template .. write(..) { .. _io._write(..); .. }
..
};
~~~util/mmio.h~~~
class Mmio : public Io_space<Mmio>
{
friend class Io_space<Mmio>;
private:
template .. _read(..) { .. }
template .. _write(..) { .. }
public:
Mmio_b(addr_t base) : Io_space<Mmio_accessor>(*this) ..
};
~~~i2c_io.h~~~
class I2c_io : public Io_space<I2c_io> { .. };
~~~~~~
This would keep the back-end hidden and enable diversification.
Cheers,
Martin
Am 08.12.2016 um 15:37 schrieb Martin Stein:
> Hi Johannes,
>
> We actually had an internal discussion about such an approach. As far as
> I remember, it was in the context of the Zynq drivers. I absolutely like
> the idea of using the Mmio framework with different back-ends. I think
> you would have to exchange merely the two raw-access methods of the
> framework:
>
> ! template <typename _ACCESS_T>
> ! void Mmio::_write(off_t const, _ACCESS_T const)'
> !
> ! template <typename _ACCESS_T>
> ! _ACCESS_T Mmio::_read(off_t const) const
>
> The read<>() and write<>() methods you mention should not contain any
> code that depends on the way of accessing registers but only the bit and
> offset logic that could be reused.
>
> I'm curious about the outcome of your idea and help willingly if you
> have further questions.
>
> Cheers,
> Martin
>
> Am 07.12.2016 um 18:26 schrieb Johannes Schlatow:
>> Hi,
>>
>> I really like Genode's Register API as it makes accessing memory mapped
>> hardware registers quite clean and simple.
>>
>> However, I recently encountered the need to access a rather complex I2C
>> slave device. The I2C controller itself is accessible via MMIO. Yet, the
>> slave device itself has a notion of registers. Basically, you first send the
>> register address to the I2C slave and, in a second transaction, you can
>> read/write the register's value.
>>
>> Being used to the clean appearance of MMIO in Genode, I was wondering
>> whether the access to I2C slave registers could be wrapped in a similar way.
>> My intuition is that it might simply suffice to inherit from the Mmio class
>> and modify the write<>() and read<>() functions but haven't checked the code
>> in detail. Any suggestions/ideas?
>>
>> Cheers
>> Johannes
>>
>> ------------------------------------------------------------------------------
>> Developer Access Program for Intel Xeon Phi Processors
>> Access to Intel Xeon Phi processor-based developer platforms.
>> With one year of Intel Parallel Studio XE.
>> Training and support from Colfax.
>> Order your platform today.http://sdm.link/xeonphi
>> _______________________________________________
>> genode-main mailing list
>> genode-main@lists.sourceforge.net
>> https://lists.sourceforge.net/lists/listinfo/genode-main
>>
>
> ------------------------------------------------------------------------------
> Developer Access Program for Intel Xeon Phi Processors
> Access to Intel Xeon Phi processor-based developer platforms.
> With one year of Intel Parallel Studio XE.
> Training and support from Colfax.
> Order your platform today.http://sdm.link/xeonphi
> _______________________________________________
> genode-main mailing list
> genode-main@lists.sourceforge.net
> https://lists.sourceforge.net/lists/listinfo/genode-main
>
------------------------------------------------------------------------------
Developer Access Program for Intel Xeon Phi Processors
Access to Intel Xeon Phi processor-based developer platforms.
With one year of Intel Parallel Studio XE.
Training and support from Colfax.
Order your platform today.http://sdm.link/xeonphi
_______________________________________________
genode-main mailing list
genode-main@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/genode-main
