AVR und 32Bit-Adressen

[Frank Roggel (Gast)]

Hallo zusammen,

ich rechne eine CRC über meinen Programmcode und hab dazu eine 
Dummy-Section angelegt, deren Adresse mir anzeigt, wo der Programmcode 
aufhört:

const uint16_t  Dummy        __attribute__((section (".dummy"      ), used, unused)) = 0xAAAA;
const uint16_t  AddresseVonDummy  __attribute__((section (".addressevondummy"  ), used, unused)) = (uint16_t)&Dummy;

Der Wert AddresseVonDummy liegt an einer fixen Adresse im Hexfile, damit 
ich den Wert im Bootloader auslesen kann.

Das funktioniert einwandfrei, aber nur mit 16Bit-Adressen.

Wenn ich ganze für einen ATMega1284 bauen will, bräuchte ich 
32Bit-Adressen.
Wenn ich nun folgendes probiere

const uint16_t  Dummy        __attribute__((section (".dummy"      ), used, unused)) = 0xAAAA;
const uint32_t  AddresseVonDummy  __attribute__((section (".addressevondummy"  ), used, unused)) = (uint32_t)&Dummy;

steht in AddresseVonDummy immer noch 0x00000000 drinn.

Wie geht das?

[(prx) A. K. (prx)]

Eine Funktion, die eine CRC auf einen Datenblock im RAM berechnet, ist 
auf einem AVR  nicht für ROM einsetzbar. Das musst du Byte für Byte 
berechnen, indem du mit einem Pointer ins ROM jedes Byte holst.

[Frank Roggel (Gast)]

A. K. schrieb:
> Eine Funktion, die eine CRC auf einen Datenblock im RAM berechnet,
> ist
> auf einem AVR  nicht für ROM einsetzbar. Das musst du Byte für Byte
> berechnen, indem du mit einem Pointer ins ROM jedes Byte holst.

Sicher, aber das hat nichts mit meinem Problem zu tun.

Mir geht es nur darum, wie ich auf einem AtMega1284 den Adressen 
jenseits der 64kByte darstellen kann.

[Jim M. (turboj)]

Wir lösen auf:

Dein ATMega1284 Build nutzt ein anderes Linker Skript, dass keine 
"dummy" Section kennt. Daher landet dummy an Addresse Null.

Schau also mal bei den entsprechenden Linker Skripten nach.

[Peter D. (peda)]

http://www.avrfreaks.net/sites/default/files/morepgmspace.h

[Frank Roggel (Gast)]

Jim M. schrieb:
> Wir lösen auf:
Schön wär's.


Ich hab folgenden Code:

const uint16_t  Dummy        __attribute__((section (".dummy"      ), used, unused)) = 0xAAAA;
const uint32_t  AddresseVonDummy32  __attribute__((section (".addressevondummy32"  ), used, unused)) = (uint32_t)&Dummy;
const uint16_t  AddresseVonDummy16  __attribute__((section (".addressevondummy16"  ), used, unused)) = (uint16_t)&Dummy;

Den kann ich auf einem ATMega644 oder auf einem ATMega1284 erzeugen, und 
es gibt immer das gleiche Ergebnis:
In AddresseVonDummy16 stehen die korrekten unteren 16Bit der Adresse von 
Dummy drinn.
In AddresseVonDummy32 steht 0x00000000 drinn.

Siehe Hexfile vom ATMega128P:
Dummy liegt an Adresse 0x0000050A.
AddresseVonDummy32 liegt an Adresse 0x1F7F4 und enthält 0x00000000.
AddresseVonDummy16 liegt an Adresse 0x1F7F8 und enthält 0x050A.

(...)
:02050A00AAAA9B
:020000021000EC
:04F7F4000000000011
:02F7F8000A0500
:00000001FF

[Frank Roggel (Gast)]

Peter D. schrieb:
> http://www.avrfreaks.net/sites/default/files/morepgmspace.h

Danke, aber hilft leider auch nicht.

GET_FAR_ADDRESS() ist ja AVR Code.
In meinem Fall müßte ja der Linker die Adresse von Dummy ausfüllen.

[Stefan E. (sternst)]

Frank Roggel schrieb:
> Wenn ich ganze für einen ATMega1284 bauen will, bräuchte ich
> 32Bit-Adressen.

Ich würde dafür einfach eine kleine Assembler-Datei in das Projekt 
integrieren:

  .global  AddresseVonDummy
  .section  .addressevondummy,"a",@progbits
  .type  AddresseVonDummy, @object
  .size  AddresseVonDummy, 4
AddresseVonDummy:
  .byte  lo8(Dummy)
  .byte  hi8(Dummy)
  .byte  hh8(Dummy)
  .byte  0

Kleiner Hinweis am Rande:
Es heißt eigentlich "Adresse" (mit einfachem d).

[Johann L. (gjlayde)]

Frank Roggel schrieb:
> const uint16_t  Dummy        __attribute__((section (".dummy"      ),

Schlecht, vermutlich eine Orphan Section.  Deren Position wird als durch 
implizite Regeln von ld für entsprechende Sections bestimmt.

Besser: definier ein eigenes Symbol in deinem Linker Skript.  Hat zudem 
den Vorteil, dass der CRC nicht nur über Code geht sondern auch über die 
Daten, welche zur Initialisierung des SRAM verwendet werden (also für 
.data und .rodata).

An die Adresse kommt man dann z.B. so:

#include <stdint.h>

extern uint8_t __data_load_end; // defined in ld script

uintptr_t getp (void)
{
    return (uintptr_t) &__data_load_end;
}

uint32_t getp32 (void)
{
    uint32_t addr;
    __asm ("ldi %A0, lo8(%1)" "\n\t"
           "ldi %B0, hi8(%1)" "\n\t"
           "ldi %C0, hh8(%1)"
           : "=d" (addr) : "i" (&__data_load_end));
    return addr;
}

extern const __memx uint8_t p24_memx[] __asm ("__data_load_end");

const __memx uint8_t* getp24_memx (void)
{
    return p24_memx;
}