; ============================================================================
; F_ST30_ARM - Flash programming algorithm for ST30 Embedded Flash
;
; Library Name: Included into container .s file.
;
; Module Name:  F_ST30_ARM.S
; Module Descr: Flash programming for ST30 Embedded Flash
; Creation Date:2002
; Author:       Ian Field
;
; THIS INFORMATION IS PROPRIETARY TO
; ARM, INC.
; 1981 North Broadway, Suite 245
; Walnut Creek, CA 94596
; USA
; ----------------------------------------------------------------------
; Copyright (c) 2002  ARM, Inc.
; ALL RIGHTS RESERVED;
;
; Revisions of F_ST30_ARM.S: (latest revision on top)
; #.#  Name  Date      Description
; ---  ----- --------  -----------------------------------------------------
; 1.0  Ian   09/02     Ported to ST30
; $Revision: 1.1.6.1 $
;
; Implementation notes:
;
; GENERAL
; -------
;
;       This file is to be included into another asm file which has the
; board/chip specific knowledge needed for initialization and the like.
; That is, this is the algorithm only.
;
;       This file is based on information on Intel Boot block flash 
; of various forms. It is generalized to handle x8 and x16 accesses.
; It does not need to know the block sizes or positions as that is all
; passed in. 
;
;       This uses the standard RVDEBUG implementation for an API. That
; means that registers are used for passing arguments and returning
; status. The registers used are based on the save/restore list. The
; first registers are assumed to be the ones to use for passing args.
; In the case of ARM, this is R0, R1, R2, R3, etc.
;
; REGISTER MODEL
; --------------
;
;       The register model for this routine is as follows:
;       R0:     Input: page of Flash (not used on ARM)
;               Output:status return to host
;       R1:     Input: base address of Flash block to operate on
;       R2/R3/R4/R5/R8/R9: Input: arguments
;               Typical meanings: R2=Counter
;       R6/R7:Scratch
;
; -----------------------------------------------------------------------------
; Description:
; ----------------------------------------------------------------------------
;                               NOTICE
;
;       This code is proprietary and secret; the use of this source is
; restricted, and all rights are reserved.
;
;       If reading for interest, enjoy.
;
;       If maintaining, read comments carefully! There are some inter-depen-
; dencies and connectivities. Areas with particular connection are marked.
; There are some variable protocols that are not self evident: check all uses
; of variables before making big changes.
; ============================================================================
;

;************************************************************************/
;* DEFINE ENTRY POINTS                                                  */
;************************************************************************/

;       EXPORT          FLASH_init      // provided by asm that includes us
;       EXPORT          FLASH_erase_all // not available
        EXPORT          FLASH_erase
        EXPORT          FLASH_write_erase
        EXPORT          FLASH_write
        EXPORT          FLASH_validate
        EXPORT          FLASH_break
;       EXPORT          FLASH_term      // we do not need one

;************************************************************************/
;* DEFINE MACROS AND EQUATES                                            */
;************************************************************************/


;************************************************************************/
;* THE GLOBAL FUNCTIONS (EXPORTED PUBLICLY)                             */
;************************************************************************/
 
;* -----------------------------------------------------------------------
;  FLASH_erase - erase a Flash block
;
;  Notes:
;     - this erases a Flash block on request from host. The host has
;       the information on which end has the boot block and its size,
;       so we do not need to worry about that. 
;     - we may be asked to erase one or a set of blocks, but all will
;       have the same size.
;
;  Input/Output:
;     - In: R1=Base of 1st Flash Block to erase
;           R0=Page of Flash (no meaning for ARM)
;           R2=Count of blocks to do
;           R4=Size of blocks (for iterate) -- used to be R3, why?!?
;     - Out:R0=status code (0=OK, else error)
;     - Scratch: R6,R7
;  ----------------------------------------------------------------------- */

FLASH_erase
        bl      erase_block     ; erase block in R1
        bne     flash_exit      ; failed on this one

        subs    R2,R2,#1        ; count down
        addne   R1,R1,R4        ; setup for next block if more
        bne     FLASH_erase     ; more to do
        b       flash_exit      ; Stop routine on breakpoint

