xmega128a1 EBI SDRAM

[Markus C. (ljmarkus)]

Hallo,

Ich habe das ALVIDI Board (V1.3) mit dem SDRAM MT48LC16M4A2.

nun lege zb.

volatile uint8_ data_00[512];
volatile uint8_ data_01[512];
volatile uint8_ data_02[512];
volatile uint8_ data_03[512];
volatile uint8_ data_04[512];
volatile uint8_ data_05[512];
volatile uint8_ data_06[512];
volatile uint8_ data_07[512];
volatile uint8_ data_08[512];
volatile uint8_ data_09[512];
volatile uint8_ data_10[512];
volatile uint8_ data_11[512];
volatile uint8_ data_12[512];
volatile uint8_ data_13[512];
volatile uint8_ data_14[512];
volatile uint8_ data_15[512];
volatile uint8_ data_16[512];
volatile uint8_ data_17[512];
volatile uint8_ data_18[512];
volatile uint8_ data_19[512];
volatile uint8_ data_20[512];

an und befülle die Arrays zb: data_00[i] = 'a' usw.
wenn ich die dann auslese und über Uart aus gebe habe ich immer an der 
gleichen Stelle mehrere Byte Fehler.

Den EBI starte ich so:

void initExternalRam(void){
/*--------------------------------------------------------------------------------------*/
  //SRAM einbinden mittels EBI (External Bus Interface)
  //RAM an Port H:(Ctrl), 
  //            J:D0..D3, A8..A11
  //            K:A0..A7
  /*! \brief Address where we want SDRAM to be accessed. */
  #define SDRAM_ADDR 0x4000

  /*! \brief Macro to access SDRAM. */
  #define SDRAM(addr) ((uint8_t *) SDRAM_ADDR)[addr]

  /*! \brief Number of test bytes to store to SDRAM */
  #define VECTOR_SIZE 40000L
  /*
   *  Hardware setup for 3-port SDRAM interface:
   *
   *  PORTK[7:0] - A[7:0]
   *
   *  PORTJ[7:0] - {A[11:8],D[3:0]}
   *
   *  PORTH[7:0] - {WE,CAS,RAS,DQM,BA0,BA1,CKE,CLK}
   *
   */

  /* Set signals which are active-low to high value */
  PORTH.OUT = 0x0F;


  /* Configure bus pins as outputs(except for data lines). */
  PORTH.DIR = 0xFF;
  PORTK.DIR = 0xFF;
  PORTJ.DIR = 0xF0;

  /* Set direction and output value of Chip Select line (C0). */
  PORTC.DIR = 0x01;
  PORTC.OUT = 0x00;





  // Initialize EBI. 
  EBI_Enable( EBI_SDDATAW_4BIT_gc,
              EBI_LPCMODE_ALE1_gc,
              EBI_SRMODE_ALE12_gc,
              EBI_IFMODE_3PORT_gc );

  // Initialize SDRAM 
  EBI_EnableSDRAM( EBI_CS_ASPACE_2MB_gc, //EBI_CS_ASPACE_8KB_gc,   // 8 KB address space. 
                   (void *) SDRAM_ADDR,    // Base address. 
                   false,                  // 2 cycle CAS Latency.
                   false,                  // 11 Row bits. 
                   EBI_SDCOL_8BIT_gc,      // 8 Column bits.
                   EBI_MRDLY_1CLK_gc,      // 1 cycle Mode Register Delay. 
                   EBI_ROWCYCDLY_1CLK_gc,  // 1 cycle Row Cycle Delay. 
                   EBI_RPDLY_1CLK_gc,      // 1 cycle Row to Pre-charge Delay. 
                   EBI_WRDLY_1CLK_gc,      // 1 cycle Write Recovery Delay. 
                   EBI_ESRDLY_1CLK_gc,     // 1 cycle Exit Self Refresh to Active Delay. 
                   EBI_ROWCOLDLY_1CLK_gc,  // 1 cycle Row to Column Delay. 
                   0x03FF,                 // 1023 cycle Refresh Period (32.8 ms @ 2MHz). 
                   0x0100 );               // 256 cycle Initialization Delay (128 us @ 2MHz). 


}

