f_intel_arm.s

realview22.rar

; ============================================================================
; F_INTEL_ARM - Flash programming algorithm for Intel Flash 
; (Boot block style including block lock/unlock)
;
; Library Name: Included into container .s file.
;
; Module Name:  F_INTEL_ARM.S
; Module Descr: Flash programming for Intel Boot block Flash including block lock
; Creation Date:2003
; Author:       Nick Milner
;
; THIS INFORMATION IS PROPRIETARY TO
; ARM
; 110 Fulbourn Road
; Cambridge
; CB1 9NJ
; UK
;
; Revisions of F_INTEL_ARM.S: (latest revision on top)
; #.#  Name  Date      Description
; ---  ----- --------  -----------------------------------------------------
;
; 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                                            */
;************************************************************************/

        IF              WIDTH=1
          MACRO
           STORE        $p1,$p2,$p3
            IF "$p3" = ""
             strb       $p1,$p2
            ELSE
             strb       $p1,$p2,$p3
            ENDIF
          MEND
          MACRO
           LOAD         $p1,$p2,$p3
            IF "$p3" = ""
             ldrb       $p1,$p2
            ELSE
             ldrb       $p1,$p2,$p3
            ENDIF
          MEND
        ENDIF

        IF              WIDTH=2
          MACRO
           STORE        $p1,$p2,$p3=0
            IF "$p3" = ""
             strh       $p1,$p2
            ELSE
             strh       $p1,$p2,$p3
            ENDIF
          MEND
          MACRO
           LOAD         $p1,$p2,$p3=0
            IF "$p3" = ""
             ldrh       $p1,$p2
            ELSE
             ldrh       $p1,$p2,$p3
            ENDIF
          MEND
        ENDIF

        IF              WIDTH=4
          MACRO
           STORE        $p1,$p2,$p3=0
            IF "$p3" = ""
             str        $p1,$p2
            ELSE
             str        $p1,$p2,$p3
            ENDIF
          MEND
          MACRO
           LOAD         $p1,$p2,$p3=0
            IF "$p3" = ""
             ldr        $p1,$p2
            ELSE
             ldr        $p1,$p2,$p3
            ENDIF
          MEND
        ENDIF

        IF :DEF: P_WIDTH
          IF P_WIDTH > 1
            MACRO
              EXPAND    $p1
                add $p1, $p1, $p1, lsl #16
                IF P_WIDTH=4
                  add $p1, $p1, $p1, lsl #8
                ENDIF
            MEND
          ENDIF
        ELSE
          MACRO
            EXPAND      $p1
          MEND
        ENDIF

;************************************************************************/
;* 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
;           R3=Size of blocks (for iterate)
;     - 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
;  ----------------------------------------------------------------------- */

FLASH_write_erase
        bl      erase_block     ; erase block in R1
        bne     flash_exit      ; failed on this one
FLASH_write
        
        bl      block_unlock    ; Unlock block for writing
        add     R4,R4,R1        ; compute start address
        
        mov     R6,#0x40        ; program initiate msg
        EXPAND  R6

write_loop
        LOAD    R7,[R5],#WIDTH  ; load first value from buffer then inc
        STORE   R6,[R4]         ; program initiate
        STORE   R7,[R4],#WIDTH  ; write value desired then inc
        bl      wait_for_ready  ; wait for Flash to finish write

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