M8_boot2.asm

.include "c:\avrtools\appnotes\m8def.inc"

.def  temp    = r16

.def  page    = r17

.def  checksum  = r19

.def  counter    = r18

.def  checksum2  = r20

.def   spmreg    = r21

;**********************************************************

;* I²C-Bootloader für ATMega8                             *

;* Möglichkeit 1:                                         *

;* Der Bootloader wird durch einen speziellen Befehl      *

;* vom Anwenderprogramm aufgerufen. Falls das Programm    *

;* Fehlerhaft ist, läßt sich aber nichts mehr booten.     *

;* Möglichkeit 2:                                         *

;* Durch programmieren des BOOTRST-Bits wird der          *

;* Bootloader grundsätzlich gestartet. Ein General Call   *

;* (Adresse $00) startet das Anwendungsprogramm.          *

;* (Sprung zu Adresse $0000)                              *

;* Angesprochen wird der Bootloader über die I²C-Adresse  *

;* $F0. Es werden immer 66 Bytes erwartet, wenn ein       *

;* Schreibbefehl über Adresse $F0 gesendet wird:          *

;* 1. Byte = Page-Nr. (0...127)                           *

;* 64 Datenbytes                                          *

;* Prüfsumme (XOR)                                        *

;* Mit Adresse F1 wird ein Lesezugriff ausgelöst, hiermit *

;* kann die Prüfsumme überprüft werden (Rückgabe 1 Byte)  *

;* BOOTSZ0/BOOTSZ1 = 0, Boot-Sektor 128 Bytes             *

;**********************************************************

.org $0F80

boot4:

  ldi temp,low(ramend)  ;Den Stackpointer auf das Ende des RAM setzen

  out SPL,temp

  ldi temp,high(ramend)

  out SPH,temp  

  ldi checksum2,$AA  ;Initialisieren des I²C-Rückgabewertes auf einen Defaultwert

twi_init:

  ldi temp,$D0      ;minimalste Geschwindigkeit auswählen (hier entsprechende

          ;Änderungen vornehmen, wenns schneller gehen soll).

          ;Allerdings sollte diese Einstelleung keinen Einfluß haben,

          ;da der Bootloader nur im Slave-Modus arbeitet

  out TWBR,temp

  ldi temp,(1<<TWPS0)|(1<<TWPS1)  ;prescaler 64

  out TWSR,temp

  ldi temp,(1<<TWINT)|(1<<TWEN)|(1<<TWEA)

  out TWCR,temp      ;I²C-Bus initialisieren (TWINT-Flag löschen, einschalten, ACK

          ;senden bei eigener Adressierung)

  ldi temp,$F1

  out TWAR,temp      ;Adress-Register mit der Slave-Adresse definieren,

          ;General Call (Adresse $00) ebenfalls akzeptieren

wait_i2c:

  in temp,TWCR      ;auf eine I²C-Datenübertragung warten

  sbrs temp,TWINT  

  rjmp wait_i2c

  in temp,TWSR      ;Status-Byte lesen

  andi temp,$F8      ;Status-Code isolieren

  cpi temp,$60

  breq slaw      ;die eigene Adresse+W wurde empfangen

  cpi temp,$70

  breq gencw      ;ein "General Call" (Adresse 0) wurde empfangen

  cpi temp,$A8

  breq slar      ;eigene Adresse +R wurde empfangen

  rjmp boot4      ;Boot-Reset (nächste Übertragung abwarten)

;* SLAW = schreibender Zugriff

;* das nächste Byte ist bereits die Page-Nummer

slaw:

  rcall get_i2c      ;ein Byte vom I²C-Bus lesen

  brcs boot4      ;falls unerwartet ein Stop-Bit empfangen wurde, Neustart

  mov page,temp      ;Page-Nummer in "page" speichern

  ldi counter,$40      ;64 Bytes Daten lesen

  ldi yh,$01      ;Page 1 des SRAM verwenden

  clr yl

  clr checksum      ;Register für die Prüfsumme initialisieren

slaw_loop:

  rcall get_i2c      ;Datenbyte lesen

  brcs boot4      ;falls unerwartet ein Stop-Bit kommt Neustart des Boot-Programms

  st y+,temp      ;aktuelles Datenbyte in den SRAM schreiben

  eor checksum,temp    ;Prüfsumme aktualisieren

  dec counter      ;Zähler aktualisieren

  brne slaw_loop      ;wiederholen, bis 64 Bytes übertragen wurden

  rcall get_i2c      ;Prüfsumme vom Master lesen

  mov checksum2,temp    ;speichern in checksum2 (für I²C-Ausgabe)

  cp checksum2,checksum    ;die übertragene mit der selbst berechneten Prüfsumme vergleichen

  rcall flash_write

  rjmp wait_i2c      ;auf die nächste Übertragung warten

;* SLAR = lesender Zugriff

;* Die selbst berechnete Prüfsumme wird zurückgesendet, kann zur Kontrolle

;* verwendet werden. 

