ATmega164PA Bootloader - SPMCSR Erase Bit hängt

[X- R. (x-rocka)]

Moin,

ich arbeite gerade mit Codevision an einem Bootloader für den 
ATmega164PA.
Ich kann nicht zu 100% auf die gelieferten Beispiele zurückgreifen 
(Interface, Formatierung im System, etcpp.).

Ein Windows Programm liest ein hex-File, überprüft es, wandelt es in 
binär um und sendet Zeile für Zeile an den AVR, der jede empfangene und 
geschrieben Zeile quittiert, so dass die nächste gesendet wird.

Die folgenden Teile funktionieren:
- Datenübertragung per UART
- Flash auslesen
- Parser der Hex-Daten
- Page Buffer füllen

Jetzt die Probleme:
Nach jeder Erase oder Write Anweisung auf das SPMCSR Register bleibt das 
Erase-Bit gesetzt! Sogar wenn Write-Command vorher gesetzt wurde (0x05 
in SPMCSR schreiben).
Das hat zur Folge, dass genau eine Seite geschrieben wird, beim nächsten 
SPM_busy_wait() hängt's dann.
Löschen geht auch (übrigens nur der ganze Flash, nicht einzelne Seite), 
danach hängt das Erase-Bit auch noch.

Wahrscheinlich sehe ich den Wald vor lauter Bäumen nicht - vlt. seht ihr 
es ja?!

Zur Erläuterung:
Nach jeder empfangenen hex-File-Zeile wird bootload_ctl() aufgerufen.
bootload_ctl() prüft per ihex_line_parser() die Daten, wenn okay wird in 
ihex2flash() der Page Buffer gefüllt und wenn voll geschrieben.

/* ########################################################################## */
/* include */

#include "ATmega164PA_BtLdr.h"
#include "Bootloader.h"


/* ########################################################################## */
/* code constants */


/* ########################################################################## */
/* variables */

u16_t ihex_line_dest_addr = 0;
u8_t ihex_line_dat_len = 0;
u8_t ihex_line_dat_type = 0;
u8_t ihex_line_dat_buf[32];

u16_t flash_page_num = 0;
u16_t flash_page_addr = 0;
u16_t flash_cnt = 0;

u8_t SPM_timer = 0;

/* ########################################################################## */
/* local functions: */


/* ########################################################################## */
/* global functions */

/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
/* bootloader control */
void bootload_ctl(void)
{
  u8_t parser_ret;
  u8_t write_ret;

  /* check line from hex file */
  parser_ret = ihex_line_parser();

  if( parser_ret == IHEX_LINE_OKAY )
  {
    /* write to flash */
    write_ret = ihex2flash(IHEX_RECTYP_DATA);

    TX1_byte(write_ret);
  }
  else if( parser_ret == IHEX_LINE_EOF )
  {
    /* write last data, fill rest with 0xFF */
    write_ret = ihex2flash(IHEX_LINE_EOF);
    /* send message we're done */
    TX1_byte(write_ret);
  }
  else TX1_byte(parser_ret);

  /* reset RX1 stuff */
  mem_set(RX1_buffer, 0x00, (u16_t)sizeof(RX1_buffer));
  RX1_timer = UART1_TIMEOUT_MAX;
  RX1_ihex_avl = 0;
}


