sam-t2/sam/cpus/vonk/bl/lib/ecc/src/BL_Hamming_32_7_Synd.h

/*
* ========== Copyright Header Begin ==========================================
*
* OpenSPARC T2 Processor File: BL_Hamming_32_7_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_Hamming_32_7_Synd_h__
#define __BL_Hamming_32_7_Synd_h__
#include "BL_BaseSynd.h"
#include "BL_HammingEcc.h"

class BL_Hamming_32_7_Synd : public BL_BaseSynd
{
  public:

    BL_Hamming_32_7_Synd(uint32_t syndrome) : BL_BaseSynd(syndrome)
    {
      if (syndrome > 0x7f)
      {
        fprintf(stderr,"ERROR: Bad Syndrome!");
        exit(-1);
      }
    }

    BL_Hamming_32_7_Synd(uint32_t data, BL_EccBits ecc) :
      BL_BaseSynd(BL_HammingEcc::
                  get_hamming_32_7_synd(data,ecc.get()).getSyndrome())
    {}

    ~BL_Hamming_32_7_Synd() {}

    bool isDoubleBitError() const { return (syndrome_ - 1) < 0x3f; }

    bool isSingleBitError() const { return (syndrome_ - 0x40) < 0x27; }

    // ((syndrome_ - 0x40) & syndrome_ - 0x41)) returns true if
    // "syndrome_ - 0x40" *NOT* a power of 2.  See Table A-7 to see
    // that this is true for all data bits.
    bool isDataBitError() const
    {
      return (isSingleBitError() && ((syndrome_ - 0x40) & syndrome_ - 0x41));
    }

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

      uint32_t bit = syndrome_ - 0x40;
      if (bit >= 0x10)
        return (bit >= 0x20) ? bit - 7 : bit - 6;
      else if (bit > 8)
        return bit - 5;
      else if (bit > 4)
        return bit - 4;
      else
        return bit - 3;
    }

    // !((syndrome_ - 0x40) & syndrome_ - 0x41)) returns true
    // "syndrome_ - 0x40" is a power of 2.  See Table A-7 to see
    // that this is true for all check bits.
    bool isCheckBitError() const
    {
      return (isSingleBitError() && !((syndrome_ - 0x40) & syndrome_ - 0x41));
    }

    // This method works because the check bits are at powers of 2
    // (after substracting 0x40) so this divide and conquer search
    // is quite fast.
    uint32_t getCheckBit() const
    {
      if (!isCheckBitError())
      {
        fprintf(stderr,"ERROR: Not check bit error!");
        exit(-1);
      }

      uint32_t bit = syndrome_ - 0x40;
      if (bit >= 0x10)
        return (bit >= 0x20) ? 5 : 4;
      else if (bit == 8)
        return 3;
      else if (bit == 4)
        return 2;
      else
        return (bit == 0) ? 6 : bit - 1;
    }

    bool isMultipleBitError() const { return (syndrome_ - 0x67) < (0x19); }

    static BL_EccBits calc_check_bits(unsigned long long data)
    {
      return BL_HammingEcc::calc_check_bits(BL_HammingEcc::BL_Hamming_32_7, data);
    }

#define BL_HAMMING_32_7_DIE(S) { \
fprintf(stderr, S " line: %d\n", __LINE__); \
exit(-1); \
}

    static void validate()
    {
      uint32_t data = 0x12345678;
      uint32_t ecc = BL_Hamming_32_7_Synd::calc_check_bits(data).get();

      BL_Hamming_32_7_Synd syndrome =
        BL_HammingEcc::get_hamming_32_7_synd(data, ecc);

      if (!syndrome.noError())
        BL_HAMMING_32_7_DIE("NoError fails");

      int i;
      for (i = 0; i < 32; ++i) {
        syndrome =
          BL_HammingEcc::get_hamming_32_7_synd((1<<i)^data, ecc);

        if (syndrome.noError())
          BL_HAMMING_32_7_DIE("NoError succeeds");

        if (!syndrome.isSingleBitError())
          BL_HAMMING_32_7_DIE("isSingleBit fails");

        if (syndrome.isDoubleBitError())
          BL_HAMMING_32_7_DIE("isDoubleBit succeeds");

        if (syndrome.isMultipleBitError() || syndrome.isUncorrectableError())
          BL_HAMMING_32_7_DIE("isMultipleBit/isUncorrectable succeeds");

        if (syndrome.getDataBit() != i)
          BL_HAMMING_32_7_DIE("getDataBit mismatch");
      }

      for (i = 0; i < 7; ++i) {
        syndrome =
          BL_HammingEcc::get_hamming_32_7_synd(data, (1<<i)^ecc);

        if (syndrome.noError())
          BL_HAMMING_32_7_DIE("NoError succeeds");

        if (!syndrome.isSingleBitError())
          BL_HAMMING_32_7_DIE("isSingleBit fails");

        if (syndrome.isDoubleBitError())
          BL_HAMMING_32_7_DIE("isDoubleBit succeeds");

        if (syndrome.isMultipleBitError() || syndrome.isUncorrectableError())
          BL_HAMMING_32_7_DIE("isMultipleBit/isUncorrectable succeeds");

        if (syndrome.getCheckBit() != i)
          BL_HAMMING_32_7_DIE("getCheckBit mismatch");
      }

      for (i = 1; i < 32; ++i) {
        int j;
        for (j = 0; j < i; ++j) {
          syndrome =
            BL_HammingEcc::get_hamming_32_7_synd((1<<i)^(1<<j)^data,
              ecc);

          if (syndrome.noError())
            BL_HAMMING_32_7_DIE("NoError succeeds");

          if (syndrome.isSingleBitError())
            BL_HAMMING_32_7_DIE("isSingleBit succeeds");

          if (!syndrome.isDoubleBitError())
            BL_HAMMING_32_7_DIE("isDoubleBit fails");

          if (syndrome.isMultipleBitError())
            BL_HAMMING_32_7_DIE("isMultipleBit succeeds");

          if (!syndrome.isUncorrectableError())
            BL_HAMMING_32_7_DIE("isUncorrectable fails");
        }
      }

      for (i = 1; i < 7; ++i) {
        int j;
        for (j = 0; j < i; ++j) {

          syndrome =
            BL_HammingEcc::get_hamming_32_7_synd(data,
              (1<<i)^(1<<j)^ecc);

          if (syndrome.noError())
            BL_HAMMING_32_7_DIE("NoError succeeds");

          if (syndrome.isSingleBitError())
            BL_HAMMING_32_7_DIE("isSingleBit succeeds");

          if (!syndrome.isDoubleBitError())
            BL_HAMMING_32_7_DIE("isDoubleBit fails");

          if (syndrome.isMultipleBitError())
            BL_HAMMING_32_7_DIE("isMultipleBit succeeds");

          if (!syndrome.isUncorrectableError())
            BL_HAMMING_32_7_DIE("isUncorrectable fails");
        }
      }
    }

#undef BL_HAMMING_32_7_DIE

  private:

    BL_Hamming_32_7_Synd();
};

#endif