chadderz121 / bakingpi-www Goto Github PK

/******************************************************************************
*   systemTimer.s
*    by Alex Chadwick
*       System Timer Equates
*       by Exile In Paradise
*       The system timer runs at 1MHz, and just counts always.
******************************************************************************/

/*
 * Register equates for the System Timer
 */
.equ ST_CS, 0x20003000
.equ ST_CLO,0x20003004
.equ ST_CHI,0x20003008
.equ ST_C0, 0x2000300C
.equ ST_C1, 0x20003010
.equ ST_C2, 0x20003014
.equ ST_C3, 0x20003018

/* 
 * Masks for each bit of the System Timer Counter Status Register
 */
.equ MASK0,0b0000000000000001
.equ MASK1,0b0000000000000010
.equ MASK2,0b0000000000000100
.equ MASK3,0b0000000000001000

/*
 * Error return values for functions
 */
.equ ERR_INPUT1_OUT_OF_RANGE, -1
.equ ERR_INPUT2_OUT_OF_RANGE, -2
.equ ERR_INPUT3_OUT_OF_RANGE, -3
.equ ERR_INPUT4_OUT_OF_RANGE, -4

/*****************************************************************************
 *  systemTimer.s
 *  by Alex Chadwick
 *  SetCounterDelay(int counter,int delay)
 *  by Exile In Paradise
 *  The system timer runs at 1MHz, and just counts always.
 *****************************************************************************/

.include "systemTimer-equates.s"

/*****************************************************************************
 * SetCounterDelay - sets counter to an amount to wait for
 * r0 - counter to set 0 through 3 inclusive
 * r1 - amount of microseconds to delay (32-bit, 1-4294967296)
 * Destroys r0, r1, r2, r3
 * Alters ST_CS and ST_C0, ST_C1, ST_C2, OR ST_C3 registers
 * Returns nothing on success, ERR_INPUT1_OUT_OF_RANGE, ERR_INPUT2_OUT_OF_RANGE
 */
.global SetCounterDelay
SetCounterDelay:
    @ first, check our inputs are in range
    in_counter .req r0
    in_delay .req r1
    return .req r0
    cmp in_counter,#3               @ r0 (counter) must be 0 to 3 inclusive
    movhi return,#ERR_INPUT1_OUT_OF_RANGE
    movhi pc,lr             @ input 1 out of range, return from function
    cmp in_delay,#0         @ r1 (delay in microsecond) must be 1 or more
    moveq return,#ERR_INPUT2_OUT_OF_RANGE
    moveq pc,lr             @ input 2 out of range, return from function
    .unreq return           @ remove alias

    @ now setup the function
    push {lr}               @ save LR onto stack for later pop to PC
    counter .req r2         @ alias reg2 as "counter"
    delay .req r3           @ alias reg3 as "delay"
    mov counter,in_counter          @ save input r0 into scratch register
    mov delay,in_delay              @ save input r1 into scratch register
    .unreq in_counter       @ remove alias
    .unreq in_delay @ remove alias

    @ find which bit mask to write to clear specific counter status bit
    counterstatus .req r0
    cs_mask .req r1
    ldr counterstatus,=ST_CS                @ setup r0 for Counter Status register

    cmp counter,#0          @ do we need to clear counter 0?
    moveq cs_mask,#MASK0    @ setup mask for bit 0
    beq go_on$              @ branch to go on

    cmp counter,#1          @ do we need to clear counter 1? 
    moveq cs_mask,#MASK1    @ setup mask for bit 1
    beq go_on$              @ branch to go on

    cmp counter,#2          @ do we need to clear counter 2?
    moveq cs_mask,#MASK2    @ setup mask for bit 2
    beq go_on$              @ branch to go on

    cmp counter,#3          @ do we need to clear counter 3?
    mov cs_mask,#MASK3      @ setup mask for bit 3 (no moveq for last option)
    beq go_on$              @ fall through to go on
    pop {pc}                @ somehow we got here and should not have - bail