Stimmt meine EBI nicht oder woran kann es liegen?


Danke,
Markus

[Jens (Gast)]

Du schreibst nicht in das externe RAM sondern in das interne.
Das hier:
#define SDRAM_ADDR 0x4000

/*! \brief Macro to access SDRAM. */
  #define SDRAM(addr) ((uint8_t *) SDRAM_ADDR)[addr]

ist die Startadresse (0x4000) für deinen externen RAM-Bereich. Deine 
Arrays müssen ab diesem RAM-Bereich im Speicher liegen. Bei den 
Test-Sourcen, die ich gefunden habe, schreiben die immer "zu Fuß" ins 
RAM. Ist für mich unlogisch, aber anscheinend geht das nicht besser.

Grüße, Jens

[Markus C. (ljmarkus)]

Hallo Jens,

hmm, wie lege ich denn die arrays in den SDRAM und beschreibe und lese 
die?

danke, markus

[Jens (Gast)]

Ich schau mal wo ich die Sachen habe. Vielleicht kann ich die Sachen 
hochladen.
Dauert aber ein bisschen. Vielleicht heute Abend.
Bei mir habe ich das externe RAM auf dem XPLAIN Board in Betrieb 
genommen und das läuft ganz gut.
Was ich aber nicht verstehe wou das Ganze gut sein soll. Wenn ich die 
Werte "zu Fuß" reinschreiben muss, ist das mit jedem beliebigen 
Controller möglich, oder?
Ich hatte gehofft, dass der Compiler merkt dass ich mehr Speicher habe 
und kann dann das RAM dementsprechend aufteilen. Vielleicht weißß hier 
ja noch jemand etwas mehr als ich.
Gruß, Jens

[Markus C. (ljmarkus)]

Also mein Wunsch wäre ja das man frei wählen kann wo man was rein 
schreibt.

uint8_t xyz[100];          // liegt im internem SRAM
uint8_t abc[100] extern;   // liegt im externen SRAM

somit nutzt man die schnelleren 8Kb internen SRAM
und da GCC dezeit ja nur max. 64Kb unterstützt, hat man 56Kb externen 
SDRAM.

lg, markus

[Jens (Gast)]

Im Tutorial kann ich die maximale Größe grad nicht sehen. Wo steht, dass 
der Speicher begrenzt ist?
Kann man vielleicht mehr nehmen, wenn man malloc() verwendet? Ich werde 
das heute Abend auf dem XPLAIN versuchen. Mit dem JTAG-Debugger müsste 
ich die Werte ja sehen können. Oder ich schreibe die 8Mbyte voll und 
lese die wieder aus. Ich lass mir was einfallen.
Ich hab auch im Netz noch keine vernünftigen Sourcen zum EBI gefunden.
Wie gesagt, bei mir hab ich ein Funktion, die den externen Speicher 
beschreibt. Effektiv ist das nicht!

Gruß

[Jens (Gast)]

Wie gesagt, bei mir dauert das immer ein bisschen, da ich nicht so viel 
Zeit habe. Schau immer mal wieder hier rein. Ich werde die Ergebnisse 
hochladen! :-)

[Markus C. (ljmarkus)]

Hallo Jens,

habe diese diese Funktion:

/*************************************************************************
 *
 *  Name         : .init3
 *
 *  Beschreibung : EBI und SysClock initialisieren
 *
 *                 Aufruf vor main durch den StartUp Code
 *                 Stack-Pointer ist hier schon initialisiert.
 *                 SDRam ab Adresse 0x4000 mit einer Länge von 8MB
 *                 einblenden.Der Speicher wird für globale Variablen
 *                 (static) und malloc()/free() verwendet. Für diese
 *                 Funktionen stehen 48K zur Verfügung, da gcc und die
 *                 libc von einem 16-Bit Adressraum ausgehen.
 *
 *                 Initialwerte werden im Anschluss durch den StartUp Code
 *                 aus dem Flash ins SDRam kopiert.
 *                 Die Linkeroptionen
 *                 "-Wl,-section-start=.data=0x804000" und
 *                 "-Wl,-defsym=__heap_end=0x80ffff"
 *                 sind Pflicht!
 *                 avr-size berücksichtigt den dazubekommenen Speicher 
 *                 nicht! 
 *
 *                 32KHz/32MHz RC-OSC Starten
 *                 PLL mit 64MHz Starten
 *                 ClkCpu auf 32MHz; ClkPer2 auf 64MHz setzen
 *
 *  Parameter    : keine
 *
 *  Rückgabe     : keine
 *
 *************************************************************************/
