[XMega][C] Flash Write möglich aus Anwendung?

[Robert O. (rob_o)]

Hallo allerseits,
habe nach längerer Zeit wieder mit C Programmieren angefangen und mich 
gleichzeitig für einen XMega entschieden. Meine bisherigen Erfahrungen 
beschränken sich auf die mega Serie. Nun habe ich auch schon das erste 
Problem (zumindest das erste über das ich schreibe ;) ), ich möchte für 
meine Anwendung ein Array welches im Flash angesiedelt ist und 7200byte 
groß ist auf einem port ausgeben, das sollte mit pgm_read_byte kein 
problem sein.
Jetzt kommts aber, das Array soll über USART zu ändern gehen, also alle 
7200 byte über die serielle Schnittstelle empfangen und nach eventueller 
Checksummen Prüfung in den Flash Speicher schreiben.
Geht das aus der Anwendung?
Gibt es eine Alternative?
Mir ist schon eingefallen den Bootloader code zu erweitern denn der 
macht ja prinzipiell genau das was ich will, jedoch müsste ich dann 
meine Kommunikation umbauen (ich verwende ein Matlab Frontend) da die ja 
dannn lernen müsste mit dem BL zu kommunizieren.

Bin für Vorschläge und Codeschnipsel dankbar.
mfg. Robert

[Moby (Gast)]

Xmega Flash beschreiben geht grundsätzlich nur mit Code in der 
Boot-Section.

[Stephan B. (matrixstorm)]

Mit entsprechender API im BLS geht sowas schon.
Man muss aber ein paar Dinge beachten, sonst crasht der AVR.


http://matrixstorm.com/avr/avrstick/#msdbootloader_api


MfG

[Robert O. (rob_o)]

Habe mir die Seite matrixstorm einmal angesehen. Ich verwende jedoch 
einen 128A1 ohne USB, müsste also den Bootloader reverse-engineeren und 
die relevanten Stellen auf einen "normalen" Bootloader umschreiben damit 
ich die API verwenden kann, das ist jedoch außerhalb meiner 
Möglichkeiten.

[Stephan B. (matrixstorm)]

Hallo.

API ist nur eine Flashseite, mehr oder weniger unabhaengig vom 
Bootloader.
Hab das ganze sogar ins FLIP reingepatch, ohne FLIP jemals neu zu 
compilen.

Ich haenge dir mal die API Seite an.

Bei Fragen helfe ich gern.

MfG

[Robert O. (rob_o)]

