;**************************************************************
;* avrboot.asm - Assembler implementation of Atmel ATmega series
;* self programming for use with AvrProg.exe.
;*
;* Copyright (C) 2002, Mikkel Holm Olsen (mho@ostenfeld.dtu.dk)
;**************************************************************

.INCLUDE "m163def.inc"

;**************************************************************
;* Modify these to fit your needs
;**************************************************************

; Remember to chech the datasheet to make sure the baudrate works
; with the selected colck frequency
.EQU	CLOCK_FREQ = 1843200	; Clock Frequency in Hz

; Wait for 5 sec for UART data
.EQU	INIT_TIMEOUT = 5000	; (ms) Watch out for overflow if >5 sec

; UART Baud Rate.
.EQU	BAUDRATE = 19200	

; Device - ATmega163
.EQU	DEVICE_ID = 0x66	; Only one supported device
.EQU	DEV_ID_0 = 0x1E		; Manufacturer is Atmel
.EQU	DEV_ID_1 = 0x94		; 16K Flash
.EQU	DEV_ID_2 = 0x02		; ATmega163

;**************************************************************
;* No user servicable parts below this point
;**************************************************************

.EQU	UBRR_VAL = (CLOCK_FREQ/(16*BAUDRATE))-1
.EQU	TMR_VAL = $10000-(1000*CLOCK_FREQ/1024*INIT_TIMEOUT)

.EQU	VERSION_HW_H = '1'	; Hardware version 1.0
.EQU	VERSION_HW_L = '0'
.EQU	VERSION_SW_H = '1'	; Software version 1.0
.EQU	VERSION_SW_L = '0'

.EQU	MYBOOTSTART = SECONDBOOTSTART

; Register definitions
.DEF	tmp	=r16		; Parameters/General purpose
.DEF	tmph	=r17
.DEF	utmp	=r18		; UART receive register
.DEF	addrl	=r24
.DEF	addrh	=r25

.ESEG
.ORG	(E2END-1)
.DB	0x00, 0x00		; Counter for number of programmings
.CSEG

.ORG 0x0000			; Interrupt Vectors
INT_VECTORS:
  jmp	DUMMY_RESET

DUMMY_RESET:
  nop
  rjmp	DUMMY_RESET


.ORG MYBOOTSTART
RESET:
  cli
  in	tmp, MCUSR
  cpi	tmp, 0x02		; Reset by H/W reset pin
  breq	PROGRAMMING
  cbr	tmp, 1
  out	MCUSR, tmp
  rjmp	(FLASHEND+1)		; Since PC wraps, we can do with a rjmp instead of jmp
PROGRAMMING:
  ldi	tmp, Low(RAMEND)	; Set stackpointer to last addr
  out	SPL, tmp		;  - stack grows downwards
  ldi	tmp, High(RAMEND)	;  - variables are at lower addrs
  out	SPH, tmp
  
; Setup port D (UART)
  ldi	tmp, 0b00000010		; TX is output, others are input
  out	PORTD, tmp
  out	DDRD, tmp

  ldi	tmp, High(UBRR_VAL)	; Setup baud rate generator according
  out	UBRRHI, tmp		;  to value defined in the top of this
  ldi	tmp, Low(UBRR_VAL)	;  file (found from Table 27 in the
  out	UBRR, tmp		;  the AtMega163 datasheet)

  ldi	tmp, 0b00000000		; No special features
  out	UCSRA, tmp		;  (normal UART speed, No MPCM)

  ldi	tmp, (1<<RXEN)+(1<<TXEN)
  out	UCSRB, tmp		; Enable transmitter and receiver

  ldi	tmp, High(TMR_VAL)	; Timeout to receive first character
  out	TCNT1H, tmp
  ldi	tmp, Low(TMR_VAL)
  out	TCNT1L, tmp
  ldi	tmp, 0b00000101		; Prescaler = 1024
  out	TCCR1B, tmp