/* check received line, length, CRC, data type - no ASCII !!! */
u8_t ihex_line_parser(void)
{
  u8_t i;
  u16_t crc_sum = 0;

  /* check start code and length */
  if( RX1_buffer[0] != ':' || RX1_counter < IHEX_LINE_OVERHEAD_BIN ) return IHEX_ERROR_STRT_LEN;

  /* get data length in line */
  ihex_line_dat_len = RX1_buffer[1];

  /* get flash address */
  ihex_line_dest_addr = (u16_t)RX1_buffer[2] << 8;
  ihex_line_dest_addr += (u16_t)RX1_buffer[3];

  /* get data type */
  ihex_line_dat_type = RX1_buffer[4];

  /* CRC check, add all execept ':', incl CRC byte, lower byte sum must be 0 */
  for( i = 1; i < RX1_counter; i++ ) crc_sum += (u16_t)RX1_buffer[i];
  crc_sum &= 0x00FF;
  if( crc_sum != 0 ) return IHEX_ERROR_CRC;

  /* get data and copy to buffer */
  if( ihex_line_dat_type == IHEX_RECTYP_DATA && ihex_line_dat_len != 0 )
  {
    for( i = 0; i < ihex_line_dat_len; i++ )
    {
      ihex_line_dat_buf[i] = RX1_buffer[i + 5];
    }
  }
  /* extended address for > 64kB? */
  else if( ihex_line_dat_type == IHEX_RECTYP_XSADR )
  {
    /* for now just return error code */
    return IHEX_ERROR_EXTADDR;
  }
  /* EOF? */
  else if( ihex_line_dat_type == IHEX_RECTYP_EOF &&
    RX1_counter == IHEX_LINE_OVERHEAD_BIN )
  {
    return IHEX_LINE_EOF;
  }
  else return IHEX_FLASH_FT_ERROR;

  return IHEX_LINE_OKAY;
}


/* write line from hex file to flash page buffer */
u8_t ihex2flash(u8_t dat_type)
{
  u8_t ret_val;
  u8_t i;
  u16_t page_addr_b;

/* - writing flash page by page
 * - a complete page must be written
 * - data must be collected until page is full
 *
 *  1) fill page buffer
 *  2) erase page
 *  3) write page
 *
 */

/* end of hex file, write current page buffer to flash */
  if( dat_type == IHEX_LINE_EOF )
  {
    if( flash_cnt != 0 )
    {
      eeprom_busy_wait();

      /* erase page */
    //  SPM_processing((void flash *)flash_page_num, SPM_CMND_ERASE_PAGE);
    //  SPM_processing(flash_page_num, SPM_CMND_ERASE_PAGE);
    //  boot_spm_busy_wait();

      /* write page */
      SPM_processing((void flash *)flash_page_num, SPM_CMND_WRITE_PAGE);
      if( boot_spm_busy_wait() ) ret_val = IHEX_FLASH_EOF_TO;
      SPM_R0_to_SPM(0, SPM_CMND_ENABLE_RWW);

      /* reset stuff */
      flash_page_num = 0;
      flash_cnt = 0;
      flash_page_addr = 0;
    }
    ret_val = IHEX_FLASH_WR_END;
  }
/* copy data from new line to page buffer, erase & write page */
  else
  {
    for( i = 0; i < ihex_line_dat_len; i += 2 )
    {
      flash_page_addr = flash_page_num + flash_cnt;
      page_addr_b = flash_page_addr;// << 1;

      SPM_fill_page_buffer((void flash *)page_addr_b, ihex_line_dat_buf[i+1], ihex_line_dat_buf[i], SPM_CMND_FILL_PAGE_BUF);
/* hängt hier nach erstem page write */
LED2_GREEN;
      if( boot_spm_busy_wait() ) ret_val = IHEX_FLASH_FILL_TO;
LED2_OFF;

      flash_cnt += 2;

      /* page buffer full => erase page => write page! */
      if( flash_cnt == SPM_PAGE_SIZE )
      {
        eeprom_busy_wait();

        /* erase page */
      //  SPM_processing((void flash *)flash_page_num, SPM_CMND_ERASE_PAGE);
      //  SPM_processing(flash_page_num, SPM_CMND_ERASE_PAGE);
      //  boot_spm_busy_wait();

        /* write page */
        SPM_processing((void flash *)flash_page_num, SPM_CMND_WRITE_PAGE);
LED2_RED;
/* hier hängt's nach 1. page write! */
        if( boot_spm_busy_wait() ) ret_val = IHEX_FLASH_WR_TO;
LED2_OFF;
        SPM_R0_to_SPM(0, SPM_CMND_ENABLE_RWW);

        /* new page */
        page_addr_b = flash_page_num;
        flash_page_num = ihex_line_dest_addr - (ihex_line_dest_addr % SPM_PAGE_SIZE);
        if( flash_page_num == page_addr_b ) flash_page_num += SPM_PAGE_SIZE;
        flash_cnt = 0;
      }
    }
    ret_val = IHEX_FLASH_LINE_WR;
  }

LED2_OFF;

  return ret_val;
}


