newloader.asm

web51的开发库

;; FCON
	.equ	AUXR,  0x8E
	.equ	AUXR2, 0xA2
	.equ	FCON,  0xD1
	.equ	EECON, 0xD2
	.equ	EETIM, 0xD3

	.equ	XAF,    0x02
	.equ	WrUSR1, 0x50	;;Write User Flash
	.equ	WrUSR2, 0xA0
	.equ	WrXAF1, 0x52	;;Write Extra Flash
	.equ	WrXAF2, 0xA2
	.equ	FPS,    0x08	;;Flash Map Program Space

	.equ	CR, 0x0D
	.equ	LF, 0x0A

	;; XAF
	.equ	BSB, 0x00	; FF Boot Status Byte
	.equ	SBV, 0x01	; FC Software Boot Vector
	.equ	HSB, 0x04	; 18/1B Hardware Security Byte
	.equ	SSB, 0x05	; FF Software Security Byte
;	.equ	BOT, 0x06	;    Boot Reference ???
	.equ	MID, 0x30	; 58 Manufacturer ID
				;    (58 - Atmel-WM)
	.equ	ID1, 0x31	; D7 Device ID # 1
				;    (D7 - C51 X2 Electrically Erasable)
	.equ	ID2, 0x60	; FC Device ID # 2
				;    (FC - memories size)
	.equ	ID3, 0x61	; FF Device ID # 3
				;    (FF - revision 0)

	.data
count:		.ds.b	1
oscclk:		.ds.b	1
pointer:	.ds.b	1	;; write pointer to data buffer
hex_checksum:	.ds.b	1	;; hex record checksum
dbuffer:	.ds.b	22	;; data input buffer

	.equ	LOADER,   0xFC00
	.equ	APIENTRY, 0xFFF0

	.text
	.org	LOADER
;; ISP start
;;   FC00
	ljmp	ISP
;; ISP status byte check
;;   FC03
	mov	R1, #7
	mov	DPTR, #1
	;; Read boot status byte
	;; input
	;;  R1   = 0x07
	;;  DPTR = 0x0001
	;; output
	;;  Acc = value of byte read
	acall	API
	jz	jmp0		; if boot_status = 0 goto 0x0000
	mov	R1, #7
	mov	DPTR, #2
	;; Read boot vector
	;; input
	;;  R1   = 0x07
	;;  DPTR = 0x0002
	;; output
	;;  Acc = value of byte read
	acall	API
	mov	DPH, A		; else goto (boot_vector << 8)
	mov	DPL, #0
	clr	A
	jmp	@A+DPTR
jmp0:	ljmp	0

ISP:	mov	R0, #0x7F
ramClr:	mov	@R0, #0
	djnz	R0, ramClr
	mov	AUXR,  #0b00001101
;			  ..0..... RD/, WR/ 6 clock length
;			  ....11.. 1024 bytes XRAM
;			  ......0.Internal data memory access
;			  .......1 ALE only if MOVX or MOVC
	acall	autobaud	; wait for 'U'
	setb	TI
	mov	a, #'U'	; "echo" initial character
	acall	CO
	setb	REN
nextLineLoop:
	clr	RI
	mov	hex_checksum, #0
	mov	pointer, #dbuffer
WaitColon:
	acall	UCICO
	cjne	A, #':', WaitColon ; wait for start of hex record
	acall	read2char
	;; buffer
	;;  0123456789......
	;; :NNAAAARRDD..DDCC
	mov	A, dbuffer	; No of data bytes
	add	A, #4		; + 2 bytes address + 1 byte record type
	mov	R3, A		; + 1 byte checksum
r2chlp:	acall	read2char
	djnz	R3,r2chlp
	mov	A, hex_checksum
	jz	checksumOK
				; checksumBAD
	mov	a, #'X'	; checksum error
	acall	CO
	acall	CRLF
nextLine:
	acall	CRLF
	ajmp	nextLineLoop

