;----------------------------------------------------------------------------------------
;
;	Program:	Bootloader_Mega8.asm 
;
;	Writer:		Herbert Dingfelder, DL5NEG
;				for contact information visit WWW.DL5NEG.DE
;
;	Based on:	AVR-Freaks Design Note #32
;
;	Function:	Bootloader for ATmega8, Works via the UART with the normal 
;				AVRProg PC-Software
;
;	Hardware:	ATmega8 with a 7.3728MHz crystal
;
;	History:	
;
;	13.07.2004	- Source code adapted for Mega8, assembles without errors
;
;	15.07.2004	- Used crystal is not 7.3 but 3.686 MHz -> UART setting adapted
;				- LED on LEDport/LED is switched on within the boot section, 
;				  tested in Hardware and works -> processor starts correctly 
;				  within the boot section
;	18.07.2004	- Problem how to download the bootloader is solved: Simply use
;				  the AVRProg in the "mega8" mode, not in "mega8boot" mode.
;				  Since the Intel-Hex Format contains the address for the code
;				  in each line, the programmers recognizes that the code has to
;				  go to the bootrom part of the flash (provide that the
;				  ".org MY_BOOTSTART" is put at the beginning of the source code)
;				- UART communication between bootloader and host PC works
;				  (echo mode and character recognition tested and works)
;				- Crystal changed to 7.3728MHz in an attempt to fight "flushing"
;				  problems in AVRProg (without success), UART setting adapted
;				- AVRProg is able to read the flash correctly (tested, works)
;				- Reading and writing to EEPROM on host commands 'D' and 'd' works.
;				- Flash erase did not work in the NRWR section (the last 1024
;				  words of the flash) The original version from DesignNote #32
;				  was for ATmega163 which does not have  RWR/NRWR sections.
;				  Problem solved by implementing the wait_for_spm function that
;				  makes sure that a new SPM does only start when the previous one
;				  is completed. (tested, works now)
;				- function to reenable the RWW section implemented ->
;				  loading data into the application section tested and works fine
;				  (Still some problems with sync on the interface between AVRProg
;				  and the boot loader, messagebox "flushing" appears, fuse bits are
;				  read differently many times and software download needs to be
;				  started twice sometimes. As it is known that AVRProg is very sensible
;				  command/answer sync, this does not point towards real bootloader problems.
;				  It has to be tracked on the interface.)
;				  -> Good enough to work with temporarily, Version 1.0 released.
;				- Startup-function implemented for 10 second wait after power-on. If
;				  no ASCII(27) is received via UART within that time, the application starts.
;				  If the application section is empty (all cells are $FF) e.g. directly
;				  after uploading the bootloader itself, then software will wait forever
;				  for a ESC via the UART to start the bootloader software
;				  (while waiting for the ESC the LED blinks)
;				- Function pause implemented for delays in steps of 10ms (tested works)
;				- Command 'E' implemented for leaving the bootloader mode and start the 
;				  application
;				- With that entry end exit function the bootloader is fully usable, starting
;				  the downloaded application is tested and works perfectly
;				  -> Version 1.1 released
;				- Still known problem: the above mentioned sync problem in combination
;				  with AVRProg have to be identified and solved. 
;				- Only 2 Words are left in the bootloader memory. If Bugfixing needs more,
;				  the erease counter within the EEPROM can be skipped
;	24.07.2004	- Debug Session with Andy, DG9NDZ to find why AVRProg 1.37 still has some
;				  problems with the bootloader, especially in the "Advanced" Window. 		
;				  * Command 'v' for Hardware Version was not implemented -> fixed
;				  * Command ':' for tranparent command setting was not implemented
;					-> is now implemented in simple version, always returning \0
;				    By monitoring the PC/AVR interface it was found that AVRProg1.37 does 
;				    not use the defined commands r/F/N for reading the lock and fuse bits,
;				    but uses the universal command ':' to send the programming instructions
;				    directly. Additionally the calibration byte is read by the ':' command.
;				  * Command 'b' is send by AVRProg1.37 but is not implemented. It was found that
;				    it is fatal for the programming mode to implement 'b' to return 'Y', 'Y'.
;				    To simply leave it out (returns ? for unknow command) works perfectly.
;	25.07.2004	- To implement all improvements found on 24.07.2004 without skipping lots of
;				  of other code made it necessary to increase the boot loader size to 512words
;				  (=1kByte). Code adapted.
;				- Command ':' enlarged to map r/F/N functionality
;				- Tested, current status: Works well in AVRProg both for flash reading and writing
;				  and also in the Advance window the lock and fuse bits are display correctly.
;				  Only week point remaining to press "write" in advance window, that causes a
;				  loose of sync between host and bootloader. No harm is done to the target device.
;				  -> Version 1.2 released.
;	26.07.2004	- Monitoring of interface from host reveals the root cause of the sync problem when
;				  writing the the lock and fuse bits. AVRProg1.37 uses the "new universal command"
;				  which is "." + 4 data bytes. This command was not implemented. As changing the 
;				  fuse bits is dangerous when the device is remote (one could lock himself out
;				  forever), the command is now implemented simply to ignore the inputs but correctly
;				  serve the interface to the host to avoid sync problems. Tested and works perfectly.
;				  -> Version 1.3 release
;
;
;
;	Before or after programming a new ATmega8 with this Boot Loader you must program Fuse
;	bits as follows: 
;
;	• The ATmega8 Fuse High bits must be programmed to 0x04 in order to configure
;		the Boot size to 256 words and to move the Reset Vector to word address 0x1f00.
;		
;		I.e. set the check box for BOOTRST in AVR-Prog-Advanced and set the
;		selector to 256words, then press "write". It is important that this selected
;		size of the bootrom fits to the .org command within this source code, otherwise
;		the processor will not correctly start at the first line of this code after reset.
;		(Settings can be checked now or	later with "read").
;
;	Optional:
;
;	• The Lock bits can be programmed to 0xEF to protect the Boot Flash Section from
;		unintentional changes and to allow accessing the Application Flash Section.
;
;		I.e. the setting for BLB0 and BLB1 in AVR-Prog-Advance:
;
;		BLB0 (sets the protection for the application section) must be set to 
;		Mode 1 (no protection) to allow full access of LPM and SPM commands within 
;		the application section.
;
;		BLB1 (sets the protection for the boot loader section) can be set to Mode 2
;		(SPM cannot write to boot section) or can be left to Mode 1 (no protection).
;
;	• The Fuse bits must be programmed before programming the Lock bits.
;
;
; 	AVRProg Commands as defined by Atmel
;
;										Host Writes 	Host Reads
;										ID 		Data 	Data
;	Enter Programming Mode 				'P' 					13d		(implemented to ignore)
;	Auto Increment Address 				'a' 			dd				(fully implemented)
;	Set Address 						'A' 	ah al 			13d		(fully implemented)			
;	Write Program Memory, Low Byte 		'c' 	dd 				13d		(fully implemented)
;	Write Program Memory, High Byte 	'C' 	dd 				13d		(fully implemented)
;	Issue Page Write 					'm' 					13d		(fully implemented)
;	Read Lock Bits 						'r' 			dd				(fully implemented)
;	Read Program Memory 				'R' 			2*dd			(fully implemented)
;	Read EEPROM Memory 					'd' 			dd				(fully implemented)
;	Write EEPROM Memory					'D' 	dd 				13d		(fully implemented)
;	Chip Erase 							'e' 					13d		(implemented, erases appl. area only)
;	Write Lock Bits 					'l' 	dd 				13d		(implemented to ignore)
;	Read Fuse Bits 						'F' 			dd				(fully implemented)
;	Read High Fuse Bits 				'N' 			dd				(fully implemented)
;	Read Extended Fuse Bits 			'Q' 			dd				(not implemented)
;	Leave Programming Mode 				'L' 					13d		(implemented to ignore)
;	Select Device Type 					'T' 	dd 				13d		(implemented to ignore)
;	Read Signature Bytes 				's' 			3*dd			(fully implemented)
;	Return Supported Device Codes 		't' 			n*dd 	00d		(implemented, returns only Mega8)
;	Return Software Identifier 			'S' 			s[7]			(fully implemented)
;	Return Software Version 			'V' 			dd dd			(fully implemented)
;	Return Hardware Version				'v'								(fully implemented)
;	Return Programmer Type	 			'p' 			dd				(fully implemented)
;	Set LED 							'x' 	dd 				13d		(implemented to ignore)
;	Clear LED 							'y' 	dd 				13d		(implemented to ignore)
;	Exit Bootloader 					'E' 					{13d} 	(implemented 'E' is not confirmed)
;	Check Block Support 				'b' 			'Y' 2*dd		(implemented to return no)
;	Start Block Flash Load 				'B' 	2*dd 'F'		13d		(not implemented)
;												n*dd
;	Start Block EEPROM Load 			'B' 	2*dd 'E'		13d		(not implemented)	
;												n*dd
;	Start Block Flash Read 				'g' 	2*dd 'F'  n*dd			(not implemented)
;	Start Block EEPROM Read 			'g' 	2*dd 'E'  n*dd			(not implemented)
;	Universal Command (3 data bytes)	':'		3*dd	dd		13d		(implemented to ignore)
;	New Universal Command (4 data bytes)'.'		4*dd	dd		13d		(implemented to ignore)
;

