RTX with External SDRAM LPC1788 - causes bus fault

Ok so another update on this topic.

I contacted NXP support and they told me something different than the FAE.

Here is support's response:

"Thank you for contacting NXP Semiconductors.
The EMC in the LPC177x/8x family can run at a maximum speed of 80 MHz (see the Tcy(clk) = 12.5ns minimum in the data sheet).
You should divide the clock down using the EMCCLKSEL registers."

I guess I missed that in the datasheet.

Hope this is of use to someone else.

Regards,

M

Ok so another update on this topic.

I contacted NXP support and they told me something different than the FAE.

Here is support's response:

"Thank you for contacting NXP Semiconductors.
The EMC in the LPC177x/8x family can run at a maximum speed of 80 MHz (see the Tcy(clk) = 12.5ns minimum in the data sheet).
You should divide the clock down using the EMCCLKSEL registers."

I guess I missed that in the datasheet.

Hope this is of use to someone else.

Regards,

M

Now it's 80 MHz?
Time to make up your minds NXP :-)

I believe this is incorrect. The data sheet (Table 15. Dynamic characteristics: Static external memory interface, page 81) is referring to a static external memory.

The tables after this (Table 16-18. Dynamic characteristics: Dynamic external memory interface, page 83 - page85) are the ones that pertain to running a SDRAM.

I believe this clock, called the EMC_CLK, is a function of the ouptut from the PLL, and the EMC_CLOCK_DIVIDER, as shown in the user's manual on page 35, Fig. 7.

According to Section 4.6.3 on page 51 of the user's manual, this clock can be the same as the CPU clock, and the CPU clock can be 120Mhz, so this clock can be also.

I personally have driven my EMC clock at 108Mhz without and problems from my EMC or the SDRAM (MT48LC2M32B2).

I did experience a problem running it at 120Mhz, but I attributed this to a poor PCB layout.

I hope this helps,

-Dave

Good observation.
I too was able to run at slightly higher rates than 80MHz but I think this is actually the "official" limit for the EMC (static and/or dynamic).
The "clock cycle time" is more directly related to dynamic memory than static so maybe this is just in the wrong spot in the datasheet?

Also, in our target product we have static mem as well so that pretty much decides that.

Thanks.

M

After reading your response, I decided to play around with the values used to program the EMC, and now I am able to get my SDRAM to work at 120Mhz.

Here are my results:

...clearing SDRAM (8388608 bytes)...............complete! (92 ms.)
...testing SDRAM 16-bit write (2097152 words)...complete! (154 ms.)
...testing SDRAM 16-bit read (2097152 words)....complete! (310 ms.), Errors: 0
...testing SDRAM 32-bit write (1048576 dwords)..complete! (87 ms.)
...testing SDRAM 32-bit read (1048576 dwords)...complete! (148 ms.), Errors: 0

You are welcome to try it for yourself. Here are the values I used:

LPC_SC->EMCCLKSEL = 0x00000000;  // EMC uses a clock rate equal to CPU clock rate...
LPC_SC->CLKOUTCFG = 0x00000100;  // enables clock, sets clock source as CPU clk / 1...
CAS_Latency = 2;
RAS_Latency = 2;
DelayConstant = 0x00000A05;
.
.
.
LPC_SC->EMCDLYCTL   = DelayConstant;

I still believe the time entry in the datasheet is specific to the table that it is listed in, namely static memory. It is referenced throughout that table in other timing parameters, but no where else in the data sheet.

I put in another tech support request to NXP for clarification on this subject, and referenced this forum thread for them...

Good luck,

Dave

Dave,

Please post any NXP response here. Thank you.

Dave,

Thanks for the update. Yes, the data sheet conflicts itself as other NXP individuals and documents...

NXP sample code tends to look like it was written by students. Their code packages can potentially be used as a complement to the datasheet when figuring something out, but in most situations, the code needs to be rewritten - or not used at all.

Hi Dave,

We found that same error in system_lpc17xx.c as a matter of fact in the last version of system_LPC177x_8x.c there was also an error.

If using the configuration wizard in uVision there was an extra #define making all the settings offset.

Talk about trick to track down.

I'm not using the FDI board I'm using the EA board so I don't have the same RAM chip.

I took a look at your setup and I'm doing pretty much the same thing with slightly modified values (from SDRAM datasheet) I also did this both in C and assembler but that is for a different reason.

Long story short I still had intermittent errors at 120MHz but it ran well at 96MHz.

What does your test consist of? As Tamir pointed out above it's important to have a thorough test.
I used the test from the link Tamir pointed and I never get Data bus or Address bus errors I always get the errors in the full mem read/write test.