go_on$:     
    str cs_mask,[counterstatus]             @ write r1 mask to ST_CS to clear counter bit
    .unreq counterstatus
    .unreq cs_mask

    @ now to set timestamp to wait for
    counterlo .req r0
    counterhi .req r1
    delaytime .req r1
    ldr counterlo,=ST_CLO           @ set r0 to counter low address
    ldrd counterlo,counterhi,[counterlo]    @ get current 64-bit counter value into r1/r0
    add delaytime,counterlo,delay           @ add the desired delay to CLO, overwrite CHI
                            @ FIXME need carry compare to check for 32-bit rollover
    .unreq counterlo        @ clean up counterlo alias
    .unreq counterhi        @ clean up counterhi alias
    .unreq delay

    @ Now setup the counter register to wait for
    counterreg .req r0
    loopidx .req r3
    ldr counterreg,=ST_C0           @ load address of ST_C0 into register 0
    mov loopidx,#0          @ setup a loop counter for 0 to 3
counterLoop$:                       @ figure out correct address of counter to set
    cmp counter,loopidx             @ does loop number match counter we want?
    addlo counterreg,#4             @ add 4 to counter register address we care about
    addlo loopidx,#1                @ not counter we want, add to to check next counter
    blo counterLoop$                @ now loop to check again
    str delaytime,[counterreg]      @ store 32 bit time+delay to chosen count

    @ return from function call
    .unreq counterreg       @ clean up counterreg alias
    .unreq delaytime        @ clean up delaytime alias
    .unreq counter          @ clean up counter alias
    .unreq loopidx          @ clean up alias loopidx
    pop {pc}                @ pop link register from stack into pc register

/*****************************************************************************
 *  systemTimer.s
 *  by Alex Chadwick
 *  WaitCounter(int counter)
 *  by Exile In Paradise
 *  The system timer runs at 1MHz, and just counts always.
 *****************************************************************************/

.include "systemTimer-equates.s"

/*
 * WaitCounter waits until the System Timer Counter Status register shows a
 * preset counter has reached its timestamp and set the counter status high.
 * Inputs: r0 = counter to wait for
 * Returns: r0 = error if input out of range
 * Outputs: none
 * Uses: ST_CS
 * Destroys: r0, r1, r2, r3
 */

.global WaitCounter
WaitCounter:
    @ check inputs
    in_counter .req r0
    retval .req r0
    cmp in_counter,#3               @ check which counter number we were asked to wait on
    movhi retval,#ERR_INPUT1_OUT_OF_RANGE
    movhi pc,lr             @ return if requested counter to wait on is too high
    .unreq retval           

    @ setup the function
    push {lr}               @ save the return link register on the stack
    counter .req r2         @ alias register 2 as "counter" 
    mov counter,in_counter  @ move input register 0 "counter" to alias register
    .unreq in_counter

    @ Start the wait polling loop
    csreg .req r0
    counterstatus .req r1
    csmask .req r3
    loop$: 

            ldr csreg,=ST_CS                @ load counter status address into r0
            ldr counterstatus,[csreg]       @ load counter status value into r1 

            cmp counter,#0          @ check if we are waiting for counter 0
            moveq csmask,#MASK0     
            beq test$               @ if matches, exit polling loop

            cmp counter,#1          @ check if we are waiting for counter 1
            moveq csmask,#MASK1     
            beq test$               @ if matches, exit polling loop

            cmp counter,#2          @ check if we are waiting for counter 2
            moveq csmask,#MASK2             @ if yes, check bitmask for counter 2 against r1
            beq test$               @ if matches, exit polling loop 

            @cmp counter,#3         @ check if we are waiting for counter 3
            moveq csmask,#MASK3             @ if yes, check bitmask for counter 3 against r1
            @beq test$              @ if matches, exit polling loop 

            b loop$                 @ no matches in counter status, go wait more

    @ exit polling loop and return
    test$: 
            tst counterstatus,csmask
            beq loop$
    @ if equal, timer done, exit
    .unreq counter
    .unreq csreg
    .unreq csmask
    .unreq counterstatus
    pop {pc}                @ return from function call