;-------------------------definition and includes ---------------------------------------

.INCLUDE "m8def.inc" 				; Include Register/Bit Definitions for the mega8
.def tmp_r   = r18					; Use Reg. R18 for temporary stuff
.def pa_10ms = r19					; used for selecting the pause time in steps of 10ms

.def uni_cmd1 = r20					; Universal command ':' send three bytes. These
.def uni_cmd2 = r21					; are stored for futher usage in r20, r21, r28
.def uni_cmd3 = r10

.equ VER_H = '1' 					; bootloader software version higher number
.equ VER_L = '3' 					; bootloader software version lower number

.equ VERH_H = '1' 					; bootloader hardware version higher number
.equ VERH_L = '0' 					; bootloader hardware version lower number

.equ DT  = 0x76 					; Device Type = 0x76 (ATmega8)

.equ SB1 = 0x07 					; Signature byte 1
.equ SB2 = 0x93 					; Signature byte 2
.equ SB3 = 0x1e 					; Signature byte 3


.equ ESC = 27			; Ascii 27 = Escape

;LR*****************************************************
.equ fCK = 7372800      ;X-tal frequency               *
.equ BaudR=115200       ;Baud rate                     *
.equ Tr_Sp=0            ;Transmission speed (U2X)      *
.equ UBR=-1+(5+10*fCK/(16*BaudR-8*BaudR*Tr_Sp))/10 ;   *
.equ presc=1024         ;                              *
.equ fTmr=100           ;freq. of Timer 0 (1/10ms=100) *	
.equ TmrLoad=256-(fCK/(presc*fTmr))                ;   *                
.equ CR = 13            ;                              *
                        ;                              *