Let's see what NXP says to your reply.

M

Hi Dave,

I noticed that in your macro:

#define NS_2_CLKS(ns) ( (uint32_t)( (double)(ns) * tCLK_ns ) + 1 )   // convert ns to CCLKs

you have "+ 1" is that correct? I thought that the + 1 happened in hardware.

For example see table 118 from the user manual for DaynamicRP:

Table 118. Dynamic Memory Precharge Command Period register (EMCDynamictRP - address 0x2009 C030) bit
3:0 Precharge command
period (tRP)
0x0 -
0xE
n + 1 clock cycles. The delay is in EMCCLK cycles. 0x0F
0xF 16 clock cycles (POR reset value).

So if the datasheet says 18ns aren't you adding one extra clock cycle?

I could just be missing something but this may actually explain why my setting aren't working.

M

[PART 1 OF 2 MESSAGES]
I have two memory tests:

Here's the first one...

/***********************************************************************************************
** Function name:    MemTest
**
** Descriptions:     Simple test for SDRAM memory
**
** parameters:       Count - a counter for repetitive testing that shows up on TeraTerm
** Returned value:   None
**
***********************************************************************************************/
void MemTest( uint32_t Count )
   {
   uint32_t register *uint32_t_ptr;
   uint16_t register *uint16_t_ptr;
   register uint32_t Data32;
   register uint16_t Data16;
   uint32_t i, k, ErrorCount;
   uint32_t RelativeTimer;

   ANSIgotoxy(1,1);
   printf("Evaluating SDRAM performance: %u\r\n", Count);

   ANSIsetcolor( BRIGHT, ANSI_YELLOW, ANSI_BLACK );   // set Hyperterm colors

   // Clear content before 16 bit access test
   // ---------------------------------------------------------
   uint32_t_ptr = (uint32_t *)(SDRAM_BASE_ADDR);
   printf("\t...clearing SDRAM (%u bytes)...............", (uint32_t)(SDRAM_SIZE));
   RelativeTimer = SystemTimer;
   k = SDRAM_SIZE>>3;   // size in bytes divided by 4 (32bit access)
   for ( i=0; i<k; i++ )
      *uint32_t_ptr++ = 0;
   RelativeTimer = SystemTimer - RelativeTimer;
   printf( "complete! (%u ms.)\r\n", RelativeTimer );

   uint32_t_ptr = (uint32_t *)SDRAM_BASE_ADDR;

   // Test 16-bit write performance...
   // ---------------------------------------------------------
   k = SDRAM_SIZE>>2;   // size in bytes divided by 2 (16bit access)
   uint16_t_ptr = (uint16_t *)(SDRAM_BASE_ADDR);
   printf("\t...testing SDRAM 16-bit write (%u words)...", k);
   RelativeTimer = SystemTimer;
   for ( i=0; i<k; i++ )
      *uint16_t_ptr++ = ( i%65536 );
   RelativeTimer = SystemTimer - RelativeTimer;
   printf( "complete! (%u ms.)\r\n", RelativeTimer );

   // Test 16-bit read performance...
   // ---------------------------------------------------------
   uint16_t_ptr = (uint16_t *)(SDRAM_BASE_ADDR);
   printf("\t...testing SDRAM 16-bit read (%u words)....", k);
   ErrorCount = 0;
   RelativeTimer = SystemTimer;
   for ( i=0; i<k; i++ )
      {
      Data16 = *uint16_t_ptr++;
      if( Data16 != ( i%65536 ) )
         ErrorCount++;
      }
   RelativeTimer = SystemTimer - RelativeTimer;
   printf( "complete! (%u ms.), Errors: %u\r\n", RelativeTimer, ErrorCount );

   // Test 32-bit write performance...
   // ---------------------------------------------------------
   k = SDRAM_SIZE>>3;   // size in bytes divided by 4 (32bit access)
   uint32_t_ptr = (uint32_t *)(SDRAM_BASE_ADDR);
   printf("\t...testing SDRAM 32-bit write (%u dwords)..", k);
   RelativeTimer = SystemTimer;
   for ( i=0; i<k; i++ )
      *uint32_t_ptr++ = ( i );
   RelativeTimer = SystemTimer - RelativeTimer;
   printf( "complete! (%u ms.)\r\n", RelativeTimer );

   // Test 32-bit read performance...
   // ---------------------------------------------------------
   uint32_t_ptr = (uint32_t *)(SDRAM_BASE_ADDR);
   printf("\t...testing SDRAM 32-bit read (%u dwords)...", k);
   ErrorCount = 0;
   RelativeTimer = SystemTimer;
   for ( i=0; i<k; i++ )
      {
      Data32 = *uint32_t_ptr++;
      if( Data32 != ( i ) )
         ErrorCount++;
      }
   RelativeTimer = SystemTimer - RelativeTimer;
   printf( "complete! (%u ms.), Errors: %u\r\n", RelativeTimer, ErrorCount );

   ANSIsetcolor( BRIGHT, ANSI_CYAN, ANSI_BLACK );  // set Hyperterm colors
   }

