Atmega2560 Bootloader

[Florian (Gast)]

Hallo,

Ich habe bislang immer den Bootloader von Steven Seegel für meinen 
Atmega64 verwendet. Nun versuche ich seit ca. 2 Wochen diesen für meinen 
Atmega2560 lauffähig zu machen - leider bisher ohne Erfolg.

Ich denke das Problem liegt darin, dass der Bootloader nur 128KB meines 
Programms flasht anstatt der gesamten ~256KB.
Ich habe schon viel im Internet über diese Probleme gefunden, aber 
leider hat nichts davon so richtig geholfen.

Ich hoffe einer von Euch hat evtl. eine Idee woran es noch liegen könnte 
- Ich weiß mittlerweile echt nicht mehr weiter.

Vielen Dank schonmal im Voraus

MCU = atmega2560
BOOTLOADERSTARTADR = 0x3E000
BOOTLDRSIZE = 0x1000


LDFLAGS += -mrelax

#include <avr/io.h>
#include <string.h>
#include <avr/boot.h>
#include <avr/pgmspace.h>
#include <util/crc16.h>
#include <util/delay.h>
#include "fat1216.h"

#define USE_FLASH_LED
#define FLASH_LED_PORT PORTG
#define FLASH_LED_DDR DDRG
#define FLASH_LED_PIN PG0
#define FLASH_LED_POLARITY 0

#define LEDGRUEN  PG0    // Anzeige Bottloader erfolgreich beendet 
#define LEDROT    PG1    // Anzeige Bottloader Fehler in der CRC 
#define SOUND    PA5    // Nur zum Testen 
 
 

typedef struct
{
  uint32_t dev_id;
  uint16_t app_version;
  uint16_t crc;
} bootldrinfo_t;


uint16_t startcluster;
uint16_t updatecluster; //is set when update is available
bootldrinfo_t current_bootldrinfo;

void (*app_start)(void) = 0x0000;

static inline void check_file(void)
{
  //Check filesize
  
  if (filesize != FLASHEND - BOOTLDRSIZE + 1) return;

  bootldrinfo_t *file_bootldrinfo;
  fat1216_readfilesector(startcluster, (FLASHEND - BOOTLDRSIZE + 1) / 512 - 1);
  
  file_bootldrinfo =  (bootldrinfo_t*) (uint8_t*) (fat_buf + (FLASHEND - BOOTLDRSIZE - sizeof(bootldrinfo_t) + 1) % 512);
  
  //Check DEVID
  if (file_bootldrinfo->dev_id != DEVID) return;

  //Check application version
  if (file_bootldrinfo->app_version < current_bootldrinfo.app_version) return;

  current_bootldrinfo.app_version = file_bootldrinfo->app_version;
  updatecluster = startcluster;
}

int main(void)
{
  EIND = 1;
  uint16_t i;
  
  uint16_t filesector, j;
  uint16_t *lpword;
  uint32_t adr;
  
  DDRG |= (1<<LEDGRUEN);    // Port Pin als Ausgang - Bootloader erfolgreich beendet
  DDRG |= (1<<LEDROT);    // Port Pin als Ausgang - Fehlerhafte CRC 
  DDRA |= (1<<SOUND);      // Port Pin als Ausgang - Nur zum testen 
  
  //LED On
  #ifdef USE_FLASH_LED
  FLASH_LED_DDR = 1<<FLASH_LED_PIN;
  #if !FLASH_LED_POLARITY
  FLASH_LED_PORT |= 1<<FLASH_LED_PIN;
  #endif
  #endif
  
  // Blinken lassen um den Eintritt in den Bootloader zu erkennen 
  PORTG |= (1<<LEDROT);
  PORTG ^= 1<<FLASH_LED_PIN;
  _delay_ms(100);
  PORTG ^= 1<<FLASH_LED_PIN;
  _delay_ms(100);
  PORTG ^= 1<<FLASH_LED_PIN;
  _delay_ms(100);
  PORTG ^= 1<<FLASH_LED_PIN;
  PORTG &= ~ (1<<LEDROT);
  
  
  for (i=0; i<8; i++)
      ((uint8_t *)&current_bootldrinfo)[i] = pgm_read_byte_far(FLASHEND - BOOTLDRSIZE - sizeof(bootldrinfo_t) + 1 + i);
  
  //memcpy_P(&current_bootldrinfo, (uint8_t*) FLASHEND - BOOTLDRSIZE - sizeof(bootldrinfo_t) + 1, sizeof(bootldrinfo_t));
  
  if (current_bootldrinfo.app_version == 0xFFFF)
    current_bootldrinfo.app_version = 0; //application not flashed yet
    
  if (fat1216_init() == 0)
  {
    for (i=0; i<512; i++)
    {
      startcluster = fat1216_readRootDirEntry(i);

      if (startcluster == 0xFFFF)
        continue;
      
      check_file();
    }
    
    if (updatecluster)
    {
      for (filesector = 0; filesector < (FLASHEND - BOOTLDRSIZE + 1) / 512; filesector++)
      {
        #ifdef USE_FLASH_LED
        FLASH_LED_PORT ^= 1<<FLASH_LED_PIN;
        #endif
    
        lpword = (uint16_t*) fat_buf;
        fat1216_readfilesector(updatecluster, filesector);
  
        for (i=0; i<(512 / SPM_PAGESIZE); i++)
        {
          adr = (filesector * 512) + i * SPM_PAGESIZE;
          boot_page_erase(adr);
          while (boot_rww_busy())
            boot_rww_enable();
      
          for (j=0; j<SPM_PAGESIZE; j+=2)
            boot_page_fill(adr + j, *lpword++);

          boot_page_write(adr);
          while (boot_rww_busy())
            boot_rww_enable();
        }
      }
  
      //LED on
      #ifdef USE_FLASH_LED
      #if FLASH_LED_POLARITY
      FLASH_LED_PORT &= ~(1<<FLASH_LED_PIN);
      #else
      FLASH_LED_PORT |= 1<<FLASH_LED_PIN;
      #endif
      #endif
    }
  }
  
  unsigned short flash_crc = 0xFFFF;
  
  for (adr=0; adr<FLASHEND - BOOTLDRSIZE + 1; adr++)
    flash_crc = _crc_ccitt_update(flash_crc, pgm_read_byte_far(adr));
    
  if (flash_crc == 0)
  {
    //Led off
    #ifdef USE_FLASH_LED
    FLASH_LED_DDR = 0x00;
    #endif
    PORTG |= (1<<LEDGRUEN);
    _delay_ms(1000);
    PORTG &= ~(1<<LEDGRUEN);
    //EIND = 1;
    app_start();
    //asm volatile("jmp 0000");
  }
  else
  {
    PORTG |= (1<<LEDROT);
    _delay_ms(2000);
    
  }
  // Nur zum Testen für den Bestücker 
  PORTA |= (1<<SOUND);
  _delay_ms(2000);
  PORTA &= ~(1<<SOUND);
  while (1);
}