Initial commit of OpenSPARC T2 architecture model.

[OpenSPARC-T2-SAM] / sam-t2 / sam / cpus / vonk / bl / lib / ecc / src / BL_Hsiao_256_10_Synd.h

/*
* ========== Copyright Header Begin ==========================================
* 
* OpenSPARC T2 Processor File: BL_Hsiao_256_10_Synd.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 ============================================
*/
/************************************************************************
 **  
 **  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.
 **
 *************************************************************************/
#ifndef __BL_Hsiao_256_10_Synd_h__
#define __BL_Hsiao_256_10_Synd_h__
#include "BL_Utils.h"
#include "BL_BaseSynd.h"
#include "BL_HsiaoEcc.h"

class BL_Hsiao_256_10_Synd : public BL_BaseSynd
{
  public:	

    BL_Hsiao_256_10_Synd(uint32_t syndrome) : BL_BaseSynd(syndrome)
    {
      if (syndrome > 0x3ff)
      {
        fprintf(stderr,"ERROR: Bad Syndrome: 0x%x", syndrome);
        exit(-1);	      
      }
    }

    BL_Hsiao_256_10_Synd(BL_Uint256 data, BL_EccBits ecc) :
      BL_BaseSynd(BL_Hsiao_256_10_Synd::calc_check_bits(data).get() ^ ecc.get())
    {}


    ~BL_Hsiao_256_10_Synd() {}

    bool isDoubleBitError() const 
    {
      return (syndrome_ != 0) && !isSingleBitError();
    }

    bool isSingleBitError() const
    {
      if (syndrome_ == 0)
        return false;
      switch (nr_bits_set())
      {
      case 1:
      case 3:
        return true;
      case 5:
        return find_syndrome_ndx() != -1;
      default:
        return false;
      }
    }

    bool isDataBitError() const 
    {
      return (isSingleBitError() && nr_bits_set() > 1);
    }

    // This method works because the check bits are at powers of 2
    // (after substracting 0x80) so the data bits break up into
    // large ranges.
    uint32_t getDataBit() const 
    {
      if (!isDataBitError())
      {
        fprintf(stderr,"ERROR: Not data bit error!");
        exit(-1);	      
      }	      
	
      return find_syndrome_ndx();
    }
    
    bool isCheckBitError() const 
    {
      return (isSingleBitError() && is_power_of_two(syndrome_));
    }

    uint32_t getCheckBit() const 
    {
      if (!isCheckBitError())
      {
        fprintf(stderr,"ERROR: Not check bit error!");
        exit(-1);	      
      }	      
      return bit2idx(syndrome_);	
    }

    bool isMultipleBitError() const { return false; }

    static BL_EccBits calc_check_bits(BL_Uint256 data)
    {
      BL_Uint256 *patterns =
        BL_Hsiao_256_10_Synd::hsiao_256_10_patterns.patterns;
      return calc_checks(10, patterns, data);

    }

  private:

    BL_Hsiao_256_10_Synd();    

    // Number of bits set in syndrome
    // This trick works up to 12 bits
    uint_t nr_bits_set() const
    {
      return (syndrome_ * 0x1001001001001ULL & 0x84210842108421ULL) % 0x1f;
    }

    int find_syndrome_ndx() const
    {
      switch (nr_bits_set())
      {
      case 3:
        for (uint_t ndx = 0; ndx < 120; ++ndx)
          if (syndrome_ == hsiao_256_10_patterns.get(ndx).get())
            return ndx;
        assert(0);
        break;
      case 5:
        for (uint_t ndx = 120; ndx < 256; ++ndx)
          if (syndrome_ == hsiao_256_10_patterns.get(ndx).get())
            return ndx;
      default:
        break;
      }
      return -1;                // -1 is didn't find it
    }

   class Patterns
    {
      public:
        BL_Uint256         patterns[10];

        Patterns();

        ~Patterns() {}

        BL_EccBits get(uint_t ndx) const { return syndromes[ndx]; }

      private:

        static uint64_t calc_pattern(uint_t syndrome_ndx, uint_t pattern_ndx);

        static BL_EccBits syndromes[256];
    };

    static Patterns     hsiao_256_10_patterns;

};

#endif