Subversion Repositories or1k

/* mc_common.c -- Memory Controller testbenck common routines
	 Copyright (C) 2001 by Ivan Guzvinec, ivang@opencores.org
 
	 This file is part of OpenRISC 1000 Architectural Simulator.
 
	 This program is free software; you can redistribute it and/or modify
	 it under the terms of the GNU General Public License as published by
	 the Free Software Foundation; either version 2 of the License, or
	 (at your option) any later version.
 
	 This 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 program; if not, write to the Free Software
	 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
 
#include "support.h"
#include "mc_common.h"
 
static int r_Xn;
static int r_mod;
 
void randomin(unsigned long seed)
{
  r_Xn = seed;
  r_mod = 33554431; /* 2^25 - 1*/
}
 
unsigned long random(unsigned long max)
{
  r_Xn = ((r_Xn * (r_Xn + 1))%r_mod);
  if (r_Xn == 0) r_Xn = 42+1;
  return r_Xn%max;
}
 
void mc_clear_row(unsigned long nFrom, unsigned long nTo)
{
  MEMLOC32 mem32 = 0;
  unsigned long i;
 
  for(i=nFrom; i<nTo; i+=4) {
    mem32  = (unsigned long*)i;
    *mem32 = 0UL;
  }
}
 
unsigned long mc_test_row_8(int run, int seq, unsigned long nFrom, unsigned long nTo)
{
    MEMLOC8  mem8  = 0;
    MEMLOC16 mem16 = 0;
    MEMLOC32 mem32 = 0;
 
    unsigned char pattern    = 0;
    unsigned short pattern16 = 0;
    unsigned long pattern32  = 0;
    unsigned char read;
    unsigned short read16;
    unsigned long read32;
    int inc = 0;
 
    unsigned long i;
 
    /* number of locations to test */
    unsigned long nWords = nTo - nFrom;
 
    switch (run) {
    case 0:
	pattern = MC_TEST_PAT1_8;
	pattern16 = (pattern << 8); 
	pattern32 = (pattern16 << 16); break;
    case 1:
	pattern = MC_TEST_PAT2_8; 
	pattern16 = (pattern << 8);
	pattern32 = (pattern16 << 16); break;
    case 2:
	pattern = MC_TEST_PAT3_8; 
	pattern16 = (pattern << 8);
	pattern32 = (pattern16 << 16); break;
    case 3:
	pattern = MC_TEST_PAT4_8; 
	pattern16 = (pattern << 8);
	pattern32 = (pattern16 << 16); break;
    case 4:
	pattern32 = pattern16 = pattern = 0; inc = 1; break;
    } /*switch*/
 
    printf ("\tmc_test_row_8(0x%02dX, %d, 0x%08lX, 0x%08lX);\n", pattern, seq, nFrom, nTo);
 
    switch (seq) {
    case 0: /*seq. row write, row read*/
	for (i=nFrom; i<nTo; i++) {
	    mem8  = (unsigned char*)i;
	    *mem8 = pattern;
	    if (inc) pattern++;
	} /*for*/
 
	if (inc) pattern = 0;
	for (i=nFrom; i<nTo; i++) {
	    mem8 = (unsigned char*)i;
	    read = *mem8;
 
	    if ( read != pattern ) {
	        printf("\ti=%lX, read=0x%02dX, pattern=0x%02dX\n", i, read, pattern);
		return (unsigned long)mem8;
	    }
 
	    if (inc) pattern++;
	} /*for*/
	break;
    case 1: /*seq. word write, word read*/
	for (i=nFrom; i<nTo; i++) {
	    mem8  = (unsigned char*)i;
	    *mem8 = pattern;
	    read = *mem8;
 
	    if (read != pattern ) {
	        printf("\ti=%lX, read=0x%02dX, pattern=0x%02dX\n", i, read, pattern);
		return (unsigned long)mem8;
	    }
 
	    mem16  = (unsigned short*)(i & 0xFFFFFFFELU);
	    read16 = *mem16;
	    if (read16 != pattern16) {
	        printf("\ti=%lX, read16=0x%04dX, pattern16=0x%04dX\n", i, read16, pattern16);
		return (unsigned long)mem16;
	    }
	    mem32  = (unsigned long*)(i & 0xFFFFFFFCLU);
	    read32 = *mem32;
	    if (read32 != pattern32) {
	        printf("\ti=%lX, read32=0x%08lX, pattern32=0x%08lX\n", i, read32, pattern32);
		return (unsigned long)mem32;
	    }
 
	    if (inc) pattern++;
	    switch ((i+1)%4) {
	    case 0:
		pattern16 = (pattern << 8);
		pattern32 = (pattern << 24); break;
	    case 1:
		pattern16 += pattern;
		pattern32 = pattern16 << 16; break;
	    case 2:
		pattern16 = (pattern << 8);
		pattern32 += pattern16;break;
	    case 3:
		pattern16 += pattern;
		pattern32 += pattern; break;
	    } /*switch i%4*/
	} /*for*/
	break;
    case 2: /*rand. word write, word read*/
	for (i=0; i<nWords; i++) {
	    mem8  = (unsigned char*)(nFrom + random(nWords));
	    *mem8 = pattern;
	    read  = *mem8;
 
	    if (read != pattern ) {
		printf("\ti=%lX, read=0x%02dX, pattern=0x%02dX\n", i, read, pattern);
		return (unsigned long)mem8;
	    }
 
	    if (inc) pattern++;
	}
	break;
    } /*switch seq*/
 
    return 0;
} /* mc_test_row_8 */
 
