Embedded之memory test

1　　main.c

 #include "led.h" 

 #define BASE_ADDRESS   (volatile datum *) 0x10000000
 #define NUM_BYTES      0x10000 

 /**********************************************************************
  *
  * Function:    main()
  *
  * Description: Test the second 64 KB bank of SRAM.
  *
  * Notes:
  *
  * Returns:     0 on success.
  *              Otherwise -1 indicates failure.
  *
  **********************************************************************/
 main(void)
 {
     if ((memTestDataBus(BASE_ADDRESS) != ) ||
         (memTestAddressBus(BASE_ADDRESS, NUM_BYTES) != NULL) ||
         (memTestDevice(BASE_ADDRESS, NUM_BYTES) != NULL))
     {
         toggleLed(LED_RED);
         return (-);
     }
     else
     {
         toggleLed(LED_GREEN);
         return ();
     } 

 }   /* main() */ 

1.1　　Data bus test

 // typedef unsigned char datum;     /* Set the data bus width to 8 bits. */
 /**********************************************************************
  *
  * Function:    memTestDataBus()
  *
  * Description: Test the data bus wiring in a memory region by
  *              performing a walking 1's test at a fixed address
  *              within that region.  The address (and hence the
  *              memory region) is selected by the caller.
  *
  * Notes:
  *
  * Returns:     0 if the test succeeds.
  *              A non-zero result is the first pattern that failed.
  *
  **********************************************************************/
 datum
 memTestDataBus(volatile datum * address)
 {
     datum pattern;
     /*
      * Perform a walking 1's test at the given address.
      */
     for (pattern = ; pattern != ; pattern <<= )
     {
         /*
          * Write the test pattern.
          */
         *address = pattern;
         /*
          * Read it back (immediately is okay for this test).
          */
         if (*address != pattern)
         {
             return (pattern);
         }
     }
     return ();
 }   /* memTestDataBus() */

1.2　　Address bus test

 /**********************************************************************
  *
  * Function:    memTestAddressBus()
  *
  * Description: Test the address bus wiring in a memory region by
  *              performing a walking 1's test on the relevant bits
  *              of the address and checking for aliasing. This test
  *              will find single-bit address failures such as stuck
  *              -high, stuck-low, and shorted pins.  The base address
  *              and size of the region are selected by the caller.
  *
  * Notes:       For best results, the selected base address should
  *              have enough LSB 0's to guarantee single address bit
  *              changes.  For example, to test a 64-Kbyte region,
  *              select a base address on a 64-Kbyte boundary.  Also,
  *              select the region size as a power-of-two--if at all
  *              possible.
  *
  * Returns:     NULL if the test succeeds.
  *              A non-zero result is the first address at which an
  *              aliasing problem was uncovered.  By examining the
  *              contents of memory, it may be possible to gather
  *              additional information about the problem.
  *
  **********************************************************************/
 datum * memTestAddressBus(volatile datum * baseAddress, unsigned long nBytes)
 {
     unsigned long addressMask = (nBytes/sizeof(datum) - );
     unsigned long offset;
     unsigned long testOffset;
     datum pattern     = (datum) 0xAAAAAAAA;
     datum antipattern = (datum) 0x55555555;
     /*
      * Write the default pattern at each of the power-of-two offsets.
      */
     for (offset = ; (offset & addressMask) != ; offset <<= )
     {
         baseAddress[offset] = pattern;
     }
     /*
      * Check for address bits stuck high.
      */
     testOffset = ;
     baseAddress[testOffset] = antipattern;
     for (offset = ; (offset & addressMask) != ; offset <<= )
     {
         if (baseAddress[offset] != pattern)
         {
             return ((datum *) &baseAddress[offset]);
         }
     }
     baseAddress[testOffset] = pattern;
     /*
      * Check for address bits stuck low or shorted.
      */
     for (testOffset = ; (testOffset & addressMask) != ; testOffset <<= )
     {
         baseAddress[testOffset] = antipattern;
         if (baseAddress[] != pattern)
         {
             return ((datum *) &baseAddress[testOffset]);
         }
         for (offset = ; (offset & addressMask) != ; offset <<= )
         {
             if ((baseAddress[offset] != pattern) && (offset != testOffset))
             {
                 return ((datum *) &baseAddress[testOffset]);
             }
         }
         baseAddress[testOffset] = pattern;
     }
     return (NULL);
 }   /* memTestAddressBus() */

1.3　　Device test

 /**********************************************************************
  *
  * Function:    memTestDevice()
  *
  * Description: Test the integrity of a physical memory device by
  *              performing an increment/decrement test over the
  *              entire region.  In the process every storage bit
  *              in the device is tested as a zero and a one.  The
  *              base address and the size of the region are
  *              selected by the caller.
  *
  * Notes:
  *
  * Returns:     NULL if the test succeeds.  Also, in that case, the
  *              entire memory region will be filled with zeros.
  *
  *              A non-zero result is the first address at which an
  *              incorrect value was read back.  By examining the
  *              contents of memory, it may be possible to gather
  *              additional information about the problem.
  *
  **********************************************************************/
 datum * memTestDevice(volatile datum * baseAddress, unsigned long nBytes)
 {
     unsigned long offset;
     unsigned long nWords = nBytes / sizeof(datum);
     datum pattern;
     datum antipattern;
     /*
      * Fill memory with a known pattern.
      */
     for (pattern = , offset = ; offset < nWords; pattern++, offset++)
     {
         baseAddress[offset] = pattern;
     }
     /*
      * Check each location and invert it for the second pass.
      */
     for (pattern = , offset = ; offset < nWords; pattern++, offset++)
     {
         if (baseAddress[offset] != pattern)
         {
             return ((datum *) &baseAddress[offset]);
         }
         antipattern = ~pattern;
         baseAddress[offset] = antipattern;
     }
     /*
      * Check each location for the inverted pattern and zero it.
      */
     for (pattern = , offset = ; offset < nWords; pattern++, offset++)
     {
         antipattern = ~pattern;
         if (baseAddress[offset] != antipattern)
         {
             return ((datum *) &baseAddress[offset]);
         }
     }
     return (NULL);
 }   /* memTestDevice() */