[PART 2 OF 2 MESSAGES]

Here's the second one...

/***********************************************************************************************
** Function name:    ComprehensiveMemTest
**
** Descriptions:     Comprehensive test for SDRAM memory
**
** parameters:       Count - a counter for repetitive testing that shows up on TeraTerm
** Returned value:   None
**
***********************************************************************************************/
void ComprehensiveMemTest( uint32_t Count )
   {
   uint32_t register *uint32_t_ptr;
   uint16_t register *uint16_t_ptr;
   register uint32_t Mask32;
   register uint16_t Mask16;
   uint32_t i, k, ErrorCount;
   uint32_t RelativeTimer;

   ANSIsetcolor( BRIGHT, ANSI_CYAN, ANSI_BLACK );     // set Hyperterm colors
   printf("\r\nComprehensive SDRAM performance: %u\r\n\n", Count);

   ANSIsetcolor( BRIGHT, ANSI_YELLOW, ANSI_BLACK );   // set Hyperterm colors

   // Clear content before 16 bit access test
   // ---------------------------------------------------------
   uint32_t_ptr = (uint32_t *)(SDRAM_BASE_ADDR);
   printf("...clearing SDRAM (%u bytes).....................", (uint32_t)(SDRAM_SIZE));
   RelativeTimer = SystemTimer;
   k = SDRAM_SIZE>>3;   // size in bytes divided by 4 (32bit access)
   for( i=0; i<k; i++ )
      *uint32_t_ptr++ = 0;
   RelativeTimer = SystemTimer - RelativeTimer;
   printf( "complete! (%u ms.)\r\n", RelativeTimer );

   uint32_t_ptr = (uint32_t *)SDRAM_BASE_ADDR;

   // Test 16-bit performance...
   // ---------------------------------------------------------
   k = SDRAM_SIZE>>2;   // size in bytes divided by 2 (16bit access)

   /* walking bit test */
   /* ---------------- */
   ErrorCount = 0;
   printf("...Walking-bit test: SDRAM 16-bit (%u words).....", k);
   RelativeTimer = SystemTimer;
   for( Mask16=0x0001; Mask16; Mask16 <<= 1 )
      {
      uint16_t_ptr = (uint16_t *)(SDRAM_BASE_ADDR);
      for( i=0; i<k; i++ )
         {
         *uint16_t_ptr = Mask16;
         if( *uint16_t_ptr++ != Mask16 )
            ErrorCount++;
         }
      }
   RelativeTimer = SystemTimer - RelativeTimer;
   printf( "complete! (%06.3f sec) (Errors: %u)\r\n", (float)(RelativeTimer)/1000.0, ErrorCount );

   /* alternate bit test */
   /* ------------------ */
   ErrorCount = 0;
   printf("...Alternate-bit test: SDRAM 16-bit (%u words)...", k);
   RelativeTimer = SystemTimer;
   for( Mask16=0x5555; Mask16!=0x5554; Mask16 <<= 1 )
      {
      uint16_t_ptr = (uint16_t *)(SDRAM_BASE_ADDR);
      for( i=0; i<k; i++ )
         {
         *uint16_t_ptr = Mask16;
         if( *uint16_t_ptr++ != Mask16 )
            ErrorCount++;
         }
      }
   RelativeTimer = SystemTimer - RelativeTimer;
   printf( "complete! (%06.3f sec) (Errors: %u)\r\n", (float)(RelativeTimer)/1000.0, ErrorCount );

   /* unique value test */
   /* ----------------- */
   ErrorCount = 0;
   printf("...Unique value test: SDRAM 16-bit (%u words)....", k);
   uint16_t_ptr = (uint16_t *)(SDRAM_BASE_ADDR);
   RelativeTimer = SystemTimer;
   for( i=0; i<k; i++ )
      *uint16_t_ptr++ = ( i%65536 );
   uint16_t_ptr = (uint16_t *)(SDRAM_BASE_ADDR);
   for( i=0; i<k; i++ )
      {
      if( *uint16_t_ptr++ != ( i%65536 ) )
         ErrorCount++;
      }
   RelativeTimer = SystemTimer - RelativeTimer;
   printf( "complete! (%06.3f sec) (Errors: %u)\r\n\n", (float)(RelativeTimer)/1000.0, ErrorCount );

   // Test 32-bit performance...
   // ---------------------------------------------------------
   k = SDRAM_SIZE>>3;   // size in bytes divided by 4 (32bit access)

   /* walking bit test */
   /* ---------------- */
   ErrorCount = 0;
   printf("...Walking-bit test: SDRAM 32-bit (%u dwords)....", k);
   RelativeTimer = SystemTimer;
   for( Mask32=0x00000001; Mask32; Mask32 <<= 1 )
      {
      uint32_t_ptr = (uint32_t *)(SDRAM_BASE_ADDR);
      for( i=0; i<k; i++ )
         {
         *uint32_t_ptr = Mask32;
         if( *uint32_t_ptr++ != Mask32 )
            ErrorCount++;
         }
      }
   RelativeTimer = SystemTimer - RelativeTimer;
   printf( "complete! (%06.3f sec) (Errors: %u)\r\n", (float)(RelativeTimer)/1000.0, ErrorCount );

   /* alternate bit test */
   /* ------------------ */
   ErrorCount = 0;
   printf("...Alternate-bit test: SDRAM 32-bit (%u words)...", k);
   RelativeTimer = SystemTimer;
   for( Mask32=0x55555555; Mask32!=0x55555554; Mask32 <<= 1 )
      {
      uint32_t_ptr = (uint32_t *)(SDRAM_BASE_ADDR);
      for( i=0; i<k; i++ )
         {
         *uint32_t_ptr = Mask32;
         if( *uint32_t_ptr++ != Mask32 )
            ErrorCount++;
         }
      }
   RelativeTimer = SystemTimer - RelativeTimer;
   printf( "complete! (%06.3f sec) (Errors: %u)\r\n", (float)(RelativeTimer)/1000.0, ErrorCount );

   /* unique value test */
   /* ----------------- */
   ErrorCount = 0;
   printf("...Unique value test: SDRAM 32-bit (%u words)....", k);
   uint32_t_ptr = (uint32_t *)(SDRAM_BASE_ADDR);
   RelativeTimer = SystemTimer;
   for( i=0; i<k; i++ )
      *uint32_t_ptr++ = i;
   uint32_t_ptr = (uint32_t *)(SDRAM_BASE_ADDR);
   for( i=0; i<k; i++ )
      {
      if( *uint32_t_ptr++ != i )
         ErrorCount++;
      }
   RelativeTimer = SystemTimer - RelativeTimer;
   printf( "complete! (%06.3f sec) (Errors: %u)\r\n\n", (float)(RelativeTimer)/1000.0, ErrorCount );

   ANSIsetcolor( BRIGHT, ANSI_CYAN, ANSI_BLACK );  // set Hyperterm colors
   }

