testutil.cpp

The Lite Evaluation/Demonstration Kit is intended to illustrate use of the AN3042. The AN3042 is c

	if(errorCnt)
		printf("ERROR: EEPROM contents DO NOT match what was programmed; write failed\n");
	else
		printf("OK: EEPROM programmed OK\n");
}


//
// testEEPROM: Test EEPROM by read and writing values.
// 1. Read original contents.
// 2. Write address pattern test data.
// 3. Read and check address test data.
// 4. Restore original contents.
// 5. Check that restore was successful.
//
DWORD testEEPROM (DWORD comemID)
{
	printf ("Testing EEPROM...\n");

    DWORD returnCode;
    UCHAR temp[EEPROMsize], orig[EEPROMsize], temp2[EEPROMsize];
	int errorCnt = 0;
	DWORD TSTblockSZ = EEPROMsize;
    DWORD i;

	printf ("EEPROM Reads/Writes can take up to 30 seconds.\n");
	printf ("Please wait for tests to complete.\n");
	
	memset(orig, 0x0, sizeof(orig));
	returnCode = callReadEeprom (0, &orig[0], TSTblockSZ, comemID); // Read original contents.
	if (returnCode != NO_ERROR) errorCnt++;

	for (i = 0 ; i < EEPROMsize ; i++) // Init address pattern.
		temp[i] = (UCHAR)i ; 

	returnCode = callWriteEeprom (0, &temp[0], TSTblockSZ, comemID); // Write address test pattern
	if (returnCode != NO_ERROR) errorCnt++;

	memset(temp2, 0x0, EEPROMsize);
	returnCode = callReadEeprom (0, &temp2[0], TSTblockSZ, comemID); // Read.
	if (returnCode != NO_ERROR) errorCnt++;

	for (i = 0 ; i < TSTblockSZ ; i++) // Check address pattern.
		if (temp2[i] != i)
			errorCnt++;

	returnCode = callWriteEeprom (0, &orig[0], TSTblockSZ, comemID); // Restore original contents.
	if (returnCode != NO_ERROR) errorCnt++;

	memset(temp, 0x0, EEPROMsize);
	returnCode = callReadEeprom (0, &temp[0], TSTblockSZ, comemID); // Read.
	if (returnCode != NO_ERROR) errorCnt++;

	for (i = 0 ; i < TSTblockSZ ; i++)
	{ // Check that restore was successful.
		if (temp[i] != orig[i])
		{
			if(errorCnt++ < 8) // only report first 8 errors
			{
				printf ("Error: Read=%08x Original=%08x\n", temp[i], orig[i]);
			}
		}
	}
		
	return (errorCnt);
}


// Memory Test: Write Ones and Zeros
//   1. Host writes all ones to all of shared memory.
//   2. Host reads all of shared memory, confirming data
//   3. Host writes all zeros to all of shared memory.
//   4. Host reads all of shared memory, confirming data

DWORD testMemOneZero(DWORD SMtstBlkBase, DWORD SMoffset, DWORD SMtstBlkSz)
{ // Test Byte Enables.
	DWORD i, dRead, dWrote;
	DWORD errCnt = 0;

	for (i = 0; i < SMtstBlkSz/4; i++)		// Write ones
		((long *) SMtstBlkBase + SMoffset)[i] = -1;
	for (i = 0; i < SMtstBlkSz/4; i++)		// Read and check ones
	{
		dWrote = -1;
		if ( (dRead = ((long *) SMtstBlkBase + SMoffset)[i]) != dWrote)
		{
			if(errCnt++ < 8) // only report first 8 errors
			{
				printf ("Error: Addr=%08x Wrote=%08x Read=%08x\n", 
					(long *) SMtstBlkBase+SMoffset+i, dWrote, dRead);
			}
		}
	}

	for (i = 0; i < SMtstBlkSz/4; i++)		// Write zeroes
		((long *) SMtstBlkBase + SMoffset)[i] = 0;
	for (i = 0; i < SMtstBlkSz/4; i++)		// Read and check zeroes
	{
		dWrote = 0;
		if ( (dRead = ((long *) SMtstBlkBase + SMoffset)[i]) != dWrote)
		{
			if(errCnt++ < 8) // only report first 8 errors
			{
				printf ("Error: Addr=%08x Wrote=%08x Read=%08x\n", 
					(long *) SMtstBlkBase+SMoffset+i, dWrote, dRead);
			}
		}
	}

	return(errCnt);
}

