TemplateRegister.hpp

/***************************************************************************
  tag: Peter Soetens  Sat May 21 20:15:51 CEST 2005  TemplateRegister.hpp

                        TemplateRegister.hpp -  description
                           -------------------
    begin                : Sat May 21 2005
    copyright            : (C) 2005 Peter Soetens
    email                : peter.soetens@mech.kuleuven.ac.be

 ***************************************************************************
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place,                                    *
 *   Suite 330, Boston, MA  02111-1307  USA                                *
 *                                                                         *
 ***************************************************************************/


#ifndef ORO_TEMPLATEREGISTER_HPP
#define ORO_TEMPLATEREGISTER_HPP

namespace RTT
{
#define ORO_REG_BIT_DEFN(start, end) (( start << 16)|(end-start+1))

    template<typename RegType, class Size, unsigned int BaseAddress_ = 0>
    struct TemplateRegister
    {
        typedef unsigned int uint32_t;

        TemplateRegister() {}

        //unsigned int BaseAddress;

        inline volatile Size *regAddress(RegType reg)
        {
            return reinterpret_cast<volatile Size*>(BaseAddress_ + reg);
        }

        inline Size regRead(RegType reg)
        {
            return *regAddress(reg);
        }

        inline void regWrite(RegType reg, Size value)
        {
            *regAddress(reg) = value;
        }

        inline uint32_t bitRead( RegType reg, uint32_t bits)
        {
            uint32_t       regval = *regAddress(reg);
            const uint32_t width  = bits & 0xff;
            const uint32_t bitno  = bits >> 16;
            regval >>= bitno;
            regval  &= ((1<<width)-1);
            return regval;
        }

        inline void bitWrite(RegType reg, uint32_t bits, uint32_t value)
        {
            uint32_t           regval = *regAddress(reg);
            const uint32_t     width  = bits & 0xff;
            const uint32_t     bitno  = bits >> 16;
            regval &= ~(((1<<width)-1) << bitno);
            regval |=  value << bitno;
            *regAddress(reg) = regval;
        }

    };

    template<typename RegType, class Size>
    struct TemplateRegister<RegType,Size,0>
    {
        typedef unsigned int uint32_t;

        unsigned int BaseAddress;

        TemplateRegister( unsigned int base_address )
            : BaseAddress(base_address)
        {}

        inline volatile Size *regAddress(RegType reg)
        {
            return reinterpret_cast<volatile Size*>(BaseAddress + reg);
        }

        inline Size regRead(RegType reg)
        {
            return *regAddress(reg);
        }

        inline void regWrite(RegType reg, Size value)
        {
            *regAddress(reg) = value;
        }

        inline uint32_t bitRead( RegType reg, uint32_t bits)
        {
            uint32_t       regval = *regAddress(reg);
            const uint32_t width  = bits & 0xff;
            const uint32_t bitno  = bits >> 16;
            regval >>= bitno;
            regval  &= ((1<<width)-1);
            return regval;
        }

        inline void bitWrite(RegType reg, uint32_t bits, uint32_t value)
        {
            uint32_t           regval = *regAddress(reg);
            const uint32_t     width  = bits & 0xff;
            const uint32_t     bitno  = bits >> 16;
            regval &= ~(((1<<width)-1) << bitno);
            regval |=  value << bitno;
            *regAddress(reg) = regval;
        }

    };



}


#endif

---