"C" Will alle Variablen im ext. Speicher haben, aber wie mach ich das?

[Steffen H. (avrsteffen)]

Hallo Leute,

Ich steh hier vor einem Problem, bei dem ich nicht weiter komm.

Ich habe hier ein Programm für einen XMega192A3 (16k SRAM) und möchte es 
in einen XMega128A1 (8k SRAM) portieren. Jetzt reicht der interne RAM 
Speicher des XMega128 leider nicht aus.

Ich habe allerdings SDRAM am XMega dran hängen und möchte dass der 
AVR-GCC all meine Variablen dorthin speichert.

Die Variablen sind fast alle in einem Struckt angelegt wie z.B. so hier:

struct controllerSingleton {    // main TG controller struct
  uint16_t magic_start;      // magic number to test memory integity  
  double null;          // dumping ground for items with no target
  uint8_t test;
  uint8_t src;          // active source device
  uint8_t default_src;      // default source device
  uint8_t linelen;        // length of currently processing line
  uint8_t led_state;        // 0=off, 1=on
  int32_t led_counter;      // a convenience for flashing an LED
  char in_buf[INPUT_BUFFER_LEN];  // input text buffer
  char out_buf[OUTPUT_BUFFER_LEN];// output text buffer
  char saved_buf[SAVED_BUFFER_LEN];// save the input buffer
  uint16_t magic_end;
};

Interner SRAM:   0x2000 - 0x3FFF  ( soll nur für den Stack bleiben)
Externer SDRAM:  0x4000 - 0xFFFF  ( für alle angelegten Variablen und 
Heap)

Reicht es im Makefile sowas wie hier

avr-gcc ... 
-Wl,--section-start,.data=0x804000,--defsym=__heap_end=0x80ffff

zu schreiben, oder muss ich noch mehr beachten und was hat es mit dem 
"malloc()" auf sich?

Den SDRAM muss ich natürlich auch noch initialisieren. In ASM war das 
für mich kein Problem und ich habe damit den SDRAM auch schon testen 
können.


Ich bin blutiger "C" Anfänger..


Gruß Steffen

[M. K. (avr-frickler)]

Von XMEGAs habe ich keine Ahnung aber da es wohl derselbe Compiler ist 
wird es wohl ähnlich gehen wie bei meinem ATMega2560 mit externem SRAM

Ich habe 2 Linker-Symbole definiert 
--defsym=__heap_start=0x802200,--defsym=__heap_end=0x80ffff

und dann muss auch noch sehr früh das Interface fürs externe RAM 
aktiviert werden.

// externes RAM aktivieren
void __attribute__ ((naked)) __attribute__ ((section (".init1"))) init_xram(void) {
    XMCRA = (1<<SRE);
}

[Steffen H. (avrsteffen)]

Danke für die Antwort

M. K. schrieb:
> Ich habe 2 Linker-Symbole definiert
> --defsym=__heap_start=0x802200,--defsym=__heap_end=0x80ffff

Also reicht es eventuell schon, dem Linker zu sagen wo meine 
SRAM-Section beginnt und endet?

Und was hat es denn jetzt mit diesem *malloc()* auf sich?


Bin gerade dran das EBI im SDRAM - Mode zu initialisieren. Mal sehen ob 
das klappt.


Gruß Steffen

[M. K. (avr-frickler)]

Steffen H. schrieb:
> Und was hat es denn jetzt mit diesem *malloc()* auf sich?

Was ist jetzt genau deine Frage?
Also malloc() reserviert einen Speicherblock auf dem Heap.

Wenn du das ganze ein wenig debuggen möchtest, kannst du dir noch Zeiger 
auf den Anfang-/Ende des Heaps besorgen. Ausserdem gibt es noch einen 
Zeiger auf die aktuelle Größe des Heaps.

extern  char     *__malloc_heap_start, *__brkval, *__malloc_heap_end;   // Variablen für den heap

[Stefan E. (sternst)]

Steffen H. schrieb:
> Also reicht es eventuell schon, dem Linker zu sagen wo meine
> SRAM-Section beginnt und endet?

Nein, was M.K. da gepostet hat, verlegt nur den Heap in das externe RAM, 
nicht aber die Variablen. Deine Variante war schon richtig.

Steffen H. schrieb:
> Und was hat es denn jetzt mit diesem malloc() auf sich?

Damit holt man sich dynamisch Speicher vom Heap.

[Steffen H. (avrsteffen)]

Also sollte es mit