unsigned long mc_test_row_16(int run, int seq, unsigned long nFrom, unsigned long nTo)
{
    MEMLOC16 mem16 = 0;
    MEMLOC32 mem32 = 0;
 
    unsigned short pattern16 = 0;
    unsigned long pattern32  = 0;
    unsigned short read16;
    unsigned long read32;
    int inc = 0;
 
    unsigned long i;
 
    unsigned long nWords = (nTo - nFrom)/2;
 
    switch (run) {
    case 0:
	pattern16 = MC_TEST_PAT1_16;
	pattern32 = (pattern16 << 16); break;
    case 1:
	pattern16 = MC_TEST_PAT2_16;
	pattern32 = (pattern16 << 16); break;
    case 2:
	pattern16 = MC_TEST_PAT3_16;
	pattern32 = (pattern16 << 16);break;
    case 3:
	pattern16 = MC_TEST_PAT4_16;
	pattern32 = (pattern16 << 16); break;
    case 4:
	pattern16 = pattern32 = 0; inc = 1; break;
    } /*switch*/
 
    printf ("\tmc_test_row_16(0x%04dX, %d, 0x%08lX, 0x%08lX);\n", pattern16, seq, nFrom, nTo);
 
    switch (seq) {
    case 0: /*seq. row write, row read*/
	for (i=nFrom; i<nTo; i+=2) {
	    mem16  = (unsigned short*)i;
	    *mem16 = pattern16;
	    if (inc) pattern16++;
	} /*for*/
 
	if (inc) pattern16 = 0;
	for (i=nFrom; i<nTo; i+=2) {
	    mem16  = (unsigned short*)i;
	    read16 = *mem16;
 
	    if ( read16 != pattern16 ) {
		printf("\ti=%lX, read16=0x%04dX, pattern16=0x%04dX\n", i, read16, pattern16);
		return (unsigned long)mem16;
	    }
 
	    if (inc) pattern16++;
	} /*for*/
	break;
    case 1: /*seq. word write, word read*/
	for (i=nFrom; i<nTo; i+=2) {
	    mem16  = (unsigned short*)i;
	    *mem16 = pattern16;
	    read16 = *mem16;
 
	    if (read16 != pattern16 ) {
	        printf("\ti=%lX, read16=0x%04dX, pattern16=0x%04dX\n", i, read16, pattern16);
		return (unsigned long)mem16;
	    }
 
	    mem32  = (unsigned long*)(i & 0xFFFFFFFCLU);
	    read32 = *mem32;
	    if (read32 != pattern32) {
	        printf("\ti=%lX, read32=0x%08lX, pattern32=0x%08lX\n", i, read32, pattern32);
		return (unsigned long)mem32;
	    }
 
	    if (inc) pattern16++;
	    switch ((i+2)%4) {
	    case 0:
	        pattern32 = (pattern16 << 16); break;
	    case 2:
		pattern32 += pattern16;
	    } /*switch i%4*/
	} /*for*/
	break;
    case 2: /*rand. word write, word read*/
	for (i=0; i<nWords; i++) {
	    mem16  = (unsigned short*)(nFrom + random(nWords)*2);
	    *mem16 = pattern16;
	    read16 = *mem16;
 
	    if (read16 != pattern16 ) {
		printf("\ti=%lX, read16=0x%04dX, pattern16=0x%04dX\n", i, read16, pattern16);
		return (unsigned long)mem16;
	    }
 
	    if (inc) pattern16++;
	}
	break;
    } /*switch seq*/
    return 0;
} /* mc_test_row_16 */
 