//#define LED0_ON             (PORTE_OUTCLR=PIN0_bm)
//#define LED1_ON             (PORTE_OUTCLR=PIN1_bm)
//#define LED0_OFF            (PORTE_OUTSET=PIN0_bm)
//#define LED1_OFF            (PORTE_OUTSET=PIN1_bm)

#define LED0_GREEN            (PORTE_OUTSET=PIN0_bm) && (PORTE_OUTCLR=PIN1_bm)
#define LED0_RED              (PORTE_OUTSET=PIN1_bm) && (PORTE_OUTCLR=PIN0_bm)
#define LED0_OFF              (PORTE_OUTCLR=PIN0_bm) && (PORTE_OUTCLR=PIN1_bm)

void __attribute__ ((naked, section(".init3"))) XplainMemAndClk(void)
{
  uint8_t temp = (WDT.CTRL & ~WDT_ENABLE_bm) | WDT_CEN_bm;
  CCP = CCP_IOREG_gc;
  WDT.CTRL = temp;                       // Watchdog abschalten
  
  PORTE.DIR      = 0xff;                 // LEDs auf Ausgang
  PORTE.OUT      = 0xff;                 // LEDs aus
  LED0_OFF;
  //LED0_ON;                               // Konfiguration beginnt...
  
  // EBI Initialisieren;  stammt aus der Atmel AppNote AVR1312.PDF,
  // der TechNote AVR1312.ZIP und dem Micron MT48LC16M4A2TG DataSheed

  PORTH.OUT = 0x0F;                      // EBI PORTs richten
  PORTH.DIR = 0xFF;
  PORTK.DIR = 0xFF;
  PORTJ.DIR = 0xF0;

  EBI.CTRL       = EBI_SDDATAW_4BIT_gc | EBI_IFMODE_3PORT_gc;
  EBI.SDRAMCTRLA = (EBI.SDRAMCTRLA & ~(EBI_SDCAS_bm | EBI_SDROW_bm | EBI_SDCOL_gm)) |
                    EBI_SDCOL_10BIT_gc | EBI_SDROW_bm;
  EBI.SDRAMCTRLB = EBI_MRDLY_0CLK_gc | EBI_ROWCYCDLY_1CLK_gc | EBI_RPDLY_0CLK_gc;
  EBI.SDRAMCTRLC = EBI_WRDLY_0CLK_gc | EBI_ESRDLY_0CLK_gc    | EBI_ROWCOLDLY_0CLK_gc;
  EBI.REFRESH    = 0xff00;
  EBI.INITDLY    = 0x0100;
  EBI.CS3.CTRLB  = (EBI.CS3.CTRLB & ~(EBI_CS_SDSREN_bm | EBI_CS_SDMODE_gm)) |
                    EBI_CS_SDMODE_NORMAL_gc;
  EBI.CS3.BASEADDR = (((uint32_t) SDRAM_ADDR)>>8) & (0xFFFF<<(EBI_CS_ASPACE_8MB_gc>>2));
  EBI.CS3.CTRLA  = (EBI.CS3.CTRLA & ~(EBI_CS_ASPACE_gm | EBI_CS_MODE_gm)) |
                    EBI_CS_ASPACE_8MB_gc | EBI_CS_MODE_SDRAM_gc;

  while(!(EBI.CS3.CTRLB & EBI_CS_SDINITDONE_bm)); // warten bis fertig

  // System Clock initialisieren
  OSC.PLLCTRL    = OSC_PLLSRC_RC32M_gc | OSC_PLLFAC3_bm;// 32MHz/4 * 8 = 64MHz
  OSC.DFLLCTRL   = OSC_RC32MCREF_bm;      // 32MHz Rc kalibrieren
  DFLLRC32M.CTRL = DFLL_ENABLE_bm;        // Kalibrierung ein

  OSC.CTRL      |= OSC_RC32MEN_bm | OSC_RC32KEN_bm; // 32M+32K OSC einschalten
  while(!(OSC.STATUS & OSC_RC32KRDY_bm)); // warten bis stabil
  while(!(OSC.STATUS & OSC_RC32MRDY_bm)); // warten bis stabil

  OSC.CTRL      |= OSC_PLLEN_bm ;         // PLL mit 64Mhz ein
  uint8_t CTRLn  = (CLK.PSCTRL & (~(CLK_PSADIV_gm | CLK_PSBCDIV1_bm))) |
                    CLK_PSADIV_1_gc | CLK_PSBCDIV_1_2_gc;
  CCP            = CCP_IOREG_gc;          // ClkCPU = 32Mhz; ClkPer2 = 64 MHz
  CLK.PSCTRL     = CTRLn;                 // Prescaler setzen
  while(!(OSC.STATUS & OSC_PLLRDY_bm));   // warten bis PLL stabil
  CCP            = CCP_IOREG_gc;
  CLK.CTRL       = CLK_SCLKSEL_PLL_gc;    // Sysclock über PLL

  // SDRAM testen
  uint16_t Crc1  = 0xDEAD;
  uint16_t Crc2  = 0xDEAD;
  uint16_t i;
  uint8_t  Val   = 0;
  
  
  for(i=SDRAM_ADDR; i < 0xffff - SDRAM_ADDR; i++)
  {
    *(uint8_t*) i = Val;                  // Speicher beschreiben
    Crc1 = _crc_ccitt_update(Crc1 ,Val++);// CRC bilden
  }

 // *(uint16_t*) 0x7654 = 0xBEAF;         // Fehler erzwingen
 
 
  for(i=SDRAM_ADDR; i < 0xffff - SDRAM_ADDR; i++)
  {
    Val  = *(uint8_t*) i;                // Speicher lesen
    Crc2 = _crc_ccitt_update(Crc2 ,Val); // CRC bilden
  }

  if (Crc1 == Crc2) {  LED0_GREEN; }  // passt?
  else { LED0_RED; }                // Speicherfehler

//  if(Crc1 == Crc2) LED0_OFF;                     // passt? 
//  else LED0_ON;                             // Speicherfehler!
//  LED1_ON;                               // ... geschafft
}