// Memory Test: Write Address test
//   1. Host writes a unique value (the address) to each dword.
//   2. Host reads each dword of the memory, confirming data.
DWORD testMemAddr(DWORD SMtstBlkBase, DWORD SMoffset, DWORD SMtstBlkSz)
{ // Test Memory by writing address pattern.
	DWORD i, dRead, dWrote;
	DWORD errCnt = 0;

	// NOTE: Shared memory address space is known to be 4K DWORDS
	// so address pattern is repeated in 3 byte blocks
	for (i = 0; i < SMtstBlkSz/4; i++)		// Write address pattern
		((long *) SMtstBlkBase + SMoffset)[i] = (i | (i << 12) | (i << 24));

	for (i = 0; i < SMtstBlkSz/4; i++)		// Read and check address pattern
	{
		dWrote = (i | (i << 12) | (i << 24));
		if ( (dRead = ((long *) SMtstBlkBase + SMoffset)[i]) != dWrote)
		{
			if(errCnt++ < 8) // only report first 8 errors
			{
				printf ("Error: PCIAddr=%08x LocalAddr=%08x Wrote=%08x Read=%08x\n", 
					(long *) SMtstBlkBase+SMoffset+i, i*4, dWrote, dRead);
			}
		}
	}
	return(errCnt);
}

// Memory Test: Write Address Complement test
//   1. Host writes complement of unique value (the address) to each dword.
//   2. Host reads each dword of the memory, confirming data.
DWORD testMemAddrComp(DWORD SMtstBlkBase, DWORD SMoffset, DWORD SMtstBlkSz)
{ // Test Address Complement Pattern.
	DWORD i, dRead, dWrote;
	DWORD errCnt = 0;

	// NOTE: Shared memory address space is known to be 4K DWORDS
	// so address pattern is repeated in 3 byte blocks
	for (i = 0; i < SMtstBlkSz/4; i++)		// Write address complment pattern
		((long *) SMtstBlkBase + SMoffset)[i] = ~(i | (i << 12) | (i << 24));

	for (i = 0; i < SMtstBlkSz/4; i++)		// Read and check address complement pattern
	{
		dWrote = ~(i | (i << 12) | (i << 24));
		if ( (dRead = ((long *) SMtstBlkBase + SMoffset)[i]) != dWrote)
		{
			if(errCnt++ < 8) // only report first 8 errors
			{
				printf ("Error: PCIAddr=%08x LocalAddr=%08x Wrote=%08x Read=%08x\n", 
					(long *) SMtstBlkBase+SMoffset+i, i*4, dWrote, dRead);
			}
		}
	}
	return(errCnt);
}