checksumOK:
	acall	hexAPI
	ajmp	nextLine

hexAPI:	;; dbuffer
	;;  01234....
	;; :NAARD..DC
	mov	A, dbuffer+3
	;; switch (record_type)
	cjne	A, #0, Hn0
	ajmp	hexAPI0
Hn0:	cjne	A, #1, Hn1
	ajmp	hexAPI1
Hn1:	cjne	A, #2, Hn2
	ajmp	hexAPI2
Hn2:	cjne	A, #3, Hn3
	ajmp	hexAPI3
Hn3:	cjne	A, #4, Hn4
	ajmp	hexAPI4
Hn4:	cjne	A, #5, Hn5
	ajmp	hexAPI5
Hn5:	cjne	A, #0x10, Hn10
	ajmp	hexAPI10
Hn10:	cjne	A, #0x20, Hn20
	ajmp	hexAPI20
Hn20:	ret

;*********** Fn 0  - Write data to Flash ******************
;*********** Fn 10 - Write data to XRAM  ******************
;*********** Fn 20 - Write data to EEPROM *****************
hexAPI0:
hexAPI10:
hexAPI20:
	;; dbuffer
	;;  01234
	;; :NAARDD..DDC
	acall	swSecurityBits
	jnb	Acc.0, lockLB0	; LB0 programmed ?
	mov	DPH, dbuffer+1
	mov	DPL, dbuffer+2
	mov	count, #1
nextByteToFlash:
	mov	A, count
	setb	C
	subb	A, dbuffer
	jnc	noNextByte
	mov	A, #dbuffer+3
	add	A, count
	mov	R0, A
	mov	a, dbuffer+3
	cjne	a, #0, otherWrite
	mov	A, @R0
	acall	movAccToFlash
nxtWr:	inc	DPTR
	inc	count
	sjmp	nextByteToFlash
otherWrite:
	cjne	a, #0x10, writeEEprom
	mov	A, @R0
	movx	@dptr,a
	sjmp	nxtWr
writeEEprom:
	mov	A, EECON
	jb	Acc.0, writeEEprom
	mov	a,oscclk
	clr	C
	rlc	a			; * 2
	clr	C
	rlc	a			; * 4
	add	a,oscclk		; * 5
	mov	EETIM, a
	mov	EECON, #0x02		; Enable EEPROM Space bit
	mov	A, @R0
	movx	@dptr,a
	sjmp	nxtWr

noNextByte:
	mov	a, dbuffer+3
	cjne	a, #0, otherFlush
	acall	flushFlash
	ajmp	printDot		; RETURN

otherFlush:
	cjne	a, #0x10, flushEEprom
	ajmp	printDot		; RETURN

flushEEprom:
	mov	R2, IE		; save IE
	clr	EA		; disable all interrupts
	mov	EECON, #0x50	; Write Sequence
	mov	EECON, #0xA0
	mov	IE, R2		; restore IE
	ajmp	printDot		; RETURN

lockLB0:mov	a, #'P'
	ajmp	CO			; RETURN

;*********** Fn 1 ******************
;*********** Fn 3 ******************
hexAPI3:
	;; dbuffer
	;;  01234
	;; :NAARDD..DDC
	mov	A, dbuffer+4
	cjne	A, #7, noSubf7
	;; full chip erase (include boot vector / status byte
	;;  and software security bit erase)
	acall	EraseFlash
	sjmp	EraseBoot
noSubf7:
	cjne	A, #4, noSubf4
	;; Reset Boot Vector and Status Byte
	acall	swSecurityBits
	jnb	Acc.0, lockB	; LB0 programmed ?
EraseBoot:
	acall	API4		; Erase boot vector 
				;  status byte (set to high(LOADER))
	mov	DPTR, #BSB	; Erase boot status byte
	mov	A, #0xFF	; boot status byte = 0xFF
	acall	API6
	sjmp	subfCont