RECEIVE_TIMEOUT:
  in	tmp, TIFR
  sbrc	tmp, TOV1		; Check for timeout
  rjmp	(FLASHEND+1)		; Since PC wraps, we can do with a rjmp instead of jmp
  sbis	UCSRA, RXC		; Check if transmission complete
  rjmp	RECEIVE_TIMEOUT		;  - If not, retry

PROG_LOOP:
  rcall	UART_RX_CHAR
  cpi	utmp, 0x1b		; ESC - Retry.
  breq	PROG_LOOP

  cpi	utmp, 'a'		; Command 'a': Auto Increment Address
  brne	CMD_NOT_SA
  ldi	tmp, 'Y'		; Command accepted
  rjmp	CMD_SEND

CMD_NOT_SA:
  cpi	utmp, 'A'		; Command 'A': Set address
  brne	CMD_NOT_CA
  rcall	UART_RX_CHAR		; Get high part
  mov	ZH, utmp
  rcall	UART_RX_CHAR		; Get low part
  mov	ZL, utmp
  movw	addrl, ZL
  lsl	ZL			; Address in bytes, not words
  rol	ZH
  rjmp	CMD_REPLY

CMD_NOT_CA:
  cpi	utmp, 'c'		; Command 'c': Data (low byte)
  brne	CMD_NOT_SC
  rcall	UART_RX_CHAR
  mov	r0, utmp		; Save low byte in r0
  rjmp	CMD_REPLY

CMD_NOT_SC:
  cpi	utmp, 'C'		; Command 'C': Data (high byte)
  brne	CMD_NOT_CC
  rcall	UART_RX_CHAR
  mov	r1, utmp		; Save high byte in r1. low (hopefully) already in r0.
  ldi	tmp, (1<<SPMEN)
  rcall	DO_SPM
  adiw	ZL, 2			; Autoincrement address
  rjmp	CMD_REPLY

CMD_NOT_CC:
  cpi	utmp, 'd'		; Command 'd': Read Data Memory
  brne	CMD_NOT_SD
  rcall	EEPROM_WAIT		; Wait until EEPROM is ready
  sbi	EECR, EERE		; Set "Read Enable"-bit
  in	tmp, EEDR		; Read byte from EEPROM
  rjmp	CMD_SEND

CMD_NOT_SD:
  cpi	utmp, 'D'		; Command 'D': Write Data Memory
  brne	CMD_NOT_CD
  rcall	UART_RX_CHAR
  rcall	EEPROM_WAIT		; Wait until EEPROM is ready
  out	EEDR, utmp		; Put data in EEPROM Data Register
  sbi	EECR, EEMWE		; Master Write Enable
  sbi	EECR, EEWE		; Write Enable
  rjmp	CMD_REPLY    

CMD_NOT_CD:
  cpi	utmp, 'e'		; Command 'e': Chip Erase
  brne	CMD_NOT_SE
  clr	ZL			; Address pointer
  clr	ZH
  ldi	XL, Low(MYBOOTSTART)	; Start address of bootblock is stored in
  ldi	XH, High(MYBOOTSTART)	;  ZH:ZL for compare.
CMD_ERASE_LOOP:
  ldi	tmp, (1<<PGERS)+(1<<SPMEN)	; Page erase
  rcall	DO_SPM
  
  subi	ZL, Low(-2*PAGESIZE)	; Add 2*pagesize to address
  sbci	ZH, High(-2*PAGESIZE)
  cp	ZL, XL			; Are we at the bootblock yet?
  cpc	ZH, XH
  brlo	CMD_ERASE_LOOP		;  - Nope, loop
; Perhaps update EEPROM to show erase-count.
  rjmp	CMD_REPLY

CMD_NOT_SE:
  cpi	utmp, 'E'		; Command 'E': Exit programming
  brne	CMD_NOT_CE
  ldi	tmp, 13
  rcall	UART_TX_CHAR		; Send acknowledge to programming software
  ldi	tmp, (1<<ASRE)+(1<<SPMEN)	; Application Section Read Enable
  rcall	DO_SPM  
  rjmp	(FLASHEND+1)		; Since PC wraps, we can do with a rjmp instead of jmp