im makefile:

#---------------- Linker Options ----------------
#  -Wl,...:     tell GCC to pass this to linker.
#    -Map:      create map file
#    --cref:    add cross reference to  map file
LDFLAGS = -Wl,-Map=$(TARGET).map,--cref
LDFLAGS += $(EXTMEMOPTS)
LDFLAGS += $(patsubst %,-L%,$(EXTRALIBDIRS))
LDFLAGS += $(PRINTF_LIB) $(SCANF_LIB) $(MATH_LIB)
#LDFLAGS += -T linker_script.x
LDFLAGS += -Wl,-section-start=.data=0x804000
LDFLAGS += -Wl,-defsym=__heap_end=0x80ffff

lg, markus

[Jens (Gast)]

Der Speicher auf deinem Board ist genauso groß wie auf dem XPLAIN Board. 
Daher müssten die Sourcen kompatibel sein. Ab 18 Uhr bin ich zu Hause 
und kann das bei mir mal testen. Die Ergebnisse werde ich dann hier 
hochladen. Ich bin mir sicher, dass das nicht nur für uns zwei 
interessant ist!

[Markus C. (ljmarkus)]

Wenn ich mir das jetzt so durchrechne, externer SDRAM fängt bei 0x4000 
an.
0xFFFF - 0x4000 = 49kB die man nutzen kann.

Bis heute abend. markus

[Jens (Gast)]

Also ich bin einen Schritt weiter:
Ich habe das exteren SDRAM am Laufen, aber du hast Recht: Man kann nur 
49kByte benutzen. Dafür kannst du aber das Ram so einbinden wie du das 
wolltest. Du kannst einfach in das Array schreiben und es wird 
automatisch im externen RAM angelegt. Schau dir das mal an. Vielleicht 
kannst du das direkt laufen lassen.
Jetzt muss man nur noch rausbekommen, warum die Größe limitiert ist. Das 
ist sehr unschön! Ich brauche mehr Platz.
Wenn man mit einer Funktion ins RAM schreibt geht mehr. Das habe ich 
schon getestet. Da gehen wirklich die 8MByte. Aber halt langsamer.
Ich hänge das Projekt an!

