Initial commit of OpenSPARC T2 architecture model.

[OpenSPARC-T2-SAM] / sam-t2 / sam / cpus / vonk / ss / lib / csr / src / SS_CsrAccess.h

/*
* ========== Copyright Header Begin ==========================================
* 
* OpenSPARC T2 Processor File: SS_CsrAccess.h
* Copyright (c) 2006 Sun Microsystems, Inc.  All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES.
* 
* The above named program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public
* License version 2 as published by the Free Software Foundation.
* 
* The above named program 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
* General Public License for more details.
* 
* You should have received a copy of the GNU General Public
* License along with this work; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
* 
* ========== Copyright Header End ============================================
*/
#ifndef SS_CSR_ACCESS_H
#define SS_CSR_ACCESS_H
/************************************************************************
**
**  Copyright (C) 2006, Sun Microsystems, Inc.
**
**  Sun considers its source code as an unpublished, proprietary
**  trade secret and it is available only under strict license provisions.
**  This copyright notice is placed here only to protect Sun in the event
**  the source is deemed a published work. Disassembly, decompilation,
**  or other means of reducing the object code to human readable form
**  is prohibited by the license agreement under which this code is
**  provided to the user or company in possession of this copy.
**
*************************************************************************/
#include "SS_Csr.h"
#include "SS_Strand.h"
#include "MemoryTransaction.h"

template <typename T>
class SS_CsrAccess 
{
 public:
   SS_CsrAccess(SS_Csr& csr) : 
     csr_(csr) {}
   virtual ~SS_CsrAccess() {}
   const SS_CsrAccess<T> & operator=( const SS_CsrAccess<T> &rhs ) 
   {
     fprintf(stderr, "ERROR: SS_CsrAccess<T> & operator=(): Unimplemented function\n");
     return *this;
   }

   /* Access a CSR at index 0 */
   bool access(T &csr, bool isRead) {
       return access(0, csr, isRead);
   }

   /* Access a CSR at ndx for read or write.
    *
    * The CSR is indexed relative to its base address, using its
    * memory stride.  This information is set by the CSR's class and
    * defined by the PRM.
    */
   bool access(uint64_t ndx, T &csr, bool isRead) {
       SS_Strand* strand = NULL; //TODO  need a valid strand-id
       uint64_t data = 0;
       uint64_t pa = T::BaseAddress + ndx * T::Stride;

       if (ndx >= T::Count) {
           fprintf(stderr, "ERROR: SS_CsrAccess::access(): Out of bounds index %d\n", ndx);
           return true;
       }

       int access = MemoryTransaction::INTERNAL;
       if (isRead) {
           int state = csr_.read64(pa, &data, (access|MemoryTransaction::READ), 0/*(strand->strand_id()*/);
           // if the Csr hasn't been set, use the reset value
           if (state != SS_Io::OK){
               T tmp;
               csr = tmp;
           } else {
               csr.set_data(data);
           }
       }
       else {
           data = csr.getNative();
           csr_.write64(pa, data, (access|MemoryTransaction::WRITE), 0/*strand->strand_id()*/);
       }
       return true;
   }

   /* Return the CSR's raw 64-bit at index, ndx. */
   uint64_t getNative(uint64_t ndx) {
       T csr;
       access(ndx, csr, true);
       return csr.getNative();
   }

   /* Ptr-to-member-function types used to access CSR's bitfields. */
   typedef uint64_t (T::*GetFn)(void) const;
   typedef void (T::*SetFn)(uint64_t);

   /* Return the CSR's bitfield associated with getFn() at index 0. */
   uint64_t get(GetFn getFn) {
       return get(0, getFn);
   }

   /* Return the CSR's bitfield associated with getFn() at 'ndx'. */
   uint64_t get(uint64_t ndx, GetFn getFn) {
       T csr;
       access(ndx, csr, true);
       return ((csr).*(getFn))();
   }

   /* Set the CSR at index 0 to 'value'.  Return the CSR's new result. */
   T setNative(uint64_t ndx, uint64_t value) {
       T csr;
       csr.setNative(value);
       access(ndx, csr, false);
       return csr;
   }

   /* Set the CSR's bitfield associated with setFn at index 0 to ones.
    * Return the CSR's new result.
    */
   T set(SetFn setFn) {
       return set(0, setFn, ~0ULL);
   }

   /* Set the CSR's bitfield associated with setFn at index 0 to 'value'.
    * Return the CSR's new result.
    */
   T set(SetFn setFn, uint64_t value) {
       return set(0, setFn, value);
   }

   /* Set the CSR's bitfield associated with setFn at 'ndx' to ones.
    * Return the CSR's new result.
    */
   T set(uint64_t ndx, SetFn setFn) {
       T csr;
       access(ndx, csr, true);
       ((csr).*(setFn))(~0ULL);
       access(ndx, csr, false);
       return csr;
   }

   /* Set the CSR's bitfield associated with setFn at 'ndx' to 'value'.
    * Return the CSR's new result.
    */
   T set(uint64_t ndx, SetFn setFn, uint64_t value) {
       T csr;
       access(ndx, csr, true);
       ((csr).*(setFn))(value);
       access(ndx, csr, false);
       return csr;
   }

 private:
   SS_CsrAccess();

   SS_Csr& csr_;       
};

#endif /* SS_CSR_ACCESS_H */