noSubf4:
	cjne	A, #6, noSubf6
	;; Program Status Byte or Boot Vector
	acall	swSecurityBits
	jnb	Acc.0, lockB	; LB0 programmed ?
noSubf6:
	cjne	A, #5, noSubf5
	;; Program Software Security Bits
	acall	swSecurityBits
	jnb	Acc.4, lockB	; LB1 programmed ?
noSubf5:
	acall	api_call	; get parameters from hex record and call API

subfCont:

hexAPI1:			; hex eof record
	ajmp	printDot	; RETURN

lockB:	mov	a, #'P'
	ajmp	CO		; RETURN

;*********** Fn 2 ******************
hexAPI2:			; specify oscilator frequncy
	mov	oscclk, dbuffer+4
	ajmp	printDot	; RETURN

;*********** Fn 4 - DUMP data / Blank Check ******************
hexAPI4:
; display device data or blank check 
	;; dbuffer
	;;  0123456789
	;; :NAA4SSEEFC
	acall	swSecurityBits
	jb	Acc.4, LB1OK	; LB1 programmed ?
	mov	a, #'L'
	ajmp	CO		; Error RETURN
	
LB1OK:	;; dbuffer
	;;  0123456789
	;; :NxxRSSEEFC
	mov	DPH, dbuffer+4		; starting address
	mov	DPL, dbuffer+5
	mov	A, dbuffer+8	; subfunction
				; blank check = 1, display data = 0
	xrl	a,#1
	jnz	display_data

blankTestLoop:
	acall	API3
	;; Read device data
	;; input  DPTR = address of byte read
	;; output Acc = value of byte read
	xrl	A, #0xFF
	jnz	blankFAIL
	mov	A, dbuffer+6	; ending address
	cjne	A, DPH, noEnd
	mov	A, dbuffer+7
	cjne	A, DPL, noEnd
	ajmp	printDot	; RETURN -  O.K. print '.'
noEnd:	inc	DPTR
	sjmp	blankTestLoop

blankFAIL:
	mov	a, DPH		; else print failed address
	acall	printhex
	mov	a, DPL
	ajmp	printhex	; RETURN

display_data:
	acall	CRLF
	mov	count, #0
	mov	a, DPH
	acall	printhex
	mov	a, DPL
	acall	printhex
	mov	a, #'='
	acall	CO
displayNextByte:
	mov	A, dbuffer+8	; subfunction
				; blank check = 1, display data = 0
	jnb	Acc.1, displayFlash
	jb	Acc.0, displayEeprom
	movx	a,@dptr		; display XRAM = 2
	ajmp	displayAll
displayEeprom:			; display EEPROM = 3
	mov	EECON, #2	; set Enable EEPROM Space bit
	movx	a,@dptr
	mov	EECON, #0	; clear Enable EEPROM Space bit
	ajmp	displayAll
displayFlash:
	acall	API3
	;; Read device data
	;; input  DPTR = address of byte read
	;; output Acc = value of byte read
displayAll:
	acall	printhex
	;; dbuffer
	;;  0123456789
	;; :NxxRSSEEFC
	mov	A, dbuffer+6	; ending address
	cjne	A, DPH, noDumpEnd
	mov	A, dbuffer+7
	cjne	A, DPL, noDumpEnd
	ret			; RETURN
noDumpEnd:
	inc	DPTR
	inc	count
	mov	A, count
	jnb	Acc.4, displayNextByte	; 16 bytes / line
	sjmp	display_data

;*********** Fn 5 ******************
hexAPI5:
	;; dbuffer
	;;  01234
	;; :NAARFSC
	mov	A, dbuffer+4
	cjne	A, #7, noFunc7
	mov	A, dbuffer+5
	jz	noFunc7		; Function 0700
	acall	swSecurityBits
	jnb	Acc.4, lockL	; LB1 programmed ?
noFunc7:
	acall	api_call	; get parameters from hex record and call API
	acall	printhex
	ajmp	printDot	; RETURN

lockL:	mov	a, #'L'
	ajmp	CO		; RETURN

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

