Initial commit of OpenSPARC T2 architecture model.

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

/*
* ========== Copyright Header Begin ==========================================
* 
* OpenSPARC T2 Processor File: SS_AddressMap.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_AddressMap_h__
#define __SS_AddressMap_h__

#include "BL_BitUtility.h"
#include "SS_Types.h"
#include "SS_Access.h"

class SS_AddressMap
{
 public:
   SS_AddressMap();
   ~SS_AddressMap();

   // Address is the type that describes how objects registered
   // with the SS_AddressMap should be addressed. Two modes are
   // available: relative or absolute. Relative addressed objects
   // can have only one add (one lo to hi range). Absolute objects 
   // can have multiple add's. Relative addressed objects are in
   // general reusable objects, absolute addressed object are far
   // more limited in their reuse, however, can be registers at
   // multiple address ranges.

   enum Addressing
   {
     REL,      // Registered object is base relative addressed 
     ABS       // Registered object is absolute addressed
   };

   // add() maps a object obj in the address range from lo to hi inclusive.
   // The cpu argument is for strand (cpu) access. The extra usr agrument is 
   // for optinally different behaviour by frontend (usr) access.
   // If usr is not given then it defaults to cpu. The rel flags indicated 
   // whether obj needs to be addressed relative or absolute. 

   void add( SS_Paddr lo, SS_Paddr hi, void* obj, Addressing rel, 
             SS_Access::Func cpu, SS_Access::Func usr=0 );

   // overwrite the default range_object_not_found routine
   void set_fail( void* obj, SS_Access::Func cpu, SS_Access::Func usr=0 )
   {
     SS_AddressMap::fail->obj = obj;
     SS_AddressMap::fail->fun_cpu = cpu;
     SS_AddressMap::fail->fun_usr = usr ? usr : cpu;
   }

 protected:
   // The ld(), st(), rd() and wr() access methods expect to get size
   // arguments that are a power of two, and the pa to be aligned to 
   // the size. When addresses, the object sees the relative address:
   // e.g. pa - lo (lo is the low address provided to add()).

   void cpu( uint_t sid, SS_Access::Type type, SS_Paddr pa, uint_t size, uint64_t* data )
   {
     assert(SS_Access::ok(type,pa,size));
     find(pa)->cpu(sid,type,pa,size,data);
   }
   void usr( uint_t sid, SS_Access::Type type, SS_Paddr pa, uint_t size, uint64_t* data )
   {
     assert(SS_Access::ok(type,pa,size));
     find(pa)->usr(sid,type,pa,size,data);
   }

   class Range
   {
     public:
       Range() 
        : 
         lo(0), 
         hi(0), 
         obj(0), 
         rel(SS_AddressMap::REL),
         fun_cpu(0), 
         fun_usr(0) 
       {}
       Range( SS_Paddr _lo, SS_Paddr _hi, void* _obj, SS_AddressMap::Addressing _rel, 
              SS_Access::Func _cpu, SS_Access::Func _usr )
        : 
         lo(_lo), 
         hi(_hi), 
         rel(_rel),
         obj(_obj), 
         fun_cpu(_cpu), 
         fun_usr(_usr) 
       {}

       SS_Paddr                   lo;
       SS_Paddr                   hi;
       void*                      obj;
       SS_AddressMap::Addressing  rel;
       SS_Access::Func            fun_cpu;     
       SS_Access::Func            fun_usr;

       bool in_range( SS_Paddr pa )    { return (lo <= pa) && (pa <= hi); }

       void cpu( uint_t sid, SS_Access::Type type, SS_Paddr pa, uint_t size, uint64_t* data )  
       { 
         (fun_cpu)(obj,sid,type,(rel == SS_AddressMap::REL) ? (pa - lo) : pa,size,data); 
       }
       void usr( uint_t sid, SS_Access::Type type, SS_Paddr pa, uint_t size, uint64_t* data )  
       { 
         (fun_usr)(obj,sid,type,(rel == SS_AddressMap::REL) ? (pa - lo) : pa,size,data); 
       }
   };

   static void no_access( void*, uint_t, SS_Access::Type, SS_Paddr, uint_t size, uint64_t* data );

   Range* find( SS_Paddr pa )
   {
     if (_size == 0)
       return SS_AddressMap::fail;
     
     uint_t l = 0;
     uint_t h = _size;
     uint_t m = _size >> 1;
     
     Range* r = &table[m];

     while (l != m)
     {
       ((pa < r->lo) ? h : l) = m;
       m = l + ((h - l) >> 1);
       r = &table[m];
     }

     return r->in_range(pa) ? r : SS_AddressMap::fail;
   }

   enum { ALLOC = 16 };

   static Range*    fail;      // Default for failing accesses (pa not found)

   Range*   table;             // Sorted table of ranges
   uint_t   alloc;             // Number of allocated ranges
   uint_t   _size;             // Number of added ranges
};

#endif