;Pin for LED and Boot escape definition:               *
.equ LEDport  =PORTc    ;                              *
.equ LEDdir   =DDRc     ;                              *
.equ LED   =5           ;                              *

.equ LED2  =4           ;                              *
.equ LED3  =2           ;                              *
.equ LED4  =1           ;                              *
                        ;                              *
.equ TestPort =PINC	    ;                              *
.equ TestBit  =0	    ;                              *

.equ ActiveStatLED=0 ;0=low, 1=high active stat
.if ActiveStatLED
.macro	set_led
	sbi	LEDport,LED
.endm

.macro	clr_led
	cbi	LEDport,LED
.endm
.else
.macro	set_led
	cbi	LEDport,LED
.endm

.macro	clr_led
	sbi	LEDport,LED
.endm
.endif



;LR*****************************************************

.equ MY_BOOTSTART = THIRDBOOTSTART	; here we define where the bootloader starts in the flash

;----------------------------- here we go -----------------------------------------------

.org MY_BOOTSTART		; bootstart address according to .equ above

; ---------------------------------- Boot Escape ------------------------------------------
;LR***********************************
        in tmp_r,TestPort       ;    *
        sbrc tmp_r,TestBit      ;    *
        rjmp FLASHEND+1         ;    * 
;LR***********************************

	sbi LEDdir, LED2					; 
	sbi LEDport,LED2					; 
	sbi LEDdir, LED3					; 
	cbi LEDport,LED3					; 
	sbi LEDdir, LED4					; 
	sbi LEDport,LED4					; 

; ----------------------------------- init stackpointer ---------------------------------
	ldi R24, low(RAMEND)			; SP = RAMEND
	ldi R25, high(RAMEND)
	out SPL, R24
	out SPH, R25 					

	ldi tmp_r, 0b00000101		; set prescaler to 1024
	out TCCR0, tmp_r
; ---------------------------------- init UART ------------------------------------------
;LR***********************************
.if Tr_Sp               ;            *
        sbi UCSRA,U2x   ;            *	
.else                   ;            *
        cbi UCSRA,U2x   ;            *
.endif                  ;            *
;LR***********************************

	ldi tmp_r, LOW(UBR) 	
	out UBRRL, tmp_r
.if HIGH(UBR)
	ldi tmp_r, HIGH(UBR) 	
	out UBRRH, tmp_r
.endif
	ldi tmp_r,(1<<RXEN)|(1<<TXEN)		; Enable receiver & transmitter, 8-bit mode
	out UCSRB,tmp_r 					

; -------------------------- check for action on UART -----------------------------------
; After power-on, the processor starts with the bootloader section. Ususally the user
; want the application to start automatically. Only in special cases, a software update
; is required. So if no ESC (ASCII(27)) is received within 8 seconds after power-on,
; the application starts.

	sbi LEDdir, LED					; Switch LEDport to output to drive an LED
	ldi R17, 20						; Preset the number of LED-flashes for the waiting periode

start_wait:
	clr_led     					; switch off the LED
	rcall pause200					; wait a moment
	sbic UCSRA,RXC
	rjmp Char_Rec0 					; check for incoming data (if RXC==1)

