LPC1788 + SDRAM als "System Memory"

[Raff (Gast)]

Hi,

Ist es möglich, ähnlich wie bei einem STM32, bei einem LPC1778/1788 den 
externen SDRAM als Daten/System-Memory (sprich anstelle des internen 
SRAM) zu benutzen?

Ein Blick ins Reference Manual und eine suche bei Google brachte keine 
schlüssige Antwort :(

Besten Dank
Raff

[Mw E. (Firma: fritzler-avr.de) (fritzler)]

Sollte schon gehen, musst eben nur dem Linkerscript sagen, dass das 
Programm jetz auf ner anderen Adresse anfängt.

[Raff (Gast)]

Hallo Martin

Dies habe ich bereits probiert. Funktioniert aber nicht wirklich :-(
Vorneweg, der SDRAM ansich funktioniert problemlos.

Was ich nun versucht habe:
- RAM wird gleich nach dem Clock/PLL initialisiert (direkt die 
entsprechenden Werte in die Kontrollregister)
- Linker-Script auf die entsprechende Adresse umgebogen (0xA0000000)

Die Initialisierung u.s.w. klappt soweit. Allerdings hauts ihn dann im 
startup auf den Sack (bin jetzt grad nicht mehr sicher ob beim 
CopyDataInit oder LoopCopyDataInit).

Gruss
Raff

[gerhard (Gast)]

hallo raff,
welche tool chain verwendet du den?
wird der sdram controller initialisiert bevor der startup-code versucht 
auf das SDRAM zuzugreifen?

gruss
gerhard

[Raff (Gast)]

Hi gerhard

Ich verwende codesourcery lite in der aktuellen Version.

der RAM wird in der SystemInit funktion gleich nach dem PLL 
initialisiert.

Kann heute Abend gerne mal den Code posten.

Gruss
Raff

[Raff (Gast)]

Hi,

Ich habe noch ein bisschen experimentiert.
Das RAM-Init funktioniert erst nach dem SystemInit (PLL & Co).
Wird er vorher ausgeführt läuft der RAM nicht.
Das ist jetzt natürlich insofern ein Problem als im Startup als erstes 
mal die .data und .bss section kopiert/initialisiert werden.
Wenn das Linkerscript dann auf den SDRAM-Bereich zeigt knallts 
natürlich.

Hat jemand eine Idee?
der STM32 löst dies offenbar so das während dem System und RAM-Init der 
Stack auf dem internen RAM liegt und dieser danach umgebogen wird.
Ich werde mal versuchen dies auf beim LPC auch so zu machen

Gruss & Danke
Raff

[Mw E. (Firma: fritzler-avr.de) (fritzler)]

Also auf den ARM Kisten in der Uni auf dem wir grade nen Betriebssystem 
schreiben ist das mit nem Bootloader gelöst.

Der macht das init der grundlegenden Hardware und läd dann das Programm 
in den RAM.

[Raff (Gast)]

Hallo Martin

Danke für den Tipp, dies ist natürlich auch ne Idee.
Denke aber der "Trick" mit MSP umbiegen scheint auch zu funktionieren - 
muss es aber noch genau testen.

Damit dies erstmal für die Nachwelt erhalten bleibt:

Hier das original LPC Startup File (Auszug)

Reset_Handler:
  ldr   sp, =_estack    /* set stack pointer */

  /* 1. copy .data section (Copy from ROM to RAM) */
  movs r1, #0
  b LoopCopyDataInit

Und hier das geänderte:

/* temporary stack address for startup */
.equ _temp_stack, 0x10010000

(...)

Reset_Handler:
  ldr   sp, = _temp_stack    /* set stack pointer */

  bl SystemInit

  bl ram_init

/* Restore original stack pointer. */
  ldr     r0, =_estack
  msr     MSP, r0

  /* 1. copy .data section (Copy from ROM to RAM) */
  movs r1, #0
  b LoopCopyDataInit

und der guten Ordnung halber noch die ram_init funktion:

void ram_init()
{
    volatile uint32_t i;
    
    PINSEL_ConfigPin(2,16,1);  //CAS
    PINSEL_ConfigPin(2,17,1);  //RAS
    PINSEL_ConfigPin(2,18,1);  //CLK
    PINSEL_ConfigPin(2,20,1);  //CS
    PINSEL_ConfigPin(2,24,1);  //CKE
    PINSEL_ConfigPin(2,28,1);  //DQM0
    PINSEL_ConfigPin(2,29,1);  //DQM1
    PINSEL_ConfigPin(4,25,1);  //WE

    //A0-14
    PINSEL_ConfigPin(4,0,1);
    PINSEL_ConfigPin(4,1,1);
    PINSEL_ConfigPin(4,2,1);
    PINSEL_ConfigPin(4,3,1);
    PINSEL_ConfigPin(4,4,1);
    PINSEL_ConfigPin(4,5,1);
    PINSEL_ConfigPin(4,6,1);
    PINSEL_ConfigPin(4,7,1);
    PINSEL_ConfigPin(4,8,1);
    PINSEL_ConfigPin(4,9,1);
    PINSEL_ConfigPin(4,10,1);
    PINSEL_ConfigPin(4,11,1);
    PINSEL_ConfigPin(4,12,1);
    PINSEL_ConfigPin(4,13,1);
    PINSEL_ConfigPin(4,14,1);

    //D0-15
    PINSEL_ConfigPin(3,0,1);
    PINSEL_ConfigPin(3,1,1);
    PINSEL_ConfigPin(3,2,1);
    PINSEL_ConfigPin(3,3,1);
    PINSEL_ConfigPin(3,4,1);
    PINSEL_ConfigPin(3,5,1);
    PINSEL_ConfigPin(3,6,1);
    PINSEL_ConfigPin(3,7,1);
    PINSEL_ConfigPin(3,8,1);
    PINSEL_ConfigPin(3,9,1);
    PINSEL_ConfigPin(3,10,1);
    PINSEL_ConfigPin(3,11,1);
    PINSEL_ConfigPin(3,12,1);
    PINSEL_ConfigPin(3,13,1);
    PINSEL_ConfigPin(3,14,1);
    PINSEL_ConfigPin(3,15,1);

    volatile unsigned long Dummy;

  LPC_SC->PCONP     |= 0x00000800;
  /*Init SDRAM controller*/
  LPC_SC->EMCDLYCTL |= (8<<0);
  /*Set data read delay*/
  LPC_SC->EMCDLYCTL |=(8<<8);
  LPC_SC->EMCDLYCTL |= (0x08 <<16);

  LPC_EMC->Control = 1;
  LPC_EMC->DynamicReadConfig = 1;
  LPC_EMC->DynamicRasCas0 = 0;
  LPC_EMC->DynamicRasCas0 |=(3<<8);
  LPC_EMC->DynamicRasCas0 |= (3<<0);
  LPC_EMC->DynamicRP = P2C(SDRAM_TRP);
  LPC_EMC->DynamicRAS = P2C(SDRAM_TRAS);
  LPC_EMC->DynamicSREX = P2C(SDRAM_TXSR);
  LPC_EMC->DynamicAPR = SDRAM_TAPR;
  LPC_EMC->DynamicDAL = SDRAM_TDAL+P2C(SDRAM_TRP);
  LPC_EMC->DynamicWR = SDRAM_TWR;
  LPC_EMC->DynamicRC = P2C(SDRAM_TRC);
  LPC_EMC->DynamicRFC = P2C(SDRAM_TRFC);
  LPC_EMC->DynamicXSR = P2C(SDRAM_TXSR);
  LPC_EMC->DynamicRRD = P2C(SDRAM_TRRD);
  LPC_EMC->DynamicMRD = SDRAM_TMRD;

  // 13 row, 9 - col, SDRAM
  LPC_EMC->DynamicConfig0 = 0x0000680;
  // JEDEC General SDRAM Initialization Sequence
  // DELAY to allow power and clocks to stabilize ~100 us
  // NOP
  LPC_EMC->DynamicControl = 0x0183;
  for(i= 200*30; i;i--);
  // PALL
  LPC_EMC->DynamicControl = 0x0103;
  LPC_EMC->DynamicRefresh = 1;
  for(i= 256; i; --i); // > 128 clk
  LPC_EMC->DynamicRefresh = P2C(SDRAM_REFRESH) >> 4;
  // COMM

    LPC_EMC->DynamicControl    = 0x00000083; /* Issue MODE command */
  Dummy = *((volatile uint32_t *)(SDRAM_BASE_ADDR | (0x33<<12)));
  // NORM
  LPC_EMC->DynamicControl = 0x0000;
  LPC_EMC->DynamicConfig0 |=(1<<19);
  for(i = 100000; i;i--);
}

Und hier noch das Linker Script im Original:

/* Highest address of the user mode stack */
_estack = 0x10010000;    /* end of 64K RAM */

(...)

/* Specify the memory areas */
MEMORY
{
  FLASH (rx)      : ORIGIN = 0x00000000, LENGTH = 512K
  RAM (xrw)       : ORIGIN = 0x10000000, LENGTH = 64K
  RAM1 (xrw)      : ORIGIN = 0x2007C000, LENGTH = 16K
  RAM2 (xrw)      : ORIGIN = 0x20080000, LENGTH = 0K
  MEMORY_B1 (rx)  : ORIGIN = 0x80000000, LENGTH = 0K
}

Und das geänderte:

/* Highest address of the user mode stack */
_estack = 0xA2000000;    /* end of 32M RAM */

(...)

/* Specify the memory areas */
MEMORY
{
  FLASH (rx)      : ORIGIN = 0x00000000, LENGTH = 512K
  RAM (xrw)       : ORIGIN = 0xA0000000, LENGTH = 0x02000000
  RAM1 (xrw)      : ORIGIN = 0x2007C000, LENGTH = 16K
  RAM2 (xrw)      : ORIGIN = 0x20080000, LENGTH = 0K
  MEMORY_B1 (rx)  : ORIGIN = 0x80000000, LENGTH = 0K
}

Und raus kommt danach das hier:

CPU/Periph/EMC/USB              120/60/60/48 MHz
Ram-Config
DynamicRP=3
DynamicRAS=6
DynamicSREX=9
DynamicDAL=6
DynamicRC=8
DynamicRFC=8
DynamicXSR=9
DynamicRRD=2
DynamicRefresh=58
EMCDLYCTL=526872
PCONP=86552542
DynamicRasCas0=771
MSP=0xa1ffff98 <--

Der Stackpointer zeit jetzt ganz ordentlich auf den externen SDRAM.


Gruss Raff

[Harper (Gast)]

Raff schrieb:
> LPC_SC->PCONP     |= 0x00000800;

Damit wird das Bit 12 "PCADC" gesetzt. Sollte das nicht das Bit 11 
"PCEMC" sein?

[Harper (Gast)]

Ich hab mich verzählt. Bitte ignorieren.

[Harper B. (harper)]

Raff schrieb:
>
> und der guten Ordnung halber noch die ram_init funktion:
>
> [c]
> void ram_init()
> {
>     volatile uint32_t i;
>
...
>   /*Init SDRAM controller*/
>   LPC_SC->EMCDLYCTL |= (8<<0);
>   /*Set data read delay*/
>   LPC_SC->EMCDLYCTL |=(8<<8);
>   LPC_SC->EMCDLYCTL |= (0x08 <<16);
Hier werde nur Bits gesetzt. Von welcher Anfangsbelegung gehst Du hier 
aus?

>   LPC_EMC->DynamicRP = P2C(SDRAM_TRP);
...
Hier wird die Funktion (oder das Makro) P2C verwendet. Kannst Du dieses 
posten?
Wie hast Du die SDRAM_XXX -Werte gefunden?