AVR231: AES Bootloader Frage zu "TYPE_PREPARE" Record

[Tycho B. (asellus)]

Hallo,

in der loader.c gibt es eine Stelle, die ich nicht verstehe:

address = (const unsigned char __memx *)((unsigned long)bits << 16);
address = (const unsigned char __memx *)((unsigned long)address | ((unsigned long)*p++ << 8));
address = (const unsigned char __memx *)((unsigned long)address | *p++);
[...]
// Prepare for incoming data chunks by copying the page
// contents into the page buffer
case TYPE_PREPARE:
            {
              unsigned char *q = pageBuffer;
              const unsigned char __memx *r = address;

              do
              {
                *q++ = *r++;
              }
              while (--size);
              break;
            }

In der Appnote nennt sich das "FLASH PAGE PREPARE"

So wie ich das verstehe, wird der Flash in den RAM geladen. Wofür 
braucht man das bei einem Bootloader?

[Ob S. (Firma: 1984now) (observer)]

Tycho B. schrieb:

> So wie ich das verstehe, wird der Flash in den RAM geladen.

Nein. Da wird RAM-Inhalt (ggf. auch aus externem RAM) in den page buffer 
geladen. Letzteres ist zwar sicher auch irgendwie RAM, aber nicht direkt 
im RAM-Adress-Space erreichbar. Er muss über ein spezielles Verfahren 
beschrieben werden.

Allerdings gibt es einen solchen page buffer nicht bei jedem AVR8. ES 
gibt ihn bei den "Classic"-Tinys und -Megas, aber nur bei ganz wenigen 
(oder sogar nur einer?) der neuen Baureihen. Die eine, von der mir das 
sicher bekannt ist, ist AVRxxEAyy.

Für weitere Details darfst du gerne auch selber die Datenblätter lesen. 
Das hat noch niemandem ernsthaft geschadet...

[Tycho B. (asellus)]

union {
  struct {
    unsigned char m_rxBuffer[BUFFER_SIZE];  // Receive buffer
    unsigned char m_pageBuffer[PAGE_SIZE];  // Page is assembled here before
    // getting programmed to flash mem
  } part1;

  #if KEY_COUNT > 0
  struct {
    unsigned char m_tempbuf[256]; // Temp buffer for aesInit.
  } part2;
  #endif
} sharedbufs;

#define rxBuffer   sharedbufs.part1.m_rxBuffer
#define pageBuffer sharedbufs.part1.m_pageBuffer
#if KEY_COUNT > 0
#define tempbuf    sharedbufs.part2.m_tempbuf
#endif

switch (type)
          {
            // Erase page
            case TYPE_ERASE:
            spmErasePage(address);
            // Fall-through!

            // Prepare for incoming data chunks by copying the page
            // contents into the page buffer
            case TYPE_PREPARE:
            {
              unsigned char *q = pageBuffer;
              const unsigned char __memx *r = address;

              do
              {
                *q++ = *r++;
              }
              while (--size);
              break;
            }

            // Chunk of data is written into the page buffer
            case TYPE_DATA:
            {
              unsigned char *r = &pageBuffer[(unsigned long)(address) & 0xffff];

              do
              {
                *r++ = *p++;
              }
              while (--size);
              break;
            }

            // Program page buffer into flash page
            case TYPE_PROGRAM:
            {
              unsigned int *q = (unsigned int *)pageBuffer;
              const unsigned char __memx *r = address;

              do
              {
                wdt_reset();
                spmWriteWord(r, *q++);
                r += 2;
              }
              while (--size);

              spmErasePage(address);
              spmProgramPage(address);
              break;
            }

Nach meinem Verständnis wird mit case TYPE_DATA im normalen RAM eine 
Page aufgebaut.
Dann macht case TYPE_PROGRAM das Laden in den eigentlichen PageBuffer. 
Danach wird mit spmErasePage(address) und spmProgramPage(address) 
geschrieben.

pageBuffer ist auch keine besondere Adresse, es wird ganz normal im RAM 
allokiert.

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

Naja, steht doch da: "for incoming data chunks": wenn du nur Teile einer 
Page beschreibst über den Bootloader, willst du ja den Rest der Page auf 
dem vorherigen Zustand haben. Dafür musst du sie erstmal auslesen.

Wenn du über den Bootloader eh alles beschreibst, brauchst du das 
natürlich nicht.

[Tycho B. (asellus)]

Das heisst also, mit case TYPE_PREPARE liesst man den flash aus und kann 
dann mit case TYPE_DATA die ausgelesene Page im RAM modifizieren. Oder 
aber man liesst den flash gar nicht aus und benutzt case TYPE_DATA um 
die komplette Page erstmal im RAM aufzubauen. Danach wird geschrieben. 
Richtig so?

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

Ja, passt. Wenn du halt nur Teile einer Page mit TYPE_DATA sendest, dann 
wird der Rest, den du nicht gesendet hast, hinterher gelöscht. Sofern du 
eh alles schreiben wolltest, ist das natürlich egal.

[Tycho B. (asellus)]

Vielen Dank!

Letzte Frage, warum macht man hier & 0xffff?

unsigned char *r = &pageBuffer[(unsigned long)(address) & 0xffff];

Die Page wurde mit #define PAGE_SIZE 256 allokiert, würde nicht & 0xff 
reichen?

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

Keine Ahnung.

Am sinnvollsten wäre natürlich

… & (PAGE_SIZE - 1)

gewesen.

Oder gleich

… % PAGE_SIZE