st_wait2:
	set_led     					; switch on the LED
	rcall pause200					; wait a moment
	sbic UCSRA,RXC 					; check for incoming data (if RXC==1)
	rjmp Char_Rec1 					; check for incoming data (if RXC==1)

	dec R17						; decremente the loop counter
	brne start_wait					; and leave loop if counter has reached zero 
	clr_led     					; switch off the LED
	rjmp FLASHEND+1					; Start the application program 

	;--- some character was received ---
Char_Rec0:
	set_led     					; switch on the LED
Char_Rec1:
	in R16,UDR 						; fetch received character and put it into R16
	cpi R16, ESC					; if the received character was ESC
	brne No_ESC						; start the bootloader main loop
;--------------------------------- start of main loop -----------------------------------
;-------------------- wait for a character from UART other than ESC ---------------------
L10:	
	rcall uartGet 					; repeat (R16 = uartGet)
	cpi R16, ESC					; while (R16 == ESCAPE)
	breq L10
No_ESC:
;--------- Command 'E' leaves the bootloader mode and starts the application ------------

	cpi R16, 'E' 					; if(R16=='E') 'E' = Exit bootloader
	brne L11
;LR********************************
	ldi  R16,CR
	rcall uartSend
TstUDRE:	sbis UCSRA,UDRE 		; wait for empty transmit buffer (until UDRE==1)
	rjmp TstUDRE
TstTXC:	sbis UCSRA,TXC 	        	; wait for USART Transmit Complete (until TXC==1)
	rjmp TstTXC
;LR********************************
	rcall pause200
	clr_led     					; switch off the LED

	cbi LEDport,LED4					; 
	cbi LEDdir, LED4					; 
;   cbi LEDport,LED3					; 
	cbi LEDdir, LED3					; 
	cbi LEDport,LED2					; 
    cbi LEDdir, LED2					; 

	rjmp FLASHEND+1					; Start the application program 
									; (flashend+1) = Address 0
;--------- Command 'a' is question from host for autoimcrement capability----------------
;				simple anser is 'Y' for yes, autoincrement is done
L11:
	cpi R16, 'a' 					; if(R16=='a') 'a' = Autoincrement?
	brne L12

	ldi R16,'Y' 					; Yes, autoincrement is quicker
	rjmp L70 						; uartSend(R16) Send the 'Y' and go up for next command


;--------- Command 'A' is setting the address for the next operation --------------------
; 		two bytes (in total) for high and low address are sent from the host
L12: 
	cpi R16,'A' 					; else if(R16=='A') write address
	brne L14

	rcall uartGet
	mov R27,R16 					; address high byte is stored in R27

	rcall uartGet
	mov R26,R16 					; address low byte is stored in R26
	
	lsl R26 						; address=address<<1
	rol R27 						; convert from byte address to word address
	
	rjmp L68 						; uartSend('\r') send CR and go up for next command

;--------- Command 'c' is write low byte to program memory ------------------------------
; the low byte is simply stored in a register, the actual writing to the flashes
; page-buffer is done later, after the high byte was received
L14: 
	cpi R16,'c' 					; else if(R16=='c') write program memory, low byte
	brne L16

	rcall uartGet					; read the byte to be written from host

	mov R22,R16 					; store data low byte in R22

	rjmp L68 						; uartSend('\r') send CR and go up for next command


;--------- Command 'C' is write high byte to program memory -----------------------------
; together with the (already received) low byte, the highbyte is writen to the flashes
; page buffer. When the page buffer is completely written, it can be transfered into
; the real flash by the "page write" command.
;
; If only SPMEN is written, the following SPM instruction will store the value in R1:R0 
; in the temporary page buffer addressed by the Z pointer. 

L16: 

	cpi R16,'C' 					; else if(R16=='C') write program memory,high byte
	brne L18
	
	rcall uartGet					; read the high byte from the host
	mov R23,R16 					; store the data high byte in R23

	movw ZL,R26 					; load the Z pointer with the current address
	
	movw R0,R22 					; transfer the data word (data high and low byte)
									; into registers R0 and R1
	
	rcall wait_for_spm				; make sure SPM is ready to accept a new task

	ldi R24, (1<<SPMEN)				; set SPMEN in SPMCR
	out SPMCR,R24 					; page load (fill temporary buffer)

	spm 							; Store program memory

	adiw R26,2 						; address=address+2
	rjmp L68 						; uartSend('\r') send CR and go up for next command


