page    132,66
;**************************************************************************
;   FLASH.ASM - routine to make user code bootable from a flash eeprom
;
;   1 June 1996 : version 1.0   rlr/jp
;
;   copyright (C) Motorola 1996
;
;   execute with:  R0 pointing to first word of user code
;                  R1 containing size of the user's code in WORDS
;**************************************************************************
        nolist
        include 'ioequ.asm'
        list

AAR0V          EQU   $000909    ; value programmed into AAR0 (SRAM Enable)
  ;  (32k words ext. SRAM located at p:$001000-$007FFF)
  ; compare 9 most significant bits, look for a match with address
  ; X:0000 0000 0xxx xxx xxxx xxxx, no packing, no muxing, P enabled,
  ; X and Y disabled, AAR0 pin active low, asynchronous SRAM-type access

AAR1V          EQU   $010811    ; value programmed into AAR1 (FLASH Enable)
  ;   (64k bytes FLASH located at x:$010000-$01FFFF)
  ; compare 8 most significant bits, look for a match with address
  ; X:0000 0001 xxxx xxx xxxx xxxx, no packing, no muxing, X enabled,
  ; P and Y disabled, AAR1 pin active low, asynchronous SRAM-type access

BCRV           EQU   $012581    ; value programmed into BCR
                                ; (12 wait states for AAR1, 1 elsewhere)

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

        org     p:$0080
main
        movep   #$040001,x:M_PCTL  ; MF=2 (34 MHz)
        movep   #AAR0V,x:M_AAR0    ; maps SRAM from p:$0000-$7fff
        movep   #AAR1V,x:M_AAR1    ; set up flash space to be mapped from
                                   ; x:$10000 to x:$1ffff (size 65536 bytes)
        movep   #BCRV,x:M_BCR      ; 12 wait states in AAR1 domain, 
                                   ;  (360ns cycle time)
                                   ;  1 wait state elsewhere

;----- compute the number of sectors to write/read
        move    #>42,x0
        clr     b    r1,a
        
_cmpsec
        inc     b
        sub     x0,a
        bgt     _cmpsec
        move   b0,p:NUM_SEC

;-------------------------------------------------------------------------
;  Initialize the loader code with the size of the user's code and
;  the address of the user's code.   Then write the loader routine
;  into the boot sector (the 1st 128-bytes) of the FLASH.
;-----
        move    r0,p:CODE_START    ; store the address of the user's code
        move    r1,p:CODE_SIZE     ; store the size    of the user's code
        move    #BOOT,r0           ; first DSP address to save
        move    #$010000,r2        ; first address of FLASH
        bsr     <WR_FLASH          ; put boot sector in flash
;--- boot sector written


;-------------------------------------------------------------------------
;  write the user's code into the FLASH.
;-----
        move    #$10080,r2         ; user's code begins at flash address $80
        move    p:CODE_START,r0    ; where to get the user's code
        move    p:NUM_SEC,r3       ; the number of sectors to write

        dor     r3,_wrsec
        bsr     <WR_FLASH          ; WR_FLASH loads 42 words each time
        nop
_wrsec

;----- user code written

        debug
        bra     *


;**************************************************************************
;  this is the bootstrap loader
;  it is loaded into the P:memory at boot time, sets up AAR0,
;  then moves the user's code into 56303 pram beginning at p:0
;
;  THE LOADER WILL SET UP AAR0 TO MAKE THE 56303 MEMORY MAP AS FOLLOWS:
;     (map not drawn proportionally to scale, but you get the point)
;
;               P:$FFFFFF  -------- 
;                         | unused |
;                         | ext P  |
;                         | space  |
;                         |        |
;               P:$01FFFF |--------|
;                         | FLASH  |
;               P:$010000 |--------|
;                         |        |
;                         | unused |
;                         | ext P  |
;                         | space  |
;                         |        |
;               P:$007FFF |--------| <-- end of accessible P memory
;                         |        |
;                         |        | 
;                         |        |
;                         | 28K    |
;                         | ext P  |\
;                         | (SRAM) | \
;                         |        |  \  user's program will reside here,
;               P:$001000 |--------|  /  note there is no gap btw int and ext P
;                         | 4K int | /
;                         | P space|/
;               P:$000000  -------- 
;                           56303
;                        P memory map
;
;**************************************************************************
BOOT
        dc      BOOT_END-BOOT           ;storage for size of boot
        dc      bootgo                  ;storage for address of boot
bootgo