unsigned long mc_test_row_32(int run, int seq, unsigned long nFrom, unsigned long nTo)
{
    MEMLOC32 mem32 = 0;
 
    unsigned long pattern32 = 0;
    unsigned long read32;
    int inc = 0;
 
    unsigned long i;
 
    unsigned long nWords = (nTo - nFrom)/4;
 
    switch (run) {
    case 0:
	pattern32 = MC_TEST_PAT1_32; break;
    case 1:
	pattern32 = MC_TEST_PAT2_32; break;
    case 2:
	pattern32 = MC_TEST_PAT3_32; break;
    case 3:
	pattern32 = MC_TEST_PAT4_32; break;
    case 4:
	pattern32 = nFrom; inc = 1; break;
    } /*switch*/
 
    printf ("\tmc_test_row_32(0x%08lX, %d, 0x%08lX, 0x%08lX);\n", pattern32, seq, nFrom, nTo);
 
    switch (seq) {
    case 0: /*seq. row write, row read*/
	for (i=nFrom; i<nTo; i+=4) {
	    mem32  = (unsigned long*)i;
	    *mem32 = pattern32;
	    if (inc) pattern32 += 4;
	} /*for*/
 
	if (inc) pattern32 = nFrom;
	for (i=nFrom; i<nTo; i+=4) {
	    mem32 = (unsigned long *)i;
	    read32 = *mem32;
 
	    if ( read32 != pattern32 ) {
		printf("\ti=%lX, read32=0x%08lX, pattern32=0x%08lX\n", i, read32, pattern32);
		return (unsigned long)mem32;
	    }
 
	    if (inc) pattern32 += 4;
	} /*for*/
	break;
    case 1: /*seq. word write, word read*/
	for (i=nFrom; i<nTo; i+=4) {
	    mem32  = (unsigned long*)i;
	    *mem32 = pattern32;
	    read32 = *mem32;
 
	    if (read32 != pattern32 ) {
	        printf("\ti=%lX, read32=0x%08lX, pattern32=0x%08lX\n", i, read32, pattern32);
		return (unsigned long)mem32;
	    }
 
	    if (inc) pattern32 += 4;
 
	}
	break;
    case 2: /*rand. word write, word read*/
	for (i=0; i<nWords; i++) {
	    mem32 = (unsigned long*)(nFrom + random(nWords)*4);
	    if (inc) 
	        pattern32 = (unsigned long)mem32;
	    *mem32 = pattern32;
	    read32  = *mem32;
 
	    if (read32 != pattern32 ) {
		printf("\ti=%lX, read32=0x%08lX, pattern32=0x%08lX\n", i, read32, pattern32);
		return (unsigned long)mem32;
	    }
	} /*for*/
	break;
    } /*switch seq*/
    return 0;
} /* mc_test_row_32 */
 
 
/*---------------------------------------------------------------------------*/
 
 
/*-----[ Common Functions ]--------------------------------------------------*/
unsigned long mc_test_row(unsigned long nFrom, unsigned long nTo, unsigned long flags)
{
    int nRun, nSize, nSeq;
    int ret = 0;
 
    printf("\nmc_test_row(0x%08lX, 0x%08lX)\n", nFrom, nTo);
 
    for (nRun = 0; nRun < 5; nRun++) {
	switch (nRun) {
	case 0:
	    if ( (flags & MC_TEST_RUN0) != MC_TEST_RUN0 ) 
		continue;
	    break;
	case 1:
	    if ( (flags & MC_TEST_RUN1) != MC_TEST_RUN1 )
		continue;
	    break;
	case 2:
	    if ( (flags & MC_TEST_RUN01) != MC_TEST_RUN01 )
		continue;
	    break;
	case 3:
	    if ( (flags & MC_TEST_RUN10) != MC_TEST_RUN10 )
		continue;
	    break;
	case 4:
	    if ( (flags & MC_TEST_RUNINC) != MC_TEST_RUNINC )
		continue;
	} /*switch*/
 
	for (nSeq = 0; nSeq < 3; nSeq++) {
	    switch (nSeq) {
	    case 0:
		if ( (flags & MC_TEST_SEQ) != MC_TEST_SEQ )
		    continue;
		break;
	    case 1:
		if ( (flags & MC_TEST_SEQ1) != MC_TEST_SEQ1 )
		    continue;
		break;
	    case 2:
	      if ( (flags & MC_TEST_RAND) != MC_TEST_RAND )
		    continue;
	    } /*switch*/
 
	    for (nSize = 0; nSize < 3; nSize++) {
		switch (nSize) {
		case 0:
		    if ( (flags & MC_TEST_8) != MC_TEST_8 )
			continue;
		    ret = mc_test_row_8(nRun, nSeq, nFrom, nTo);
		    break;
		case 1:
		    if ( (flags & MC_TEST_16) != MC_TEST_16)
			continue;
		    ret = mc_test_row_16(nRun, nSeq, nFrom, nTo);
		    break;
		case 2:
		    if ( (flags & MC_TEST_32) != MC_TEST_32)
			continue;
		    ret = mc_test_row_32(nRun, nSeq, nFrom, nTo);
		} /*switch*/
 
		if (ret) return ret;
		mc_clear_row(nFrom, nTo);
	    } /*for nSize*/
	} /*for nSeq*/
	/*report(0xDEADDEAD);*/
    } /*for nRun*/
 
    return 0;
} /* mc_test_row */