;-------------------------- Command 'e' is chip erase -----------------------------------
; "chip erase" for the boot loader means to erase all flash pages othen than the
; boot loader sector itself
L18: 

	cpi R16,'e' 					; else if(R16=='e') Chip erase
	brne L28

	; the loop that has to be performed to clear the application section is:
	; for(address=0; address < (2*MY_BOOTSTART); address += (2*PAGESIZE))
	; the "address" variable to be used are the registers R26 and R27
	
	clr R26 						; start with address 0
	clr R27

	rjmp L24						; continue the loop at the check for
									; "end-criteria reached"

;......... beginning of erase loop ............
L20: 

; If the PGERS bit is written to one at the same time as SPMEN, the next SPM 
; instruction within four clock cycles executes page erase. The page address 
; is taken from the high part of the Z pointer.

	rcall wait_for_spm				; make sure SPM is ready to accept a new task

	movw ZL,R26 					; load the Z-pointer with the address of the 
									; page to be erased

	ldi R24, (1<<PGERS) | (1<<SPMEN); simultaniously set PGERS and SPMEN in SPMCR
	out SPMCR,R24 					; 	to prepare for the page_erase

	spm 							; Store program memory
	nop

	subi R26,low(-2*PAGESIZE) 		; increment the address by the size of a page
	sbci R27,high(-2*PAGESIZE)		

	; this is the check for end-criteria reached, i.e. has the address already 
	; reached the beginning of the boot-loader section
L24: 
	ldi R24,low( 2*MY_BOOTSTART)	; load R24, R25 with the address where the boot-loader
	ldi R25,high(2*MY_BOOTSTART)	;	section starts

	cp R26,R24 						; do a word-compare to check if the address is still
	cpc R27,R25						; smaller than the address where the bootloader starts

	brlo L20						; if that is the case, go to the beginning of the erase loop

; ..... remember the number of flash-erases in the EEPROM .....
	ldi R26,low( E2END -1) 			; increment Chip Erase Counter located
	ldi R27,high(E2END -1) 			; at address E2END-1
	movw R22,R26 					; Save Chip Erase Counter Address in R22
	ldi R17,1 						; read EEPROM
	rcall EepromTalk
	mov R24,R16 					; R24 = Chip Erase Counter low byte
	rcall EepromTalk
	mov R25,R16 					; R25 = Chip Erase Counter high byte
	adiw R24,1 						; counter ++
	out EEDR,R24 					; EEDR = R24 Chip Erase Counter low byte
	movw R26,R22 					; R26 = Chip Erase Counter Address
	ldi R17,6 						; write EEPROM
	rcall EepromTalk
	out EEDR,R25 					; EEDR = R25 Chip Erase Counter high byte
	rcall EepromTalk
; ..........................................................

	rcall wait_for_spm				; make sure SPM is ready to accept a new task

	rcall enable_rww					; reenable the RWW section so it can be accessed again

	rjmp L68 						; uartSend('\r') send CR and go up for next command

;---------------------------- Command 'm' is write page ---------------------------------
; To execute page write, set up the address in the Z pointer, write 'X0000101' to SPMCR
; and execute SPM within four clock cycles after writing SPMCR. The data in R1 and R0
; is ignored. The page address must be written to PCPAGE. Other bits in the Z pointer will
; be ignored during this operation.
L28: 
	cpi R16,'m' 					; else if(R16== 'm') Write page
	brne L34

	rcall wait_for_spm				; make sure SPM is ready to accept a new task
		
	movw ZL,R26 					; load Z-pointer with address
	
	ldi R24, (1<<PGWRT) | (1<<SPMEN); set PGWRT and SPMEN in SPMCR to prepare for Write page
	out SPMCR,R24
	
	spm 							; Store program memory
	
	nop

	rcall enable_rww					; reenable the RWW section so it can be accessed again

L32: 
	rjmp L68 						; uartSend('\r') send CR and go up for next command


;--------------------- Command 'P' is enter programming mode ----------------------------
; nothing is done here, only the command is confirmed to host by sending CR
L34: 
	cpi R16,'P' 					; else if(R16=='P') Enter programming mode
	breq L32 						; uartSend('\r') Send CR to host and go up for next command


;--------------------- Command 'L' is leave programming mode ----------------------------
; nothing is done here, only the command is confirmed to host by sending CR
	cpi R16,'L' 					; else if(R16=='L') Leave programming mode
	breq L32 						; uartSend('\r') Send CR to host and go up for next command


;--------------------- Command 'p' is Return programmer type ----------------------------
; simply return an 'S' to indicate to host that this is a serial programmer
	
	cpi R16,'p' 					; else if (R16=='p') Return programmer type
	brne L38

	ldi R16,'S' 					; uartSend('S') Serial
	rjmp L70 						; uartSend(R16) and go up for next command