// Memory Test: Write Bytes Test
//   1. Host writes all zeros to all of shared memory.
//   2. Host reads all of shared memory.
//   3. Host confirms data.
//   4. Create wrap-around byte data counter that counts from 1 to 255, never 0 (dWrote).
//   5. Create dword address counter that covers all of shared memory, 0 to 4095 (pdwAddr).
//   6. Host writes byte counter data to byte 0 of dword counter address of memory (nByteOffs).
//   7. Host increments byte data counter and increments dword address counter.
//   8. Host writes byte counter data to byte 1 of dword counter address of memory.
//   9. Host increments byte data counter and increments dword address counter.
//  10. Host writes byte counter data to byte 2 of dword counter address of memory.
//  11. Host increments byte data counter and increments dword address counter.
//  12. Host writes byte counter data to byte 3 of dword counter address of memory.
//  13. Host increments byte data counter and increments dword address counter.
//  14. Repeat pattern of steps 4 to 13 until all dwords of shared memory are 
//      accessed, but restart at the step after the step of the previous loop; 
//      e.g., on second loop through, start at step 8, and then run steps 9 to 13, 
//      and then 6 and 7 to end the second loop.
//		This procedure introduces a "slip" in the byte access pattern (i.e. the
//		first byte is accessed first, then the secend byte is accessed first, etc.).
//  15. Host reads all of shared memory.
//  16. Host confirms data; confirm only the one appropriate byte of each 
//      dword is non-zero and it is the correct value.
//
DWORD testMemWriteBytes(DWORD SMtstBlkBase, DWORD SMoffset, DWORD SMtstBlkSz)
{ // Test Byte Enables.
	DWORD dir;
	DWORD i;
	BYTE dRead, dWrote;
	BYTE nByteOffs;
	DWORD errCnt = 0;
	DWORD nMaxCnt = SMtstBlkSz/4; // Cont in DWORDs
	DWORD dwActRead; 
	DWORD dwExpRead;

	DWORD* pdwAddr = (DWORD*)(SMtstBlkBase + SMoffset*4);
	BYTE* pAddr;

  // Must zero memory for this test to be valid.
  for (i = 0; i < SMtstBlkSz/4; i++)		// Write zeroes
	((long *) SMtstBlkBase + SMoffset)[i] = 0L;
  for (i = 0; i < SMtstBlkSz/4; i++)		// Read zeroes
	if( ((long *) SMtstBlkBase + SMoffset)[i] ) // Check data
		if(errCnt++ < 8)
			printf ("Error: PCIAddr=%08x Wrote=%08x Read=%08x\n", (DWORD)(pdwAddr+i), 0, ((long *) SMtstBlkBase + SMoffset)[i]);

  for(dir=0; dir<2; dir++)
  { // do Write (dir=0) then read (dir=1)
	dWrote = 0;
	nByteOffs = 0;
	for (i = 0; i < nMaxCnt; i++)
	{ // Write Words
		pAddr = (BYTE*)((DWORD*)(pdwAddr+i));
		dWrote++;
		if(dWrote == 0)
			dWrote = 1; // wrap around and skip 0
		if(!dir)
		  *(pAddr+(nByteOffs%4)) = dWrote;
		else
		{
			//dRead = *(pAddr+(nByteOffs%4));
			dRead = dWrote;
			dwActRead = *((DWORD*)(pdwAddr+i));     // read whole DWORDs 
			// NOTE: The following is Endian Dependant! 
			// For Motorola, change to dwExpRead = bRead << (8*(3-(nByteOffs%4)));
			dwExpRead = dRead << (8*(nByteOffs%4)); // to verify single bytes
			if((dwActRead) != (dwExpRead))          // ONLY 1 byte should have value
				if(errCnt++ < 8)
					printf ("Error: PCIAddr=%08x Wrote=%08x Read=%08x\n", (DWORD)(pdwAddr+i), dwExpRead, dwActRead);
		}
	    nByteOffs++; // access next byte
	    if(!((i+1)%4)) 
			nByteOffs++; // incr 1 extra time for each 4 words to change pattern of access
	}
  }
  return(errCnt);
}