;* -----------------------------------------------------------------------
;  FLASH_write - write to a Flash block
;  FLASH_write_erase - erase then write
;
;  Notes:
;     - this writes a buffer into a flash block. The caller is responsible
;       for pre-erasing if needed.
;     - note: this is writing half-words and not bytes
;     - the host knows about block sizes and all, and passes in the needed
;       info.
;     - if we are writing into a later part of the block, this will be
;       handled by the host.
;
;  Input/Output:
;     - In: R1=Base of Flash Block to write
;           R0=Page of Flash (no meaning for ARM)
;           R2=Count of bytes to copy
;           R4=Offset in block to copy into (from base)
;           R5=Address of buffer to copy from
;           R8=Page of buffer (no meaning for ARM)
;           R9=0 if no verify, else same value as R2 (count)
;     - Out:R0=status code (0=OK, else error)
;     - Scratch: R6,R7
;   Notes:
;     - no speed benefit in using double word over single word prog,.
;       24us vs 48us. Bulk of time is spent erasing sectors.
;     - double word requires first word is even word address aligned.
;  ----------------------------------------------------------------------- */

FLASH_write_erase
        bl      erase_block     ; erase block in R1
        bne     flash_exit      ; failed on this one
FLASH_write
        add     R4,R4,R1        ; compute start address