#pragma warn-
/* call: SPM_fill_page_buffer((void flash *)addr, ... */
/* fill buffer */
void SPM_fill_page_buffer(void flash *addr, u8_t dat_hi, u8_t dat_lo, u8_t cmnd)
{
#asm
  cli
  ldd    r30,y+3
  ldd    r31,y+4
  ldd    r0,y+1
  ldd    r1,y+2
  ld     r22,y
  WR_SPMCR_REG_R22
  spm
  sei
#endasm
}


/* call: SPM_processing((void flash *)addr, ... */
/* erase page (cmnd = 0x03) / write buffer to page (cmnd = 0x05) */
void SPM_processing(void flash *addr, u8_t cmnd)
{
#asm
  cli
  ldd    r30,y+1
  ldd    r31,y+2
  ld     r22,y
  WR_SPMCR_REG_R22
  spm
  sei
#endasm
}


/* ??? */
void SPM_R0_to_SPM(u8_t data, u8_t cmnd)
{
#asm
  cli
  ldd    r0,y+1
  ld     r22,y
  WR_SPMCR_REG_R22
  spm
  sei
#endasm
}
#pragma warn+


/* read flash */
void SPM_read_flash(u16_t addr, u16_t len)
{
  u8_t byte;

  do
  {
  #if(0)
  /* ASCII, takes too much prog space */
    if( (len % 16) == 0 ) TX1_byte('\n');
    TX1_byte('0');
    TX1_byte('x');
    byte = (u8_t)*((u8_t flash *)addr);
    TX1_byte(hex_char[(byte & 0xF0) >> 4]);
    TX1_byte(hex_char[ byte & 0x0F]);
    TX1_byte(' ');
  #endif

    byte = (u8_t)*((u8_t flash *)addr);
    TX1_byte(byte);
    addr++;
    len--;
  } while( len );
}


u8_t boot_spm_busy_wait(void)
{
LED1_RED;
  SPM_timer = 10;      /* *100 ms */
  while( SPMCSR )//& (1<<SPMEN) )
  {
    if( SPM_timer == 0 ) return 1;
  };
LED1_GREEN;
  return 0;
}


void eeprom_busy_wait(void)
{
  while( EECR & (u8_t)(1<<EEPE) );
}


void mem_set(u8_t *buf, u8_t val, u16_t len)
{
  u16_t i = 0;

  for( i = 0; i < len; i++ ) buf[i] = val;
}

[X- R. (x-rocka)]

Irgendjemand eine Idee?

[Oliver (Gast)]

Hm. Schwer zu sagen. Dein COde macht es einem nicht gerade einfach, 
schnell die wesentlichen Dinge zu finden.

Wie auch immer, SPEM sollte immer irgendwann zurückgesetzt werden. 
Sicher, daß dein Timeout-Timer richtig taktet?

Oliver

[X- R. (x-rocka)]

Nachfragen hilft einem immer, die Fehler dann selbst zu finden...
Ich hatte das SPMCSR per UART falsch ausgelesen (bit inversion...), es 
hing das RWWSB bit.
Also boot_spm_busy_wait() wieder nur auf SPMEN geändert, und noch ein 
boot_spm_busy_wait() hinter das re-enable des RWW-Bereichs, jetzt 
geht's.
Aua...