Bootloader ATmega32 Problem

[Sebastian Z. (sz1985)]

Hallo zusammen,

ich bin gerade dabei einen Bootloader für den ATmega32 zu schreiben. 
Aktuell habe ich das Problem, dass er mir den Flash Speicher weder 
löscht noch mit Daten beschreibt.


Einstellungen:
Lockbits: 0xFF
Fuses:    0xDAFF

Linker:   -Ttext=0x7000

#include <string.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/boot.h>
#include <util/delay.h>
#include "uart1.h"
#include <avr/pgmspace.h>

#define UART_BAUD 103


unsigned char c;
unsigned char temp;


void program_page (uint32_t page, uint8_t *buf)
{
    uint16_t i;
    uint8_t sreg;
 
    /* Disable interrupts */
    sreg = SREG;
    cli();
 
    eeprom_busy_wait ();
   uart_putc(page);
    boot_page_erase (page);
    boot_spm_busy_wait ();      /* Wait until the memory is erased. */
   uart_puts("e");
    for (i=0; i<SPM_PAGESIZE; i+=2)
    {
        /* Set up little-endian word. */
        uint16_t w = *buf++;
        w += (*buf++) << 8;
    
        boot_page_fill (page + i, w);
    }
 
    boot_page_write (page);     /* Store buffer in flash page.    */
    boot_spm_busy_wait();       /* Wait until the memory is written.*/
 
    /* Reenable RWW-section again. We need this if we want to jump back */
    /* to the application after bootloading. */
    boot_rww_enable ();
 
    /* Re-enable interrupts (if they were ever enabled). */
    SREG = sreg;
}


int main()
{
uint16_t flash_page = 0;

uint8_t flash_data[SPM_PAGESIZE];
uint8_t c;
uint8_t temp;

    temp = MCUCR;
    GICR = temp | (1<<IVCE);
    GICR = temp | (1<<IVSEL);

//Befüllen des Buffers mit Testdaten für eine Page
memset(flash_data, 0x1F, sizeof(flash_data));

    uart_init(UART_BAUD); 
    sei();

uart_puts("Hier ist das Testprogramm zum löschen einer page\n");
_delay_ms(2000);

do
{
c = uart_getc();

if(c='d')
{
program_page((uint16_t)flash_page, flash_data);
}

}
while(c!='d');
uart_puts("Ende");

return 0;
}

Wenn ich mir das Flashabbild (als iHex) nach dem Ausführen des 
Schreibvorganges anschaue, habe ich im Flashbereich 0x0000 bis 0x6FFF 
den Wert 0xFF stehen. Ab 0x7000 steht der Code des Bootlaoders.

Hoffe es kann mir jemand von euch weiterhelfen.

Vielen Dank!

Gruss

Sebastian

[Sebastian Z. (sz1985)]

Hat keiner von euch eine Idee, wo der Fehler liegen könnte?

[Peter D. (pdiener)]

Zumindest das Löschen hat doch funktioniert, wenn überall 0xff steht.

Grüße,

Peter

[Neubi (Gast)]

meine funktionierende version sieht folgendermassen aus ...

c-file:

MEMSEG_BOOTLOADER BYTE LoaderStartDownload(void)
{
  BYTE i,x;
  WORD page, data;

  for(x=0; x<MAX_FLASH_PAGES; x++)
  {
    //------------------ get program-page from USB-Stick --------------//
    if(!LoaderGetNextProgramPage(&page))    // get next program-page from usb-stick
    {
      LoaderUsbTxStr("C 0");                // pagewrite failed -> close file
      return FALSE;
    }

    //----------------------- erase flash-page ------------------------//
    eeprom_busy_wait();
    boot_page_erase(page);
    boot_spm_busy_wait();                   // wait until the memory is erased
  
    //----------------- fill data to internal page-buffer -------------//
    for(i=0; i<SPM_PAGESIZE; i+=2)
    {
      data  = USB.Tx.data[i];               // little endian
      data += ((USB.Tx.data[i+1]) << 8);
      boot_page_fill(page + i, data);
    }

    //------------------------ burn page to flash ---------------------//
    boot_page_write(page);
    boot_spm_busy_wait();                   // wait until the memory is written.
    boot_rww_enable();
  }

  LoaderUsbTxStr("C 0");                    // close file

  return TRUE;
}