;--------------------- Command 'R' is "Read one word from program memory" ---------------
; reads one word from the 'current' address that is stored in R26 and increments R26
L38: 
	cpi R16,'R' 					; else if(R16=='R') Read program memory
	brne L40

	movw ZL,R26 					; load Z-pointer with address of memory to be read

	lpm R24,Z+ 						; read program memory LSB; store LSB in R24 and Z pointer ++
	lpm R16,Z+ 						; read program memory MSB; store MSB in R16 and Z pointer ++

	rcall uartSend 					; uartSend(R16) write back MSB to host

	movw R26,ZL 					; increment the 'current' address += 2

	mov R16,R24 					; LSB stored in R16

	rjmp L70 						; uartSend(R16) write back the LSB to host and go
							; up for next command

;--------------------- Command 'D' is "write data to EEPROM" ----------------------------
L40: 
	cpi R16,'D' 					; else if (R16=='D') Write data to EEPROM
	brne L41
	rcall uartGet					; fetch the data to write from the UART
	out EEDR,R16 					; EEDR = uartGet() 
	ldi R17,6 						; write EEPROM
	rcall EepromTalk
	rjmp L68 						; uartSend('\r') Confirm the command to host with CR


;--------- Command 'b' is question from host for block mode capability----------------
;		simple anser is 'N' 'N', no bootloader does not support blockmode
L41:

	cpi R16, 'b' 					; if(R16=='b') 'b' = Blockmode?
	brne L42

	ldi R16,'N' 					; send 'N'
	rcall uartSend

	ldi R16,'N' 					; send 'N'
	rjmp L70 						; uartSend(R16) Send the 'N' and go up for next command

;--------------------- Command 'd' is "read data from EEPROM -----------------------------
L42: 
	cpi R16,'d' 					; else if (R16=='d') Read data from EEPROM
	brne L43
	ldi R17,1 						; read EEPROM
	rcall EepromTalk 				; R16 = EEPROM data
	rjmp L70 						; uartSend(R16)


;-------------------------- Command ':' is universal command ----------------------------
; Host sends 3 more bytes which must be used to determine the required action. AVRProg
; uses the ':' with parameters to do things that could simply be done by r/F/N. 
; We have to map recognized parameters to the refering action.

L43: 
	cpi R16,':' 					; else if(R16==':') Universal Command
	brne L44
	

	;.............. read in the parameters ...............................

	rcall uartGet 					; R16 = uartGet()
	mov uni_cmd1, r16				; store the read byte

	rcall uartGet 					; R16 = uartGet()
	mov uni_cmd2, r16				; store the read byte

	rcall uartGet 					; R16 = uartGet()
	mov uni_cmd3, r16				; store the read byte

	;.....................................................................

	clr r16							; preset r16 with zero, if parameters are not
									; recognized, zero will be returned to host

	;.....................................................................

	cpi uni_cmd1, 0x58				; check if 1st paramter is 0x58 
	brne cmd1_not_0x58

	cpi uni_cmd2, 0x00				; check if 2nd paramter is 0x00
	brne cmd2_not_0x00_1

	; -> 58 00 is read lock bits,
	ldi ZL,1 						; Z pointer = 0001 (-> readFuseAndLock will read lock)
	rcall readFuseAndLock			; go get the requested bits

cmd2_not_0x00_1:

	cpi uni_cmd2, 0x08				; check if 2nd paramter is 0x08
	brne cmd2_not_0x08

	; -> 58 08 is read fuse high bits,
	ldi ZL,3 						; Z pointer = 0003 (-> readFuseAndLock will read high fuse)
	rcall readFuseAndLock			; go get the requested bits

cmd2_not_0x08:

cmd1_not_0x58:

	cpi uni_cmd1, 0x50				; check if 1st paramter is 0x50 
	brne cmd1_not_0x50

	cpi uni_cmd2, 0x00				; check if 2nd paramter is 0x00
	brne cmd2_not_0x00_2

	; -> 50 00 is read fuse bits,
	clr ZL 							; Z-pointer = 0000 (-> readFuseAndLock will read fuse)
	rcall readFuseAndLock			; go get the requested bits

cmd2_not_0x00_2:

cmd1_not_0x50:
	
	rcall uartSend 					; uartSend(bits) send the read lock/fuse bits

	rjmp L68 						; uartSend('\r') and go up for next command



;--------------------- Command 'F' is "read fuse bits" ----------------------------------
L44: 
	cpi R16,'F' 					; else if(R16=='F') Read fuse bits
	brne L46
	clr ZL 							; Z-pointer = 0000 (-> readFuseAndLock will read fuse)
	rjmp L50 						; rcall readFuseAndLock


;--------------------- Command 'r' is "read lock bits" ----------------------------------
L46: 
	cpi R16,'r' 					; else if(R16=='r') Read lock bits
	brne L48
	ldi ZL,1 						; Z pointer = 0001 (-> readFuseAndLock will read lock)
	rjmp L50 						; rcall readFuseAndLock