EraseFlash:
	mov	DPTR, #0	; start of flash
nextFlashPage:
	mov	R0, #0x80	; page size
nextFlashByte:
	mov	A, #0xFF
	acall	movAccToFlash
	mov	A, #HIGH(LOADER-1)
	cjne	A, DPH, noLastFlashAddr
	mov	A, #LOW(LOADER-1)
	cjne	A, DPL, noLastFlashAddr
lastFlashAddr:
	acall	flushFlash
	mov	DPTR, #SSB
	mov	A, #0xFF
	ajmp	API6
noLastFlashAddr:
	inc	DPTR
	djnz	R0, nextFlashByte
	acall	flushFlash
	sjmp	nextFlashPage

movAccToFlash:
	orl	FCON, #FPS	; Enable FLASH
	movx	@DPTR, A	; Write Flash
	ret

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

	;; *******************
	;; *****  API 0  *****
	;; *******************
	
	;; input
	;;  R1  = 0x00
	;;  DPH = 0x00
	;; output
	;;  Acc = value of byte read

	;; input
	;;  DPL = 0x00
	;; Read copy of the manufacturer ID

	;; input
	;;  DPL = 0x01
	;; Read copy of the device ID #1

	;; input
	;;  DPL = 0x02
	;; Read copy of the device ID #2

	;; input
	;;  DPL = 0x03
	;; Read copy of the device ID #3

API0:	mov	A, DPL
	jz	API0_0
	dec	A
	jz	API0_1
	dec	A
	jz	API0_2
	sjmp	API0_3

API0_0:	mov	DPTR, #MID	; Manufacturer ID
	sjmp	rdXAF
API0_1:	mov	DPTR, #ID1	; Device ID # 1
	sjmp	rdXAF
API0_2:	mov	DPTR, #ID2	; Device ID # 2
	sjmp	rdXAF
API0_3:	mov	DPTR, #ID3	; Device ID # 3
	sjmp	rdXAF

	;; *******************
	;; *****  API 2  *****
	;; *******************
	;; Program data byte
		
	;; input
	;;  R1   = 0x02
	;;  DPTR = address of byte to program
	;;  Acc  = byte to program
	;; output
	;;  Acc  = 0x00 if pass, !0x00 if fail

API2:	acall	movAccToFlash
	clr	A
flushFlash:
	mov	R2, IE		; save IE
	clr	EA		; disable all interrupts
	mov	FCON, #WrUSR1
	mov	FCON, #WrUSR2
	mov	IE, R2		; restore IE
disableFlashWr:
	mov	FCON, #0	; Disable FLASH
	ret

	;; *******************
	;; *****  API 3  *****
	;; *******************
	;; Read device data
	
	;; input
	;;  R1   = 0x03
	;;  DPTR = address of byte read
	;; output
	;;  Acc = value of byte read

API3:	anl	FCON, #0
	mov	A, #0
	movc	A, @A+DPTR
	ret

	;; *******************
	;; *****  API 4  *****
	;; *******************
	;; Erase boot vector status byte
	
	;; input
	;;  R1   = 0x04
	;;  DPH  = 0x00
	;;  DPL  = don't care
	;; output
	;;  none

API4:	mov	DPTR, #SBV
	mov	A, #HIGH(LOADER)

	;; *******************
	;; *****  API 6  *****
	;; *******************
	
	;; input
	;;  R1   = 0x06
	;;  DPH  = 0x00

	;; Program boot status byte
	;;  DPL  = 0x00
	;;  Acc  = status byte
	;; output
	;;  Acc  = status byte

	;; Program boot vector
	;;  DPL  = 0x01
	;;  Acc  = boot vector
	;; output
	;;  Acc  = boot vector