/*****************************************************************************
 *  main.s
 *   by Alex Chadwick
 *  Modified to use SetCounterDelay() and WaitCounter()
 *  by Exile In Paradise
 *  A sample assembly code implementation of the ok04 operating system, that
 *  simply turns the OK LED on and off repeatedly, synchronising using the
 *  system timer.
 *  Sections changed since ok03.s are marked with NEW.
 *
 *  main.s contains the main operating system, and IVT code.
 *****************************************************************************/

/*
* .globl is a directive to our assembler, that tells it to export this symbol
* to the elf file. Convention dictates that the symbol _start is used for the
* entry point, so this all has the net effect of setting the entry point here.
* Ultimately, this is useless as the elf itself is not used in the final
* result, and so the entry point really doesn't matter, but it aids clarity,
* allows simulators to run the elf, and also stops us getting a linker warning
* about having no entry point.
*/
.section .init
.globl _start
_start:

/*  
* Branch to the actual main code.
*/  
b main

/*  
* This command tells the assembler to put this code with the rest.
*/  
.section .text

/*
* main is what we shall call our main operating system method. It never
* returns, and takes no parameters.
* C++ Signature: void main(void)
*/
main:

/*
* Set the stack point to 0x8000.
*/
mov sp,#0x8000

/* 
* Use our new SetGpioFunction function to set the function of GPIO port 16 (OK
* LED) to 001 (binary)
*/
mov r0,#16
mov r1,#1
bl SetGpioFunction

/*
* Use our new SetGpio function to set GPIO 16 to low, causing the LED to turn
* on.
*/
loop$:
mov r0,#16
mov r1,#0
bl SetGpio 

/* NEW
* We wait using our new method. We use a value of 100000 micro seconds for the
* delay causing the light to flash 5 times per second.
*/
mov r0,#0   @ use ST_C0 counter 0
ldr r1,=100000      @ delay for 100,000 microseconds
bl SetCounterDelay
mov r0,#0   @ use ST_C0 counter 0 to wait on
bl WaitCounter

/*
* Use our new SetGpio function to set GPIO 16 to high, causing the LED to turn
* off.
*/
mov r0,#16
mov r1,#1
bl SetGpio

/* NEW
* We wait using our new method. We use a value of 100000 micro seconds for the
* delay causing the light to flash 5 times per second.
*/
mov r0,#0   @ use ST_C0 counter 0
ldr r1,=100000      @ delay for 100,000 microseconds
bl SetCounterDelay
mov r0,#0   @ use ST_C0 counter 0 to wait on
bl WaitCounter

/*
* Loop over this process forevermore
*/
b loop$

# Disable device_tree so we can see the ATAGS
device_tree=

.globl GetSystemTimerBase
GetSystemTimerBase: 
ldr r0,=0x20003000
mov pc,lr