;--------------------- Command 'N' is "read fuse high bits" -----------------------------
L48: 
	cpi R16,'N' 					; else if(R16=='N') Read high fuse bits
	brne L52
	ldi ZL,3 						; Z-pointer = 0003 (-> readFuseAndLock will read high fuse)


;-------- for all previous commands F,r,N hear we call the readFuseAndLock --------------
;		function that will read the bits that are indicated by the Z-register	
L50: 
	rcall readFuseAndLock
	rjmp L70 						; uartSend(R16)


;--------------------- Command 't' is Return supported devices code ---------------------
;				obviously we return only the device code of the mega8 here
L52: 
	cpi R16,'t' 					; else if(R16=='t') Return supported devices code
	brne L54

	ldi R16,DT 						; Device Type
	rcall uartSend 					; uartSend(DT) send Device Type of Mega8

	clr R16							; command set of AVRProg requires the termination of
									; the t-command with a \0 not with a CR as other commands
	rjmp L70 						; uartSend(0) and go up for next command

; ---------------- ignored commands that are not sensible for boot loader ---------------
; The following 4 commands only make sense for a general programmer, not for a bootloader.
; As theres commands come with an additional byte as parameter, with have to fetch that
; byte from the UART to avoid messing up the UART reading.
L54: 								

	cpi R16,'l' 					; 'l' = Write Boot Loader lockbits
	breq L56

	cpi R16,'x' 					; 'x' = Set LED
	breq L56

	cpi R16,'y' 					; 'y' = Clear LED
	breq L56

	cpi R16,'T' 					; 'T' = Select device type
	brne L60

L56: 
	rcall uartGet 					; R16 = uartGet()
	rjmp L68 						; uartSend('\r') and go up for next command


;--------------------- Command 'S' is Return software identifier ------------------------
L60: 
	cpi R16,'S' 					; else if(R16=='S') Return software identifier
	brne L62
	
	ldi ZL,low(2*Soft_Id)			; load address of String into Z-Register
	ldi ZH,high(2*Soft_Id)

L61: 
	lpm R16,Z+						; read one character of the string and increment string pointer
	
	tst R16
	breq L72 						; exit the character output loop charcter was '\0' 

	rcall uartSend 					; send the read character via the UART

	rjmp L61						; go to start of loop for next character


;--------------------- Command 'V' is Return software Version ---------------------------
L62: 
	cpi R16,'V' 					; else if (R16=='V') Return Software Version
	brne L63

	ldi R16, VER_H 					; send bootloader software version higher number
	rcall uartSend

	ldi R16, VER_L 					; send bootloader software version lower number
	rjmp L70 						; uartSend and go up for next command

;--------------------- Command 'v' is Return hardware Version ---------------------------
L63: 
	cpi R16,'v' 					; else if (R16=='v') Return hardware Version
	brne L64

	ldi R16, VERH_H 				; send bootloader software version higher number
	rcall uartSend

	ldi R16, VERH_L 				; send bootloader software version lower number
	rjmp L70 						; uartSend and go up for next command


;--------------------- Command 's' is Return Signature Byte -----------------------------
L64: 
	cpi R16,'s' 					; else if (R16=='s') Return Signature Byte
	brne L65

	ldi R16,SB1 					; uartSend(SB1) Signature Byte 1
	rcall uartSend

	ldi R16,SB2 					; uartSend(SB2) Signature Byte 2
	rcall uartSend

	ldi R16,SB3 					; uartSend(SB3) Signature Byte 3
	rjmp L70 						; uartSend and go up for next command


;--------------------- Command '.' is new universal command -----------------------------
; this command will be ignored, only the inteface will be handled correctly
L65: 
	cpi R16,'.' 					; else if (R16=='.') New Universal Command
	brne L66

	;.............. read in the 4 parameters ...............................

	rcall uartGet 					; R16 = uartGet()
	rcall uartGet 					; R16 = uartGet()
	rcall uartGet 					; R16 = uartGet()
	rcall uartGet 					; R16 = uartGet()
	
	; ......................................................................

	clr R16 						; uartSend(/0)
	rcall uartSend

	rjmp L68 						; uartSend('\r') and go up for next command


;++++++++++++++ handling the different command till here ++++++++++++++++++++++++++++++++
;			only general completion for all commands below


;---------------------- failed commands can end up here ---------------------------------
;	an '?' is send via the UART to indicate fail host, then main loop starts again

L66: 
	ldi R16,'?' 					; else uartSend('?')
	rjmp L70 						; uartSend(R16)

;--------- successfully completed commands without return value can end up here ---------
;	an CR is sent via the UART to confirm execution to host, then main loop starts again