//
// Memory Test for AN3042.
// Get pointer to shared memory, offset, and size, then run a series of tests.
//
DWORD testSharedMem (DWORD comemID)
{
	DWORD errorCnt = 0;

	printf ("Testing Memory...\n");
	_flushall();

    // Get a pointer to the Shared Memory area (BAR 0)
    DWORD linBAR[COMEM_MAX_BARS];
    DWORD returnCode = comemCopyBarPtrL(linBAR, comemID);
    if (returnCode != NO_ERROR)
    {
        printf("Error creating BAR pointers.");
		return (returnCode);
    }
	DWORD SMtstBlkBase = linBAR[0];

	// Determine size and offset for Shared Memory area
	DWORD SMtstBlkSz;
	DWORD SMoffset;
	if (chipType() == CHIP3041)
	{
		SMtstBlkSz = 512;				// For 3041, in bytes.
		SMoffset = 0x0;					// Offset from BAR0 for 3041, in DWORDS.
	}
	else
	{
		SMtstBlkSz = 0x4000;		// For 3042, in bytes.
		SMoffset = SM_OFFSET;		// Offset from BAR0 for 3042, in DWORDS.
	}

	returnCode = 0;
	printf ("Running Write Address test.\n"); // Write address pattern
	if (errorCnt = testMemAddr(SMtstBlkBase, SMoffset, SMtstBlkSz)) 
		printf ("Address test failed for %d addresses.\n", errorCnt);
	else
		printf ("Address test passed.\n");
	returnCode += errorCnt;

	printf ("Running Write Address Complement test.\n"); // test complement (check for stuck bits).
	if (errorCnt = testMemAddrComp(SMtstBlkBase, SMoffset, SMtstBlkSz)) 
		printf ("Address Complement test failed for %d addresses.\n", errorCnt);
	else
		printf ("Address Complement test passed.\n");
	returnCode += errorCnt;

	printf ("Running Byte Write test.\n"); // Write rotating byte pattern 
	if (errorCnt = testMemWriteBytes(SMtstBlkBase, SMoffset, SMtstBlkSz)) 
		printf ("Byte Write test failed for %d addresses.\n", errorCnt);
	else
		printf ("Byte Write test passed.\n");
	returnCode += errorCnt;

	printf ("Running All Ones, then all Zeros test.\n"); // Write Ones then Zeros 
	if (errorCnt = testMemOneZero(SMtstBlkBase, SMoffset, SMtstBlkSz)) 
		printf ("Ones, Zeros test failed for %d addresses.\n", errorCnt);
	else
		printf ("Ones, Zeros test passed.\n");
	returnCode += errorCnt;

	_flushall();

	return (returnCode);
}  // end testSharedMem


//
// initSharedMem
//
//  Params:
//   patternStart = start address from the start of the Shared Mem
//   patternLen   = length in bytes 
//   patternType  = (always ADDR_PATTERN for now)
//   comemID      = unique designator of which 3042
// 

DWORD initSharedMem (DWORD patternStart, DWORD patternLen, DWORD patternType, DWORD comemID)
{
// Pattern numbers
#define ADDR_PATTERN 1
#define FILL_PATTERN 2
	
	int SMtstBlkSz;
	DWORD SMoffset;
	int errorCnt = 0;

	if (chipType() == CHIP3041)
	{
		SMtstBlkSz = 512;				// For 3041, in bytes.
		SMoffset = 0x0;					// Offset from BAR0 for 3041, in bytes.
	}
	else
	{
		if (patternLen == 0)
			SMtstBlkSz = 0x4000;		  // If 0 bytes specified, use the whole Shared Mem.
		else
			SMtstBlkSz = patternLen;      // else, use the size specified in the call.

		SMoffset = SM_OFFSET + patternStart/4;		// in DWORDS
	}


    // Get a pointer to the Shared Memory area (BAR 0)
    DWORD linBAR[COMEM_MAX_BARS];

    DWORD returnCode = comemCopyBarPtrL(linBAR, comemID);
    if (returnCode != NO_ERROR)
        {
        printf("Error creating BAR pointers.");
        errorCnt++;
        }

	printf ("Initializing Shared Mem at: 0x%08x patternLen: 0x%x pattern=%s\n", 
		(linBAR[0] + SM_OFFSET*4), patternLen, 
		(patternType == ADDR_PATTERN) ? "ADDR_PATTERN" : "FILL_PATTERN (=0xAA55AA55)");

	long dRead;
	DWORD SMtstBlkBase = linBAR[0];
	if(patternType == ADDR_PATTERN)
	{
		int i;
		for (i = 0; i < SMtstBlkSz/4; i++)		// Write address pattern
			((long *) SMtstBlkBase + SMoffset)[i] = i;
		for (i = 0; i < SMtstBlkSz/4; i++)		// Read and check address pattern
		{
			dRead = ((long *) SMtstBlkBase + SMoffset)[i];
			if ( dRead != i)
			{
				errorCnt++;