[Markus C. (ljmarkus)]

Hallo Jens,

ja nur das was ich nicht verstehe ist warum nur 49kB nutzbar sind?
da fehlen 16kB (8kB vom internen) und 8kB vom externen.

lg, markus

[Jens (Gast)]

Ich hab es:
Im Datenblatt auf Seite 22 steht, das das interne SRAM auf Adresse 
0x2000 los geht.
Enn man mehr als 64kByte haben will, muss man die Adressierung selber 
machen und einen 32bit Pointer anlegen. In den Tutorials von Atmel ist 
da was drin. Aber wie gut das geht weiss ich noch nicht.
Ich habe hier im Forum eine Bibliothek gefunden (himem.h). Die macht 
genau das. Die verwendet nicht nur die RAMPX und RAMPY Pointer, sondern 
auch den RAMPZ Pointer. Ich hab die noch nicht implementiert. Aber 
vielleicht hast du heute noch Muse das zu tun. Ich schaff das heute 
wahrscheinlich nicht mehr.
Ansonsten ab morgen mehr. Ob ich am Wochenende dazu komme weiss ich 
nicht. Du müsstest genau sagen, was du brauchst. Dann kann ich morgen 
vielleicht mal einen Studenten in der Firma dran setzten!

Grüße und schönen Abend, Jens

[Markus C. (ljmarkus)]

Hallo Jens,

das es "normal" mit dem GCC nur bis 64kB geht ist mir klar.

Dem Linker sage ich folgendes:

#---------------- Linker Options ----------------
#  -Wl,...:     tell GCC to pass this to linker.
#    -Map:      create map file
#    --cref:    add cross reference to  map file
LDFLAGS = -Wl,-Map=$(TARGET).map,--cref
LDFLAGS += $(EXTMEMOPTS)
LDFLAGS += $(patsubst %,-L%,$(EXTRALIBDIRS))
LDFLAGS += $(PRINTF_LIB) $(SCANF_LIB) $(MATH_LIB)
#LDFLAGS += -T linker_script.x
LDFLAGS += -Wl,-section-start=.data=0x804000
LDFLAGS += -Wl,-defsym=__heap_end=0x80ffff

Bei dieser Einstellung habe ich ja 49kB zuverfügung.


der interne geht bei 0x2000 los, der externe bei 0x4000


0xFFFF - 0x2000 = 57kB. Da fehlen doch aber noch 8kB

lg, markus

[Jens (Gast)]

Schau mal ins Datenblatt rein!
Von 0x0000 - 0x1FFF sind die ganzen Register
    0x2000 - 0x3FFF internes SRAM
    0x4000 - 0xFFFFFF externes RAM
Der Atmel hat eine durchgehende Adressmap für alle Speicher und 
Register.
Mit den 49kB geht das genau auf.
Deine Linker Optionen muss ich zugeben, die sagen mir überhaut nichts. 
Damit hatte ich bis jetzt noch nichts zu tun.
Ich lade morgen nochmal den anderen Code hoch, der den Speicher bis 
8MByte unterstützt. Da müssten wir uns mal Gedanken machen, ob man den 
inline einfügt und wir müssten testen, ob das die Performance steigert. 
Der Mittelweg ist dann der Richtige. Nämlich Laufzeit und 
Speicherbelastung.

Gruß, Jens

[Markus C. (ljmarkus)]

Ich habe nochmal etwas getestet, ziehe ich meinen CS Jumper für den 
externen RAM, dann wird kein Array mehr angelegt was bedeutet das der 
interne Speicher nicht angesprochen wird.

lg, markus

[Jens (Gast)]

Das glaube ich nicht. Kannst du den Code mal posten?
Das CS geht doch nur auf den externen SRAM. Du könntest auch mal 
beschreiben, was du vor hast. Dann kann man die SOurcen gleich so 
trimmen, das das passt.

Gruß, Jens