; set up AAR0 to create the memory map shown above 
        movep   #$040001,x:M_PCTL  ; MF=2 (34 MHz)
        movep   #AAR0V,x:M_AAR0    ; maps SRAM from p:$0000-$7fff
        movep   #AAR1V,x:M_AAR1    ; set up flash space to be mapped from
                                   ; x:$10000 to x:$1ffff (size 65536 bytes)
        movep   #BCRV,x:M_BCR      ; 31 wait states in AAR1 domain, 1 wait state
                                   ; elsewhere, THIS WILL CHANGE


;----------------------------------------------------------------------------
;The following code moves the user's code from the flash to P:RAM.
;   The users code starts in the 2nd sector of the FLASH at P:$010080
;----------------------------------------------------------------------------


load    move   p:NUM_SEC,r3             ; number of sectors to read
        move   p:CODE_START,r0          ; starting address of user code
        move   p:CODE_SIZE,r2           ; R2 contains the length of code in WORDS
        move   #$010080,r1              ; user's code goes into FLASH at $010080

        dor    r3,_sector_loop          ; get all sectors
        dor    #42,_word_loop           ; 42 words per FLASH sector
        dor    #3,_byte_loop            ; each word requires 3 bytes
        move   x:(r1)+,a2               ; Load byte from flash.
        asr    #8,a,a                   ; Shift 8 times to move byte into
                                        ; correct position.
_byte_loop
        movem  a1,p:(r0)+               ; Stores 24-bit word into P mem
        nop                             ; dummy NOP to avoid do loop restrict.
_word_loop
        move    (r1)+
        move    (r1)+
_sector_loop        

        move   p:CODE_START,r1
        jmp    (r1)                     ; Jump to the user's code

CODE_SIZE   ds   1                      ; user code size
CODE_START  ds   1                      ; starting location of user code
NUM_SEC     ds   1                      ; number of sectors to save

BOOT_END        equ     *


;=========================================================================
;************************************************************************
;   WR_FLASH
;   This routine writes one 128-byte FLASH sector.
;      Each sector will contain 42 (24-bit) words from DSP RAM (126 bytes)
;      The last 2 bytes contain a 16-bit checksum of the data
; 
;   enter with:  r2 pointing to starting PEROM Byte Address from 56303 p.o.v.
;                r0 pointing to first DSP word to save
;
;   corrupts:    r0 - points to next P:memory location to save
;                r2 - points to next FLASH byte address to write
;                a,b,x0   
;-----------------------------------------------------------------------------

WR_FLASH
        clr     b                       ;initialize checksum
;----------------------------------------------------------------------------
;  disable_protect - Software data Protection routine
;----------------------------------------------------------------------------
disable_protect  
        move    #>$71,x0                ; $71 ==> $AA at Flash
        move    x0,x:$15555             ;Atmel needs $5555
        move    #>$8E,x0                ; $8E ==> $55 at Flash
        move    x0,x:$12AAA             ;Atmel needs $2AAA
        move    #>$41,x0                ; $41 ==> $A0 at Flash
        move    x0,x:$15555             ;Atmel needs $5555
   ;--- writes are now enabled

        dor     #42,move_code           ;move 126 bytes
        move    p:(r0)+,a               ;get 3 byte word
        add     a,b                     ;accumulate checksum
        move    a1,x:(r2)+              ;move low byte to flash
        lsr     #8,a
        move    a1,x:(r2)+              ;move mid byte
        lsr     #8,a
        move    a1,x:(r2)+              ;move high byte
move_code

        ;*** 127th and 128th bytes are 16-bit checksum
        move    b1,x:(r2)+              ;move low byte of checksum to flash
        lsr     #8,b                    ;get next 8 bits of checksum
        move    b1,x:(r2)+              ;move mid byte of checksum to flash

        bsr    <delay_20m               ;wait 20 milliseconds to finish 
                                        ;...program cycle
        rts

;---------------------------------------------------------------------------
; delay_20m -- 
; 20.15 ms of delay guarantees that the write cycle has finished.
;
; For Write Pulse Width High to extend 150 us requires a minimum of
; 5100 Icycles for a 33.868 MHz clock.  (29.5 ns/Icycle)
;
; the tWC is 20ms, so we just wait long enough here for the
; write cycle to have started AND finished...
;
;---------------------------------------------------------------------------
delay_20m
        dor     #110,_l1                ;110 x 207us = 22.7 ms
        move    #7000,x0
        rep     x0                      ; 207us delay
        nop
        nop
_l1
        rts
   
        end     main