...and the output on TeraTerm looks like this:

Evaluating SDRAM performance: 0
        ...clearing SDRAM (8388608 bytes)...............complete! (92 ms.)
        ...testing SDRAM 16-bit write (2097152 words)...complete! (154 ms.)
        ...testing SDRAM 16-bit read (2097152 words)....complete! (310 ms.), Errors: 0
        ...testing SDRAM 32-bit write (1048576 dwords)..complete! (87 ms.)
        ...testing SDRAM 32-bit read (1048576 dwords)...complete! (149 ms.), Errors: 0

Comprehensive SDRAM performance: 0

...clearing SDRAM (8388608 bytes).....................complete! (92 ms.)
...Walking-bit test: SDRAM 16-bit (2097152 words).....complete! (05.234 sec) (Errors: 0)
...Alternate-bit test: SDRAM 16-bit (2097152 words)...complete! (00.695 sec) (Errors: 0)
...Unique value test: SDRAM 16-bit (2097152 words)....complete! (00.450 sec) (Errors: 0)

...Walking-bit test: SDRAM 32-bit (1048576 dwords)....complete! (04.837 sec) (Errors: 0)
...Alternate-bit test: SDRAM 32-bit (1048576 words)...complete! (00.302 sec) (Errors: 0)
...Unique value test: SDRAM 32-bit (1048576 words)....complete! (00.226 sec) (Errors: 0)

System ready for USB testing...

Marc,

The macro is correct. The "+1" handles rounding. Since I'm casting to a double, doing the math, and then casting to an unsigned int, (which truncates the result) adding one will always insure I round up.

-Dave