Ich denke ich bekomme eine Ahnung wie das funkt.
In der letzten flash page in der BL Section steht deine API page 
(compilierte __bootloader__**** files) Am Beginn der API Page ist eine 
Sprungtabelle die unter anderem do_spm (Offset 2) anspringt.
In der Applikation wird wird apipage.h inkludiert, dort wird mit extern 
definierten funktionen auf die Sprungtabelle verwiesen.
(#define APIPAGE__bootloader__do_spm  (APIPAGE_PAGEBYTEADDRESS+0x08))

Es wird also gar kein code aus dem BL verwendet, somit patcht man die 
apipage anstelle der letzten flash page in den Bootloader.

Einiges ist jedoch noch unklar:
.) APIPAGEAUXSECTION ist nirgendwo definiert oder ist das nicht 
notwendig?
.) section (".apipage") müsste im Makefile def. sein. Kannst Du mir das 
auch zeigen?
.) was ist apipage.a?
.) Kannst Du mir die compilierte APIPage schicken damit ich den BL 
patchen kann? Ich plane avr-xboot (https://code.google.com/p/avr-xboot/) 
zu verwenden.

Danke für die Hilfe.
mfg. Robert

[Stephan B. (matrixstorm)]

Hallo

Robert Offner schrieb:
> APIPAGEAUXSECTION ist nirgendwo definiert oder ist das nicht
> notwendig?

Das ist ein Makro welches von meinem internen AUXSECTION System 
definiert wird. Du kannst es aber auch leer lassen, dann lander der 
entpsrechende Code eben in .text.
Der Grund fuer diese allgmeinere Programmierung: Manchmal passt (bei der 
Bootloaderprogrammierung) nicht alles in die BLS. Das AUXSECTION Level 
entscheidet dann per Makro, was statt in .text/.boot in einer Pseudo-BLS 
landet.

Robert Offner schrieb:
> section (".apipage") müsste im Makefile def. sein. Kannst Du mir das
> auch zeigen?

Das wird einfach als Linkeranweisung an den Anfang der letzten Seite des 
Flash positioniert. "-Wl,--section-start=.apipage=0x21e00" (im Falle von 
ATxmega128A3U)

Robert Offner schrieb:
> Kannst Du mir die compilierte APIPage schicken damit ich den BL
> patchen kann? Ich plane avr-xboot (https://code.google.com/p/avr-xboot/)
> zu verwenden.

Kann ich machen - aber schwatzen wir mal bei Tageslicht dueber. Bin 
schon ziemlich KO jetzt um diese Zeit.
Fuer meine 
http://www.ebay.de/itm/231298084713?ssPageName=STRK:MESELX:IT&_trksid=p3984.m1555.l2649 
habe ich aber auch einen Bootloader nach AVR1605 direkt mit APIPage 
vorhanden. (Ist das nicht sogar die Refernezimplementierung von XBoot?)



Robert Offner schrieb:
> was ist apipage.a?

Eine vorkompilierte Bibliothek fuers statische Linken (eingentlich 
object archive), welches das minimale __do_spm auf bequemere Funktionen 
umsetzt - siehe apipage.h .

Beispielsweise musst du nur noch "flash_writepage" aufrufen, waehrend 
ansonsten das alles gemacht werden muesste:

/*
 * __do_spm:
 * 
 * Call the "bootloader__do_spm"-function, located within the BLS via comfortable C-interface
 * During operation code will block - disable or reset watchdog before call.
 *
 * REMEMBER: interrupts have to be disabled! (otherwise code may crash non-deterministic)
 */


#if ((APIPAGE_TOTALADDRESSSPACEBYTESIZE_EXEC) >= 131071)
#  define __do_spm_complex__PROCESSEIND                \
    /* prepare the EIND for following (e)icall */              \
    "lds  r18  ,  %[eind]                \n\t"  \
    "push  r18                    \n\t"  \
    "ldi  r18  ,  %[spmfuncaddrEIND]            \n\t"  \
    "sts  %[eind]  ,  r18                \n\t"
#  define __do_spm_complex__RESTOREEIND                \
    "pop  __tmp_reg__                  \n\t"  \
    "sts  %[eind]  ,  __tmp_reg__              \n\t"
#  define __do_spm_complex__CALLOPCODE  "eicall\n\t"
#else
#  define __do_spm_complex__PROCESSEIND
#  define __do_spm_complex__RESTOREEIND
#  define __do_spm_complex__CALLOPCODE  "icall\n\t"
#endif

/* WARNING: "___bootloader__do_spm__ptr" is a functionptr in flash. 
 * Using "APIPAGE__bootloader__do_spm*" (flash location) without conversion will break code!
 * 
 * "__do_spm_complex" is based on spminterface of USBaspLoader, by Stephan Baerwolf
 */
#define __do_spm_complex(___bootloader__do_spm__ptr, flashword_ptr, nvmcommand, dataword, MagicValue)  \
({                          \
    asm volatile (                      \
    "push  r0                    \n\t"  \
    "push  r1                    \n\t"   \
                          \
    /* load the magic value (MagicValue) */                \
    "ldi  r23  ,  %[magicD]              \n\t"  \
    "ldi  r22  ,  %[magicC]              \n\t"  \
    "ldi  r21  ,  %[magicB]              \n\t"  \
    "ldi  r20  ,  %[magicA]              \n\t"  \
                          \
    /* load the address (flashword_ptr) */                \
    "mov  r13  ,  %B[flashptr]              \n\t"  \
    "mov  r12  ,  %A[flashptr]              \n\t"  \
    "mov  r11  ,  %C[flashptr]              \n\t"  \
                          \
    __do_spm_complex__PROCESSEIND                  \
                          \
    /* also load the nvm command */                  \
    "mov  r18  ,  %[nvmcmd]              \n\t"  \
                          \
    /* load the data (dataword) */                  \
    "mov  r1  ,  %B[data]              \n\t"  \
    "mov  r0  ,  %A[data]              \n\t"  \
                          \
    /* finally call the bootloader-function */                \
    __do_spm_complex__CALLOPCODE                  \
    __do_spm_complex__RESTOREEIND                  \
                          \
    "pop  r1                    \n\t"  \
    "pop  r0                    \n\t"  \
                          \
    /* stop further execution in case of unexpected error */            \
    "cpi  r18  ,  0xff                \n\t"   \
    "errorloop%=:                    \n\t"  \
    "breq errorloop%=                    \n\t"  \
    :                          \
    : [flashptr]    "r"  (flashword_ptr),            \
      [spmfunctionaddress]  "z"  ((uint16_t)((uint32_t)___bootloader__do_spm__ptr)),    \
      [spmfuncaddrEIND]    "M"  ((uint8_t)(((uint32_t)___bootloader__do_spm__ptr)>>16)),  \
      [eind]      "i"  (_SFR_MEM_ADDR(EIND)),            \
      [data]      "r"  (dataword),              \
      [magicD]      "M"  (((MagicValue)>>24)&0xff),          \
      [magicC]      "M"  (((MagicValue)>>16)&0xff),          \
      [magicB]      "M"  (((MagicValue)>> 8)&0xff),          \
      [magicA]      "M"  (((MagicValue)>> 0)&0xff),          \
      [nvmcmd]      "r"  (nvmcommand)              \
    : "r0","r1","r11","r12","r13","r18","r20","r21","r22","r23"            \
    );                          \
})


[...]

/* write operations using __bootloader_do_spm driver */

void __do_spm(const uint_farptr_t flashword_ptr, const uint8_t nvmCommand, const uint16_t dataWord) {
  uint8_t sreg_backup = CPU_SREG;
  cli();
#if (USE_SPMINTEREFACE_MAGICVALUE != 0)
  __do_spm_complex(((uint32_t)APIPAGE__bootloader__do_spm_magicblock)>>1, flashword_ptr, nvmCommand, dataWord, (uint32_t)USE_SPMINTEREFACE_MAGICVALUE);
#else
  /* DANGER: ignores platform protection by magical value */
#  warning USE_SPMINTEREFACE_MAGICVALUE is zero - platform protection deactivated!
  __do_spm_complex(((uint32_t)APIPAGE__bootloader__do_spm)>>1           , flashword_ptr, nvmCommand, dataWord, (uint32_t)USE_SPMINTEREFACE_MAGICVALUE);
#endif
  CPU_SREG=sreg_backup;
}

[...]

size_t flash_writepage_Ex(__extfuncptr_type(apipage__do_spm_t) *spmfunc, const uint8_t in_pageBuffer[SPM_PAGESIZE], const uint_farptr_t in_pageNr, const uint8_t nvmCommand) {
  uint_farptr_t flashAddress = in_pageNr*((uint_farptr_t)SPM_PAGESIZE);

  flash_eraseflashbuffer_Ex(spmfunc, in_pageBuffer, flashAddress);
  flash_loadflashbuffer_Ex(spmfunc, in_pageBuffer, flashAddress);
  __extfuncptr_function(apipage__do_spm_t, spmfunc, flashAddress, nvmCommand, 0);

  return SPM_PAGESIZE;
}

[...]

#if (!(defined(APIPAGE_OLDFLASHWRITE)))
size_t flash_writepage(const uint8_t in_pageBuffer[SPM_PAGESIZE], const uint_farptr_t in_pageNr) {
  __extfuncptr_type(apipage__do_spm_t) spmfunc = __extfuncptr_getPtr(apipage__do_spm_t, __do_spm);
  return flash_writepage_Ex(&spmfunc, in_pageBuffer, in_pageNr, NVM_CMD_ERASE_WRITE_FLASH_PAGE_gc);
}
#else
/* very poor: old ATxmegas don't support some types of erasing/wrting  - working around */
size_t flash_writepage(const uint8_t in_pageBuffer[SPM_PAGESIZE], const uint_farptr_t in_pageNr) {
  __extfuncptr_type(apipage__do_spm_t) spmfunc = __extfuncptr_getPtr(apipage__do_spm_t, __do_spm);
#if (APIPAGE_OLDFLASHWRITE)
  return flash_writepage_Ex(&spmfunc, in_pageBuffer, in_pageNr, APIPAGE_OLDFLASHWRITE);
#else
  return flash_writepage_Ex(&spmfunc, in_pageBuffer, in_pageNr, (in_pageNr<(BOOT_SECTION_START/SPM_PAGESIZE))?NVM_CMD_ERASE_WRITE_APP_PAGE_gc:NVM_CMD_ERASE_WRITE_BOOT_PAGE_gc);
#endif
}
#endif

Bis nachher/morgen.

MfG Stephan

p.s.: Nur zur Erwaehnung die ganzen Codeauszuege sind Bestandteil meines 
AVR Stick Projektes: http://matrixstorm.com/avr/avrstick/