CMD_NOT_CE:
  cpi	utmp, 'F'		; Command 'F': Read fuse bits
  brne	CMD_NOT_CF
  ldi	ZL, 0			; Fuse bits
  rjmp	READ_FUSE_LOCK

CMD_NOT_CF:
; This command has been disabled to make sure no one breaks anything :-)
;  cpi	utmp, 'l'		; Command 'l': Write Lock Bits
;  brne	CMD_NOT_SL
;  rcall	UART_RX_CHAR
;  mov	r0, utmp
;  ldi	tmp, (1<<BLBSET)+(1<<SPMEN)	; Boot Lock Bits
;  rcall	DO_SPM  
;  rjmp	CMD_REPLY

CMD_NOT_SL:
  cpi	utmp, 'm'		; Command 'm': Issue Page Write
  brne	CMD_NOT_SM
  ldi	tmp, (1<<PGWRT)+(1<<SPMEN)
  rcall	DO_SPM
  rjmp	CMD_REPLY

CMD_NOT_SM:
  cpi	utmp, 'N'		; Command 'N': Read High Fuse Bits
  brne	CMD_NOT_CN
  ldi	ZL, 3			; High Fuse bits
  rjmp	READ_FUSE_LOCK

CMD_NOT_CN:
  cpi	utmp, 'p'		; Command 'p': Return programmer type
  brne	CMD_NOT_SP
  ldi	tmp, 'S'
  rjmp	CMD_SEND

CMD_NOT_SP:
  cpi	utmp, 'P'		; Command 'P': Enter Programming mode
  brne	CMD_NOT_CP
  rjmp	CMD_REPLY

CMD_NOT_CP:
  cpi	utmp, 'r'		; Command 'r': Read Lock Bits
  brne	CMD_NOT_SR
  ldi	ZL, 1			; Lock bits
  rjmp	READ_FUSE_LOCK

CMD_NOT_SR:
  cpi	utmp, 'R'		; Command 'R': Read Program Memory
  brne	CMD_NOT_CR
  ldi	tmp, High(2*MYBOOTSTART)
  cpi	ZL, Low(2*MYBOOTSTART)
  cpc	ZH, tmp
  brlt	CMD_READ_OK		; Check if trying to read the bootblock
  ldi	tmp, 0xFF
  rcall	UART_TX_CHAR
  rcall	UART_TX_CHAR
  rjmp	PROG_LOOP
CMD_READ_OK:
  lpm	tmph, Z+
  lpm	tmp, Z+
  rcall	UART_TX_CHAR
  mov	tmp, tmph
  rcall	UART_TX_CHAR
  rjmp	PROG_LOOP

CMD_NOT_CR:
  cpi	utmp, 's'		; Command 's': Read Signature Bytes
  brne	CMD_NOT_SS
  ldi	ZL, Low(VENDOR_ID*2)	; Load Z with pointer to string
  ldi	ZH, High(VENDOR_ID*2)
  rjmp	CMD_TX_STR

CMD_NOT_SS:
  cpi	utmp, 'S'		; Command 'S': Software Identifier.
  brne	CMD_NOT_CS
  ldi	ZL, Low(SOFTWARE_ID*2)	; Load Z with pointer to string
  ldi	ZH, High(SOFTWARE_ID*2)
CMD_TX_STR:
  rcall	UART_TX_STR
  rjmp	PROG_LOOP

CMD_NOT_CS:
  cpi	utmp, 't'		; Command 't': List supported devices
  brne	CMD_NOT_ST
  ldi	tmp, DEVICE_ID		; Supported device
  rcall	UART_TX_CHAR
  ldi	tmp, 0			; End of list
  rcall	UART_TX_CHAR
  rjmp	PROG_LOOP

CMD_NOT_ST:  
  cpi	utmp, 'T'		; Command 'T': Select device to use
  brne	CMD_NOT_CT
  rcall	UART_RX_CHAR
  cpi	utmp, DEVICE_ID		; Hopefully he asks for the only device we support
  breq	CMD_REPLY
  ldi	tmp, '?'		; If not.. Don't know what to respond.
  rcall	UART_TX_CHAR
  rjmp	PROG_LOOP