header-file:

#define  __BOOT_PAGE_ERASE            0x03
#define  __BOOT_PAGE_WRITE            0x05
#define  __BOOT_PAGE_FILL             0x01
#define  __BOOT_RWW_ENABLE            0x11



#define  eeprom_busy_wait()       while(EECR & 0x02)

#define  boot_spm_busy_wait()     while(SPMCR & 0x01) 

#define  boot_page_erase(page)                   \
({                                               \
    __asm__ __volatile__                         \
    (                                            \
        "movw r30, %2\n\t"                       \
        "sts %0, %1\n\t"                         \
        "spm\n\t"                                \
        : "=m" (SPMCR)                           \
        : "r" ((BYTE)__BOOT_PAGE_ERASE),         \
          "r" ((WORD)page)                       \
        : "r30", "r31"                           \
    );                                           \
})

#define boot_page_fill(address, data)            \
({                                               \
    __asm__ __volatile__                         \
    (                                            \
        "movw  r0, %3\n\t"                       \
        "movw r30, %2\n\t"                       \
        "sts %0, %1\n\t"                         \
        "spm\n\t"                                \
        "clr  r1\n\t"                            \
        : "=m" (SPMCR)                           \
        : "r" ((BYTE)__BOOT_PAGE_FILL),          \
          "r" ((WORD)address),                   \
          "r" ((WORD)data)                       \
        : "r0", "r30", "r31"                     \
    );                                           \
})

#define boot_page_write(address)                 \
({                                               \
    __asm__ __volatile__                         \
    (                                            \
        "movw r30, %2\n\t"                       \
        "sts %0, %1\n\t"                         \
        "spm\n\t"                                \
        :                                        \
        : "i" (&SPMCR),                          \
          "r" ((BYTE)__BOOT_PAGE_WRITE),         \
          "r" ((WORD)address)                    \
        : "r30", "r31"                           \
    );                                           \
})

#define boot_rww_enable()                        \
({                                               \
    __asm__ __volatile__                         \
    (                                            \
        "sts %0, %1\n\t"                         \
        "spm\n\t"                                \
        :                                        \
        : "i" (&SPMCR),                          \
          "r" ((BYTE)__BOOT_RWW_ENABLE)          \
    );                                           \
})

gruss,
neubi

[Neubi (Gast)]

#define SPM_PAGESIZE 128

[Sebastian Z. (sz1985)]

Zum einen löscht er den Speicher nicht, da er in diesem Bereich bereits 
auf 0xFF steht.

@Neubi:
Ich habe deinen Code mit minimalen Anpassungen bei mir getestet und habe 
leider immernoch das Problem, dass er keine Daten schreibt. Hast du noch 
eine Idee, woran das liegen kannß

[Sascha W. (sascha-w)]

SELFPRGEN Fuse gesetzt ?

Sascha

[Sebastian Z. (sz1985)]

Sascha Weber schrieb:
< SELFPRGEN Fuse gesetzt ?

SPIEN ist laut den Werten der FUSES gestzt, aber AVR zeigt mir im Reiter 
FUSES unter dem Punkt SPIEN ein Häckchen mit kleinem roten Fragezeichen 
an.

[Sascha W. (sascha-w)]

SELFPRGEN nicht SPIEN, aber uups die gibt's beim m32 gar nicht. Schau 
dir mal deine BLB_Fuses an.

Sascha

[Sebastian Z. (sz1985)]

Die Lockbits sind alle auf 1 (0xFF).
BLB0  No lock on SPM and LPM in Application Section
BLB1  No lock on SPM and LPM in Bootloader Section

[Stefan E. (sternst)]

Sebastian Z. schrieb:
> Fuses:    0xDAFF
>
> Linker:   -Ttext=0x7000

Da dein Flash-Write-Code nicht im Bootloader-Bereich liegt (sondern 
etwas unterhalb), kann er das Flash auch nicht beschreiben.

[Sebastian Z. (sz1985)]

Vielen Dank. Habe den Wert jetzt auf 0x7800 geändert und es 
funktioniert.
Habe damals die Startadresse für 2048 words errechnet, warum auch immer.