.globl GetTimeStamp
GetTimeStamp:
push {lr}
bl GetSystemTimerBase
ldrd r0,r1,[r0,#4]
pop {pc}
delay .req r2
mov delay,r0
push {lr}
bl GetTimeStamp
start .req r3
mov start,r0
loop$:
bl GetTimeStamp
elapsed .req r1
sub elapsed,r0,start
cmp elapsed,delay
.unreq elapsed
bls loop$
.unreq delay
.unreq start
pop {pc}

.globl GetSystemTimerBase
GetSystemTimerBase: 
ldr r0,=0x20003000
mov pc,lr

.globl GetTimeStamp
GetTimeStamp:
push {lr}
bl GetSystemTimerBase
ldrd r0,r1,[r0,#4]
pop {pc}

.globl Wait
Wait:
delay .req r2
mov delay,r0
push {lr}
bl GetTimeStamp
start .req r3
mov start,r0
loop$:
bl GetTimeStamp
elapsed .req r1
sub elapsed,r0,start
cmp elapsed,delay
.unreq elapsed
bls loop$
.unreq delay
.unreq start
pop {pc}

fbInfoAddr .req r3

mov result,fbInfoAddr
pop {pc}
.unreq result
.unreq fbInfoAddr

/******************************************************************************
*   main.s
*    by Alex Chadwick
*
*   A sample assembly code implementation of the ok02 operating system, that 
*   simply turns the OK LED on and off repeatedly.
*   Changes since OK01 are marked with NEW.
******************************************************************************/

/*
* .section is a directive to our assembler telling it to place this code first.
* .globl is a directive to our assembler, that tells it to export this symbol
* to the elf file. Convention dictates that the symbol _start is used for the 
* entry point, so this all has the net effect of setting the entry point here.
* Ultimately, this is useless as the elf itself is not used in the final 
* result, and so the entry point really doesn't matter, but it aids clarity,
* allows simulators to run the elf, and also stops us getting a linker warning
* about having no entry point. 
*/
.section .init
.globl _start
_start:

/* 
* This command loads the physical address of the GPIO region into r0.
*/
ldr r0,=0x3F200000 /* NEW */

/*
* Our register use is as follows:
* r0=0x3F200000 the address of the GPIO region.
* r1=1 << 21    a number with bits 21-23 set to 001 to put into the GPFSEL4 NEW
*               function select to enable output to GPIO 47. NEW 
* then
* r1=1 << 15    a number with bit 15 high, so we can communicate with GPIO 47. NEW
* r2=0x003F0000 a number that will take a noticeable duration for the processor 
*               to decrement to 0, allowing us to create a delay.
*/
mov r1,#1
lsl r1,#21 /* NEW GPFSEL4 bit 21 to enable GPIO47 for out */

/*
* Set the GPIO function select.
*/
str r1,[r0,#0x10] /* NEW GPFSEL4 instead */

/* 
* Set the 15th bit of r1.
*/
mov r1,#1
lsl r1,#15 /* NEW we want 15th bit for GPSET1 and GPCLR0 */

/* NEW
* Label the next line loop$ for the infinite looping
*/
loop$: 

/*
* Set GPIO 47 to low, causing the LED to turn on.
*/
str r1,[r0,#0x20] /* NEW GPSET1 instead of GPSET0 */

/* NEW
* Now, to create a delay, we busy the processor on a pointless quest to 
* decrement the number 0x3F0000 to 0!
*/
mov r2,#0x3F0000
wait1$:
    sub r2,#1
    cmp r2,#0
    bne wait1$

/* NEW
* Set GPIO 47 to high, causing the LED to turn off.
*/
str r1,[r0,#0x2C] /* NEW GPCLR1 instead of GPCLR0 */

/* NEW
* Wait once more.
*/
mov r2,#0x3F0000
wait2$:
    sub r2,#1
    cmp r2,#0
    bne wait2$

/*
* Loop over this process forevermore
*/
b loop$

build/output.elf:     file format elf32-littlearm


Disassembly of section .init:

00008000 <_start>:
    8000:   e59f003c    ldr r0, [pc, #60]   ; 8044 <wait2$+0x10>
    8004:   e3a01001    mov r1, #1
    8008:   e1a01a81    lsl r1, r1, #21
    800c:   e5801010    str r1, [r0, #16]
    8010:   e3a01001    mov r1, #1
    8014:   e1a01781    lsl r1, r1, #15

00008018 <loop$>:
    8018:   e5801020    str r1, [r0, #32]
    801c:   e3a0283f    mov r2, #4128768    ; 0x3f0000

00008020 <wait1$>:
    8020:   e2422001    sub r2, r2, #1
    8024:   e3520000    cmp r2, #0
    8028:   1afffffc    bne 8020 <wait1$>
    802c:   e580102c    str r1, [r0, #44]   ; 0x2c
    8030:   e3a0283f    mov r2, #4128768    ; 0x3f0000

00008034 <wait2$>:
    8034:   e2422001    sub r2, r2, #1
    8038:   e3520000    cmp r2, #0
    803c:   1afffffc    bne 8034 <wait2$>
    8040:   eafffff4    b   8018 <loop$>
    8044:   3f200000    .word   0x3f200000