avr-gcc ... -Wl,--section-start,.data=0x804000,--defsym=__heap_end=0x80ffff

machbar sein, wie oben im Bild angedeutet?


Gruß Steffen

[Stefan E. (sternst)]

Ja.

[Jörg W. (dl8dtl) (Moderator)]

Wenn du kein malloc() benutzt, dann brauchst du dich um Dinge wie
__heap_end auch nicht kümmern.  Es reicht dann völlig, .data auf
den Anfang des externen SDRAM zu setzen (der Stack wird ja ohnehin
auf das obere Ende des internen SRAM initialisiert).

Allerdings musst du dich natürlich drum kümmern, dass das XMEM-
Interface frühzeitig genug initialisiert wird, so wie das oben
schon mit der entsprechenden Funktion in .init1 angedeutet war.

[Steffen H. (avrsteffen)]

Okay, Danke

Bin immer noch am einbinden einer SDRAM Initialisierung. In ASM war das 
alles viel einfacher..

//*******************************************************************************************************

Init_extSDRAM:
//PORT-Settings for ext. SDRAM
  ldi    accu1, 0xFF
  sts    PORTH_DIR, accu1
  sts    PORTK_DIR, accu1
  ldi    accu1, 0xF0
  sts    PORTJ_DIR, accu1
  ldi    accu1, 0x0F
  sts    PORTH_OUT, accu1

// Config EBI
  ldi    accu1, EBI_SDDATAW_4BIT_gc + EBI_LPCMODE_ALE1_gc + EBI_SRMODE_ALE1_gc + EBI_IFMODE_3PORT_gc
  sts    EBI_CTRL, accu1
// Config SDRAM
  ldi    accu1, EBI_SDROW_bm + EBI_SDCOL_10BIT_gc
  sts    EBI_SDRAMCTRLA, accu1

  ldi    accu1, byte1(768);768
  sts    EBI_REFRESH, accu1
  ldi    accu1, byte2(768);768
  sts    EBI_REFRESH +1, accu1

  ldi    accu1, byte1(1023)
  sts    EBI_INITDLY, accu1
  ldi    accu1, byte2(1023)
  sts    EBI_INITDLY +1, accu1

// 1 cycle Mode Register Delay. + 7 cycle Row Cycle Delay. + 2 cycle Row to Pre-charge Delay
  ldi    accu1, EBI_MRDLY_1CLK_gc + EBI_ROWCYCDLY_7CLK_gc + EBI_RPDLY_2CLK_gc
  sts    EBI_SDRAMCTRLB, accu1

// 2 cycle Write Recovery Delay + 7 cycle Exit Self Refresh to Active Delay + 2 cycle Row to Column Delay
  ldi    accu1, EBI_WRDLY_2CLK_gc + EBI_ESRDLY_7CLK_gc + EBI_ROWCOLDLY_2CLK_gc
  sts    EBI_SDRAMCTRLC, accu1

  ldi    accu1, EBI_CS_SDMODE_LOAD_gc
  sts    EBI_CS3_CTRLB, accu1

  clr    accu1
  sts    EBI_CS3_BASEADDR, accu1
  sts    EBI_CS3_BASEADDR +1, accu1

  ldi    accu1, EBI_CS_ASPACE_16M_gc + EBI_CS_MODE_SDRAM_gc
  sts    EBI_CS3_CTRLA, accu1

.equ  EBI_CS_SDINITDONE = 7
Wait_SDRAM_Init1:
  lds    accu1, EBI_CS3_CTRLB
  sbrs  accu1, EBI_CS_SDINITDONE
  rjmp  Wait_SDRAM_Init1

  ldi    accu1, EBI_IFMODE_DISABLED_gc
  sts    EBI_CTRL, accu1
  ldi    accu1, EBI_CS_SDMODE_NORMAL_gc
  sts    EBI_CS3_CTRLB, accu1
  ldi    accu1, EBI_SDDATAW_4BIT_gc + EBI_LPCMODE_ALE1_gc + EBI_SRMODE_ALE1_gc + EBI_IFMODE_3PORT_gc
  sts    EBI_CTRL, accu1

Wait_SDRAM_Init2:
  lds    accu1, EBI_CS3_CTRLB
  sbrs  accu1, EBI_CS_SDINITDONE
  rjmp  Wait_SDRAM_Init2
  ret

//*******************************************************************************************************

Gruß Steffen

[Läubi .. (laeubi)]

Steffen H. schrieb:
> In ASM war das
> alles viel einfacher..