API6:	mov	DPH, #0
	acall	movAccToFlash
	mov	R4, IE		; save IE
	clr	EA		; disable all interrupts
	mov	FCON, #WrXAF1
	mov	FCON, #WrXAF2
	mov	IE, R4		; restore IS
	sjmp	disableFlashWr

	;; *******************
	;; *****  API 5  *****
	;; *******************
	;; Program software security bit

	;; input
	;;  R1   = 0x05
	;;  DPH  = 0x00
	;;  DPL  = 0x00 - security bit # 1 (inhibit writing to FLASH)
	;;         0x01 - security bit # 2 (inhibit FLASH verify)
	;;         0x10 - allow ISP writing to FLASH
	;;         0x11 - allow ISP FLASH verify
	;; output
	;;  none

API5:	mov	A, DPL
	mov	DPTR, #SSB
	xrl	A, #1
	cjne	A, #1, API6
	xrl	A, #0x11
	sjmp	API6

swSecurityBits:
	mov	DPL, #0

	;; *******************
	;; *****  API 7  *****
	;; *******************
	
	;; input
	;;  R1  = 0x07
	;;  DPH = 0x00

	;; Read software security bits
	;; input
	;;  DPL = 0x00
	;; output
	;;  Acc = value of byte read

	;; Read boot status byte
	;; input
	;;  DPL = 0x01
	;; output
	;;  Acc = value of byte read

	;; Read boot vector
	;; input
	;;  DPL = 0x02
	;; output
	;;  Acc = value of byte read

	;; Read copy of the hardware security bits
	;; input
	;;  DPL = 0x03
	;; output
	;;  Acc = value of byte read

API7:	mov	A, DPL
	jz	API7SSB
	dec	A
	jz	API7BSB
	dec	A
	jz	API7SBV
	mov	DPTR, #HSB
rdXAF:
	mov	FCON, #XAF
	clr	A
	movc	A, @A+DPTR
	sjmp	disableFlashWr
API7SSB:
	mov	DPTR, #SSB
	sjmp	rdXAF
API7BSB:
	mov	DPTR, #BSB
	sjmp	rdXAF
API7SBV:
	mov	DPTR, #SBV
	sjmp	rdXAF

	;; *******************
	;; *****  API 8  *****
	;; *******************
	;; Read bootloader version
	
	;; input
	;;  R1  = 0x08
	;; output
	;;  Acc = value of byte read

API8:	mov	A, #0x24
       	ret


	;; *******************
	;; *****  API 9  *****
	;; *******************
	;; Program data page
		
	;; input
	;;  R1    = 0x09
	;;  DPTR0 = address of the first byte to program in the FLASH memory
	;;  DPTR1 = address in XRAM of the first data to program
	;;          (second data pointer)
	;;  Acc   = number of bytes to program (max. single 128 byte page !)
	;; output
	;;  Acc   = 0x00 if pass, !0x00 if fail

API9:	anl	AUXR2, #(0xFF ^ 1); DPTR0
	mov	R6, A
	mov	R4, DPL
WrByte9:inc	AUXR2		; DPTR1
	movx	A, @DPTR
	inc	DPTR
	dec	AUXR2		; DPTR0
	acall	movAccToFlash
	clr	A
	anl	FCON, #(0xFF ^ FPS) ; disable FLASH
	inc	DPTR
	djnz	R6, WrByte9
	mov	DPL, R4
	sjmp	flushFlash

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

autobaud:
	;; wait for 'U' character 0x55
	;; 10 10101010 1
	mov	T2CON, #0
;-_start_-
;; 10 1
	jb	RXD, .	;-v
	jnb	RXD, .	;_^
	setb	TR2
	mov	R0, #3
;-_start_--_1_--_2_--_3_--
;; 10 1010101
BD3:	jb	RXD, .	;-v
	jnb	RXD, .	;_^
	djnz	R0, BD3
;-_start_--_1_--_2_--_3_--_4_--
;; 10 10101010 1
	jb	RXD, .	;-v
	jnb	RXD, .	;_^
	clr	TR2
	dec	TL2
	mov	A, TL2
	cjne	A, #0xFF, NoDecTH2
	dec	TH2
	mov	A, TH2		;????