write_loop
        mov     R6,#0x00100000
        mov     R7,#0x20000000  ; word program
        str     R7,[R6]

        str     R4,[R6,#0x10]   ; write address
        add     R4,R4,#4
        ldr     R7,[R5],#4      ; load 1st value from buffer then inc
        str     R7,[R6,#0x08]

        ldr     R7,[R6]
        orr     R7,R7,#0x80000000
        str     R7,[R6]

        bl      wait_for_ready  ; wait for Flash to finish write

        subs    R2,R2,#4        ; decrement count, more?
        bgt     write_loop      ; yes, continue

        bl      check_status    ; check Flash status and return in R0

        cmp     R9,#0           ; want verify?
        beq     done_write      ; no, just quit

        cmp     R0,#0           ; write went ok?
        bne     done_write      ; no, just quit

        mov     R2,R9           ; reset count
        sub     R4,R4,R2        ; back up to start of block to verify
        sub     R5,R5,R2        ; back up to start of buffer to verify
        b       FLASH_validate  ; go on to validate code

done_write
        b       flash_exit      ; Stop routine on breakpoint

;* -----------------------------------------------------------------------
;  FLASH_validate - validate write to a Flash block
;
;  Notes:
;     - this compares a buffer and a flash block. The caller uses this
;       after a write to verify the write worked.
;     - the host knows about block sizes and all, and passes in the needed
;       info.
;
;  Input/Output:
;     - In: R1=Base of Flash block to verify
;           R0=Page of Flash (no meaning for ARM)
;           R2=Count of bytes to verify
;           R4=Offset in block to verify from
;           R5=Address of buffer to verify against
;           R8=Page of buffer (no meaning for ARM)
;     - Out:R0=status code (0=OK, else error)
;     - Scratch: R6,R7
;  ----------------------------------------------------------------------- */

FLASH_validate
        mov     R6,#0
        mov     R7,#0
validate_loop
        ldr     R7,[R5],#4      ; load value from buffer
        ldr     R6,[R4],#4      ; load value from Flash
        cmp     R6,R7           ; same?
        bne     bad_validate    ; no, failed

        subs    R2,R2,#4        ; decrement count, more?
        bgt     validate_loop   ; yes, continue

        bl      check_status    ; check Flash status and return in R0

        b       flash_exit      ; Stop routine on breakpoint

bad_validate
        mov     R0,#1           ; compare
        b       flash_exit      ; Stop routine on breakpoint

;* -----------------------------------------------------------------------
;  FLASH_break - end of function entry for all Flash routines
;
;  Notes:
;     - this routine is the Stop routine for the flash code. It runs over
;       what should be a break (set by host). If the host messes up, it
;       will loop forever allowing the host to halt it.
;
;  Input/Output:
;     - In: R0=status code to return (0=OK, else error)
;           R1=base of Flash block operated on
;   ----------------------------------------------------------------------- */

Local_init                      ; we have no local init
flash_exit
        mov     R6,#0x00100000  ; clear status bits
        mov     R7,#0x00000000
        str     R7,[R6]
FLASH_break
        nop                     ; place to put breakpoint from host
forever
        b       forever         ; in case host screws up

;************************************************************************/
;* STATIC FUNCTIONS                                                     */
;************************************************************************/

;* -----------------------------------------------------------------------
;  erase_block - erase a block of the flash and check if OK
;
;  Notes:
;     - this handles erase of a Flash block and returns status in R0
;       as well as the Z flag
;
;  Input/Output:
;     - In: R1=Base of Flash
;     - Out:R0=Status (0=OK, else failed)
;     - Scratch: R0,R6
;  ----------------------------------------------------------------------- */

erase_block
        mov     R6,#0x100000
        mov     R0,#0x08000000
        str     R0,[R6,#0x00]   ; Set SER in FCR0

        mov     R0,#0x000000FF
        orr     R0,R0,#0x0000FF00
        orr     R0,R0,#0x000F0000
        and     R0,R1,R0        ; base of 0x00000000 or 0x80000000

        cmp     R0,#0x00002000  ; B0F0
        movlt   R0,#0x00000001
        blt     erase_set_sectors
        cmp     R0,#0x00008000  ; B0F1
        movlt   R0,#0x00000002
        blt     erase_set_sectors
        cmp     R0,#0x00010000  ; B0F2
        movlt   R0,#0x00000004
        blt     erase_set_sectors
        cmp     R0,#0x00020000  ; B0F3
        movlt   R0,#0x00000008
        blt     erase_set_sectors
        cmp     R0,#0x00030000  ; B0F4
        movlt   R0,#0x00000010
        blt     erase_set_sectors
        cmp     R0,#0x00040000  ; B0F5
        movlt   R0,#0x00000020
        blt     erase_set_sectors
        cmp     R0,#0x000C8000  ; B1F0
        movlt   R0,#0x00010000
        blt     erase_set_sectors
        cmp     R0,#0x000D0000  ; B1F1
        movlt   R0,#0x00020000
        blt     erase_set_sectors
        cmp     R0,#0x000E8000  ; B2F0
        movlt   R0,#0x00100000
        blt     erase_set_sectors
        cmp     R0,#0x000F0000  ; B2F1
        movlt   R0,#0x00200000
        blt     erase_set_sectors
        mov     R0,#0xA5        ; else, no erase
        mov     R15,R14
erase_set_sectors
        str     R0, [R6,#0x04]

        mov     R6,#0x100000
        ldr     R0,[R6,#0x00]   ; Operation start
        orr     R0,R0,#0x80000000
        str     R0,[R6,#0x00]

        mov     R6,R14          ; save link for call below
        bl      wait_for_ready  ; wait for erase to finish
        bl      check_status    ; check Flash status and return in R0
        mov     R15,R6          ; Return with code in R0 and Z bit

;* -----------------------------------------------------------------------
;  check_status - check to see if operation completed OK.
;
;  Notes:
;     - this reads the error status of the Flash and returns in R0.
;
;  Input/Output:
;     - In: R1=Base of Flash
;     - Out:R0=Status (0=OK, else failed)
;     - Scratch: R7
;  ----------------------------------------------------------------------- */

check_status
        mov     R7,#0x100000
        ldr     R0,[R7,#0x00]   ; get status
        mov     R7,#0x000F0000
        and     R0,R0,R7
        mov     R15,R14         ; Return with code in R0

;* -----------------------------------------------------------------------
;  wait_for_ready - wait for Flash to complete an operation.
;
;  Notes:
;     - this reads the status of the Flash until done.
;
;  Input/Output:
;     - In: R1=Base of Flash
;     - Scratch: R0,R7
;  ----------------------------------------------------------------------- */

wait_for_ready
        mov     R7,#0x100000
        ldr     R0,[R7,#0x00]   ; get status
        mov     R7,#0x0000000E
        add     R7,R7,#0x3E000000
        and     R0,R0,R7
        mov     R7,#0x00000000

        cmp     R0,R7           ; read back as 0x00 means OK
        bne     wait_for_ready  ; no, wait some more
        mov     R15,R14         ; Return

        END