CMD_NOT_CT:
  cpi	utmp, 'v'		; Command 'v': Hardware version
  brne	CMD_NOT_SV
  ldi	tmp, VERSION_HW_H
  rcall	UART_TX_CHAR
  ldi	tmp, VERSION_HW_L
  rcall	UART_TX_CHAR
  rjmp	PROG_LOOP

CMD_NOT_SV:
  cpi	utmp, 'V'		; Command 'V': Software version
  brne	CMD_NOT_CV
  ldi	tmp, VERSION_SW_H
  rcall	UART_TX_CHAR
  ldi	tmp, VERSION_SW_L
  rcall	UART_TX_CHAR
  rjmp	PROG_LOOP

CMD_NOT_CV:
  cpi	utmp, 'L'		; Command 'L': Leave Programming mode
  breq	CMD_REPLY
  cpi	utmp, 'x'		; Command 'x': Set LED - dummy for compability
  breq	CMD_REPLY
  cpi	utmp, 'y'		; Command 'y': Clear LED - dummy for compability
  breq	CMD_REPLY

  ldi	tmp, '?'		; Unknown command
  rjmp	CMD_SEND

CMD_REPLY:
  ldi	tmp, 13
CMD_SEND:
  rcall	UART_TX_CHAR
  rjmp	PROG_LOOP

READ_FUSE_LOCK:
  ldi	ZH, 0
  ldi	tmp, (1<<BLBSET)+(1<<SPMEN)	; Boot Lock Bits
  out	SPMCR, tmp
  lpm	tmp, Z
  rjmp	CMD_SEND  
      
;**************************************************************
;* EEPROM_WAIT - Wait until EEPROM is ready, then set the address
;**************************************************************
EEPROM_WAIT:
  sbic	EECR, EEWE		; Is EEPROM ready?
  rjmp	EEPROM_WAIT		;  - If not, loop and try again
  out	EEARH, addrh		; Setup address registers
  out	EEARL, addrl
  adiw	addrl, 1		; Increment Address
  ret

;**************************************************************
;* DO_SPM - Carry out SPM-command
;**************************************************************
DO_SPM:
  sbic	EECR, EEWE		; Make sure the EEPROM is not busy
  rjmp	DO_SPM
  out	SPMCR, tmp
  spm				; SPM timed sequence
  .DW	0xFFFF
  nop
SPM_WAIT:
  in	tmp, SPMCR
  sbrc	tmp, SPMEN
  rjmp	SPM_WAIT
  ret

;**************************************************************
;* UART_TX_STR - Transmit ASCIIZ string pointed to by Z on UART
;**************************************************************
UART_TX_STR:
  lpm	tmp, Z+			; Load next byte from string
  cpi	tmp, 0			; Is it the terminating 0-char?
  breq	TX_STR_DONE		;  -yes, end transmission
  rcall	UART_TX_CHAR		; Send the character
  rjmp	UART_TX_STR		; Repeat until whole string transmitted
TX_STR_DONE:
  ret

;**************************************************************
;* UART_TX_CHAR - Transmit char in tmp on UART interface
;**************************************************************
UART_TX_CHAR:
  sbis	UCSRA, UDRE		; Is UART ready?
  rjmp	UART_TX_CHAR		; If not, wait and try again
  out	UDR, tmp		; Now send the byte in tmp
  ret

;**************************************************************
;* UART_RX_CHAR - Wait until UART receives character, store
;* in utmp.
;**************************************************************
UART_RX_CHAR:
  sbis	UCSRA, RXC		; Check if transmission complete
  rjmp	UART_RX_CHAR		;  - If not, retry
  in	utmp, UDR		; Read the received byte
  ret

;**************************************************************
;* Data tables
;**************************************************************

SOFTWARE_ID:
.db	"AVR_MHO",0
VENDOR_ID:
.db	DEV_ID_2, DEV_ID_1, DEV_ID_0, 0