Ja dan bleib doch bei ASM... immer dieses 'genörgel' das mit XYZ 'alles 
einfacher war'... Wie einfach war das den als du gerade mit ASM 
angefangen hast?
Deine ganzen lid/sti orgine kannst du nun durch einfache Zuweisung 
lösen, Rücksprünge mit Abbruchbedingung durch eine while Schleife, was 
ist daran bitte "komplizierter"?

Und wenn du unbedingt darauf bestehst das ASM einfacher ist, du kannst 
ja auch in C ASM Code einbinden, oder sogar ganze ASM Module schreiben 
und einbinden...

Ob das aber einfacher ist als sich mal mit den Grundlagen zu 
beschäftigen...?

[Jörg W. (dl8dtl) (Moderator)]

Läubi .. schrieb:
>> In ASM war das
>> alles viel einfacher..
>
> Ja dan bleib doch bei ASM... immer dieses 'genörgel' das mit XYZ 'alles
> einfacher war'... Wie einfach war das den als du gerade mit ASM
> angefangen hast?

;-)

Um mal zu zeigen, dass das in C wirklich nicht schlimmer ist:

#include <avr/io.h>

void
__attribute__ ((naked)) __attribute__ ((section (".init1")))
init_ebi(void) {
  //PORT-Settings for ext. SDRAM
  PORTH_DIR = 0xff;
  PORTK_DIR = 0xff;
  PORTJ_DIR = 0xf0;
  PORTH_OUT = 0x0f;

  // Config EBI
  EBI_CTRL = EBI_SDDATAW_4BIT_gc + EBI_LPCMODE_ALE1_gc +
             EBI_SRMODE_ALE1_gc + EBI_IFMODE_3PORT_gc;
  // Config SDRAM
  EBI_SDRAMCTRLA = EBI_SDROW_bm + EBI_SDCOL_10BIT_gc;
  EBI_REFRESH = 768;
  EBI_INITDLY = 1023;

  // 1 cycle Mode Register Delay. + 7 cycle Row Cycle Delay.
  // + 2 cycle Row to Pre-charge Delay
  EBI_SDRAMCTRLB = EBI_MRDLY_1CLK_gc + EBI_ROWCYCDLY_7CLK_gc +
                   EBI_RPDLY_2CLK_gc;

  // 2 cycle Write Recovery Delay + 7 cycle Exit Self Refresh
  // to Active Delay + 2 cycle Row to Column Delay
  EBI_SDRAMCTRLC = EBI_WRDLY_2CLK_gc + EBI_ESRDLY_7CLK_gc +
                   EBI_ROWCOLDLY_2CLK_gc;
  EBI_CS3_CTRLB = EBI_CS_SDMODE_LOAD_gc;
  EBI_CS3_BASEADDR = 0;
  EBI_CS3_CTRLA = EBI_CS_ASIZE_16M_gc + EBI_CS_MODE_SDRAM_gc;
  while ((EBI_CS3_CTRLB & EBI_CS_SDINITDONE_bm) == 0)
    { /* wait for SDRAM init */ }
  EBI_CTRL = EBI_IFMODE_DISABLED_gc;
  EBI_CS3_CTRLB = EBI_CS_SDMODE_NORMAL_gc;
  EBI_CTRL = EBI_SDDATAW_4BIT_gc + EBI_LPCMODE_ALE1_gc +
             EBI_SRMODE_ALE1_gc + EBI_IFMODE_3PORT_gc;
  while ((EBI_CS3_CTRLB & EBI_CS_SDINITDONE_bm) == 0)
    { /* wait for SDRAM init */ }
}

Ist also eigentlich alles dasselbe, außer dass man eine Zuweisung auch
über mehrere Zeilen schreiben kann, dass man sich keine „Akkus“ selbst
definieren muss, und dass man sich nicht um die Aufteilung der
16-bit-Register in high- und low-Bytes kümmern muss. ;-)

Ich habe es spaßeshalber für dich durch den Compiler geschoben um zu
sehen, ob es auch compiliert.  EBI_CS_ASPACE_16M_gc hat dem Compiler
nicht gefallen, da die Konstante offenbar EBI_CS_ASIZE_16M_gc heißt.
Hat dein Assemblercode wirklich so funktioniert?

(Ob das Ganze inhaltlich auch Sinn hat, weißt du natürlich nur selbst,
ich habe lediglich stupide deine Assemblerwust in C-Wust übertragen.)