NoDecTH2:
	mov	R0, #3
	;;TH2TL2 / 8
ShT3:	clr	C
	xch	A, TH2
	rrc	A
	xch	A, TH2
	xch	A, TL2
	rrc	A
	xch	A, TL2
	djnz	R0, ShT3
	;;(TH2TL2 / 8) * 12
	mov	A, TL2
	mov	B, #12
	mul	AB
	mov	R6, B
	mov	R0, #5
	;;((TH2TL2 / 8) * 12) / 32
ShT5:	xch	A, R6
	clr	C
	rrc	A
	xch	A, R6
	rrc	A
	djnz	R0, ShT5
	cpl	A
	mov	RCAP2L, A
	mov	A, R6
	cpl	A
	mov	RCAP2H, A
	mov	SCON, #0x43
	mov	T2CON, #0x30
	setb	TR2
	ret

CRLF:	mov	a, #CR
	acall	CO
	mov	a, #LF
;	ajmp	CO

CO:	jnb	TI, .
	clr	TI
	mov	SBUF, a
	ret

printDot:
	mov	a, #'.'	; O.K.
	ajmp	CO

read2char:
	;; buffer
	;;  0123456789......
	;; :NNAAAARRDD..DDCC
	acall	GNibble
	swap	a
	mov	R0,a		; save high nibble
	acall	GNibble
	orl	a,R0		; merge high & low nibble
	mov	R0,a
	mov	A, pointer
	xch	A, R0
	mov	@R0, A		; save it to buffer
	add	A, hex_checksum
	mov	hex_checksum, A
	inc	pointer
	ret

printhex:
	push	acc
	swap	a
	acall	PNibl
	pop	acc
PNibl:	anl	a,#0x0F
	add	a,#0x90
	da	a
	addc	a,#0x40
	da	a
	ajmp	CO

CI:	jnb	RI, .
	clr	RI
	mov	A, SBUF
	ret

UCICO:	acall	CI
	acall	UCase
	ajmp	CO

GNibble:acall	UCICO
	mov	C,Acc.6
	jnc	decimal		;0..9
	add	a,#9		;0x41..0x46 -> 0x4A..4F
decimal:anl	a,#0x0F
	ret

UCase:	anl	a,#0x7F		;strip parity
	mov	b,a
	add	a,#(0x100 - 'a')
	jnc	UCase0		;0x00..0x60
	add	a,#(0x100 - ('z' + 1 - 'a'))
	jc	UCase0		;0x7B..0x7F
	mov	a,b
	anl	a,#0x5F
	ret

UCase0:	mov	a,b
	ret

;**************************************************************
    .ascii	"(c)BCL 2002 - [e-mail]"

    .org	APIENTRY - 46
api_call:
	.using	0
	;; dbuffer
	;;  01234567
	;; :NAARFSDC
	mov	AR1, dbuffer+4	;API subfunction
	mov	A, dbuffer+5
	anl	A, #0x0F	; #15
	mov	DPL, A		;API selection code
	mov	A, dbuffer+6	;API data input (as need)
;	ajmp	API

APIX:	cjne	R1, #8,Ln8
    	ajmp	API8
Ln8:	cjne	R1, #0,Ln0
	ajmp	API0
Ln0:	cjne	R1, #2,Ln2
	ajmp	API2
Ln2:	cjne	R1, #3,Ln3
	ajmp	API3
Ln3:	cjne	R1, #4,Ln4
	ajmp	API4
Ln4:	cjne	R1, #5,Ln5
	ajmp	API5
Ln5:	cjne	R1, #6,Ln6
	ajmp	API6

	;; Entry Point for API
    .org	APIENTRY
	;; FFF0

API:	ajmp	APIX
Ln6:	cjne	R1, #7,Ln7
	ajmp	API7
Ln7:	cjne	R1, #9,Ln9
	ajmp	API9
Ln9:	ret

	;; end