L68: 
	ldi R16,13 						; uartSend('\r')

;------------ successfully completed commands with return value can end up here ---------
;	the return value is sent via the UART to confirm execution to host 
;							then main loop starts again
L70: 
	rcall uartSend 					; uartSend(R16)

L72: 
	rjmp L10						; jump up to beginning of main loop

;-------------------------- end of main loop --------------------------------------------



;================= end of main program, only subroutines from here on ===================



;------------------ reads fuse or lock bits (depending on Z-Reg.) -------------
readFuseAndLock:

	; An LPM instruction within three cycles after BLBSET and SPMEN are set in the SPMCR
	; Register, will read either the Lock bits or the Fuse bits 
	; (depending on Z0 in the Z pointer) into the destination register.

	rcall wait_for_spm				; make sure SPM is ready to accept a new task

	clr ZH 							; Z pointer high byte = 0

	ldi R24,(1<<BLBSET)|(1<<SPMEN)	; set BLBSET and SPMEN in SPMCR 
	out SPMCR,R24 					; read fuse and lock
	lpm R16,Z 						; read program memory

	ret

;------------- does an read or write on the EEPROM (depending on R17) ---------
; 					 if R17 == 6 then Write, if R17 == 1 then Read
EepromTalk: 					
	out EEARL,R26 					; EEARL = address low
	out EEARH,R27 					; EEARH = address high
	adiw R26,1 						; address++
	sbrc R17,1 						; skip if R17 == 1 (read Eeprom)
	sbi EECR,EEMWE 					; EEMWE = 1 (write Eeprom)
	out EECR,R17 					; EECR = R17 (6 write, 1 read)

L90: 
	sbic EECR,EEWE 					; wait until EEWE == 0
	rjmp L90
	in R16,EEDR 					; R16 = EEDR

	ret

;---------------- send one character via UART (parameter is r16) --------------
uartSend: 							
	sbis UCSRA,UDRE 				; wait for empty transmit buffer (until UDRE==1)
	rjmp uartSend
	out UDR,R16 					; UDR = R16, start transmission

	ret

;---------------- read one character from UART (returned in r16) --------------
uartGet:
	
	sbis UCSRA,RXC 					; wait for incoming data (until RXC==1)
	rjmp uartGet
	in R16,UDR 						; return received data in R16
	
	ret

;-------------------- wait for SPM to be ready for new tasks ------------------
; while( SPMCR_REG & (1<<SPMEN) )
wait_for_spm:
	
	in r16, SPMCR					; read the content of SPMCR into register
	andi r16, (1<<SPMEN)			; check if bit SPMEN is set
	brne wait_for_spm				; and do more loops if bit not yet cleared

Wait_ee:
	sbic EECR, EEWE					; check that no EEPROM write access is present
	rjmp Wait_ee

	ret


; ---------------------------- re-enable the RWW section ----------------------
; When programming (page erase or page write) to the RWW section, the RWW section
; is blocked for reading (the RWWSB will be set by hardware). To re-enable the RWW
; section, the user software must wait until the programming is completed (SPMEN will be
; cleared). Then, if the RWWSRE bit is written to one at the same time as SPMEN, the
; next SPM instruction within four clock cycles re-enables the RWW section.
; If this is not done, all addresses will read $FF even if they contain other values.
enable_rww:

	rcall wait_for_spm				; make sure SPM is ready to accept a new task 

	ldi r16, (1<<RWWSRE) | (1<<SPMEN) 	; set rwwsre and spmen in SPMCR to prepare
	out SPMCR, r16						; for reenabling the rww section

	spm								; initiate the reenabling

	ret

pause200:
	ldi pa_10ms, 20
;---------------------------------- Pause -------------------------------------
; Delays the CPU the selected periode, parameter pa_10ms is in 10ms steps
pause:
	
	ldi tmp_r, TmrLoad		; preset the counter for 100 Hz (10ms)
	out TCNT0, tmp_r		; cycles till overflow

	in tmp_r, TIFR		; reset the overflow flag 
	sbr tmp_r, (1<<TOV0)	
	out TIFR, tmp_r

pw:
;LR****************************
	sbic UCSRA,RXC 	; check for incoming data (if RXC==1)
	rjmp PauseEnd
;LR****************************

	in tmp_r, TIFR	; check if overflow flag is set
	sbrs tmp_r, TOV0	
	rjmp pw		; if not, wait more

	;--- do this 10ms as often as requested in parameter pa_10ms
	dec pa_10ms		; decrement the counter
	brne pause		; and do the loop again if not zero yet

PauseEnd:	ret
	
;---------------- data for identifier string ----------------------------------
Soft_Id: 

	.DB "AVRB_M8", 0