slar:

  out TWDR,checksum2    ;die Prüfsumme ins I²C-Datenregister schreiben

  in temp,TWCR

  out TWCR,temp      ;das TWINT-Flag löschen

slar_wait:

  in temp,TWCR      ;warten, bis der Schreibvorgang beendet ist

  sbrs temp,TWINT

  rjmp slar_wait

  in temp,TWCR      ;das Stop-Bit verarbeiten

  out TWCR,temp

  rjmp wait_i2c      ;zurück zur Hauptschleife

;An diesem Punkt kann es zu unvorhersehbaren Fehlern kommen, falls der Master

;mehr als ein Byte liest, da das Stop-Bit nicht überprüft wird.  

;* General Call = Adresse 0. Das I²C-Device geht nach dem Reset sofort in den Boot-Modus,

;* ein senden des General Call startet das Anwenderprogramm. Dadurch können mit einem

;* General Call alle Devices auf dem Bus mit einem Befehl gezielt gestartet werden.

gencw:

  rcall get_i2c      ;übertragenes Datenbyte lesen

  brcc gencw      ;wiederholen, bis ein Stop-Bit empfangen wird

  clr temp

  out TWCR,temp      ;Die I²C-Schnittstelle abschalten

  jmp $0000      ;reset, Sprung ins Benutzer-Programm

;Subroutine get_i2c liest ein Byte vom I²C-Bus und gibt es in "temp" zurück.

;Ferner wird das Carry-Flag gesetzt, falls ein Stop-Bit empfangen wurde.

get_i2c:

  in temp,TWCR      

  out TWCR,temp      ;das TWINT-Flag löschen

get_i2c1:

  in temp,TWCR      ;warten, bis das TWINT-Flag wieder gesetzt wird

  sbrs temp,TWINT      ;falls =1, dann Sprung

  rjmp get_i2c1      ;ansonsten warten

  in temp,TWSR      ;Status-Register abfragen

  andi temp,$F8      ;Status-Code isolieren

  cpi temp,$A0      ;wurde ein Stop-Bit empfangen?

  breq get_i2c2      ;Sprung, falls ja

  in temp,TWDR      ;Datenbyte lesen  

  clc        ;das Carry-Flag löschen (Byte empfangen)

  ret

get_i2c2:        ;Stop-Bit empfangen

  in temp,TWCR

  out TWCR,temp      ;Das TWINT-Bit nochmals löschen

  sec        ;das Carry-Flag setzen (Stop-Bit empfangen)

  ret  

;***************************************************************************

;* Per I²C wurde eine Page (64 Bytes) Daten in den SRAM ($0100...$013F)    *

;* übertragen. In "page" ist die Nummer der Page (0..127) abgelegt.        *

;* Der Boot-Bereich beginnt ab $0F80, d.h. die Pages 124..127 dürfen       *

;* nicht programmiert werden, da sonst der Boot-Loader überschrieben       *

;* wird. Eine Sicherheitsabfrage existiert nicht, kann aber leicht ein-    *

;* gefügt werden.                                                          *

;***************************************************************************

flash_write:

  ldi yh,$01        ;SRAM-Adresse $0100 auswählen

  clr yl

  clr zl          ;Low-Byte des Z-Registers löschen

  mov zh,page

  lsr zh          ;die Page-Nummer wurde ins High-Byte

  ror zl          ;übertragen. Durch 2x rechts shiften

  lsr zh          ;wird die Page-Nummer mit 64 multipliziert

  ror zl          ;in zh:zl ist nun die Byte-Adresse der Page

  push zl          ;die berechnete Adresse für später speichern

  push zh

  ldi spmreg,(1<<PGERS)|(1<<SPMEN)  ;die angewählte Page löschen, bevor sie 

  rcall schreib_spm      ;beschrieben wird.

  ldi counter,$20        ;Größe der Page, 32 Words

flash_write_loop:

  ld r0,y+        ;Datenbytes aus dem SRAM lesen

  ld r1,y+

  ldi spmreg,(1<<SPMEN)      ;spmreg mit dem Befehl laden

  rcall schreib_spm      ;Befehl ausführen

  adiw ZH:ZL,2        ;Das Adressierungswort (zh:zl) korrigieren

  dec counter        ;den Zähler aktualisieren

  brne flash_write_loop      ;wiederholen, bis die komplette Page übertragen wurde

  pop zh          ;Die Adresse der Page wiederherstellen

  pop zl

  ldi spmreg,(1<<PGWRT)|(1<<SPMEN)  ;Befehl für Flash beschreiben

  rcall schreib_spm      ;ausführen

  ret          ;Subroutine beenden

schreib_spm:

  in temp,SPMCR        ;Den Status der SPM-Schnittstelle abfragen

  sbrc temp,SPMEN        ;ist der letzte Befehl ausgeführt?

  rjmp schreib_spm      ;falls nein, dann warten

  out SPMCR,spmreg      ;Befehlsregister schreiben

  spm          ;Befehl ausführen

  ret