rt-thread/bsp/loongson/ls1cdev/drivers/selfboot_gcc.S

/*
 * Copyright (c) 2006-2019, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Origin Authors: Loongson Technology Corporation Limited,
 * caogos <1207280597@qq.com>, Jiaxun Yang <jiaxun.yang@flygoat.com>,
 *
 * Also thanks to Liu Shiwei <liushiwei@gmail.com> and other Loongson
 * Community developers.
 *
 * Change Logs:
 * Date           Author       Notes
 * 2019-12-04     Jiaxun Yang  Initial version
 */

#include <rtconfig.h>

#ifdef RT_USING_SELF_BOOT

#ifndef __ASSEMBLY__
#define __ASSEMBLY__
#endif

#include <mips.h>
#include "selfboot.h"
#include "ls1c.h"
#include "cache.h"

/*
 *   Register usage:
 *
 *	s0	link versus load offset, used to relocate absolute adresses.
 *	s1	free
 *	s2	memory size
 *	s3	free
 *	s4	free
 *	s5	dbg
 *	s6	sdCfg
 *	s7	rasave
 *	s8	free
 */

#define tmpsize		s1
#define msize		s2
#define bonito		s4
#define dbg			s5
#define sdCfg		s6


/* Macros */
#ifdef RT_SELF_BOOT_DEBUG
#define	PRINTSTR(str) \
    .pushsection .selfboot_data; .align 4; 98: .asciz str; .popsection; la a0, 98b; bal stringserial; nop
#else
#define PRINTSTR(x)
#endif

#define	DELAY(count)	\
    li v0, count;	\
99:			\
    bnez	v0, 99b;\
    addiu	v0, -1

.section ".selfboot", "ax"
.set	noreorder
.set	mips32
.globl	_start
.extern	start
_start:

/* NMI/Reset vector starts here*/
  mtc0  zero, CP0_STATUS /* set cp0 status register to zero */
  mtc0  zero, CP0_CAUSE /* set cp0 cause register to zero */

  li  t0, ST0_BEV /* set exception vector to in flash location */
  mtc0 t0, CP0_STATUS

  /* Speed up SPI reading */
  li  t0, 0xbfe80000 /* load SPI0 controler base address to t0 */
  li  t1, 0x17 /* load "div 4, fast_read + burst_en + memory_en double I/O" to
                * to t0 for write, not all the flash chips support this mode */
  sb  t1, 0x4(t0) /* set sfc_param register */
  li  t1, 0x05
  sb  t1, 0x6(t0) /* set sfc_timing register */

  bal	locate			/* branch out of vector and get current address to ra */
    nop

/* in-flash exception vectors start here */
/* save the exception types to a0 and print out PANIC message in exc_common */
#define EXC_TLB_REFILL 0x0
#define EXC_CACHE_ERR	0x1
#define EXC_GEN	0x2
#define EXC_INT	0x3

.org 0x200 /* 0xbfc00200 TLB_REFILL exception */
  li a0, EXC_TLB_REFILL
  b exc_common
  nop

.org 0x300 /* 0xbfc00300 Cache Error exception */
  li a0, EXC_CACHE_ERR
  b exc_common
  nop

.org 0x380 /* 0xbfc00300 General exception */
  li	a0,EXC_GEN
  b exc_common
  nop

.org 0x400 /* 0xbfc00400 Interrupt exception */
  li a0, EXC_INT
  b exc_common
  nop

1: /* impossible to reach here, so make a dead loop */
  b 1b
  nop

exc_common: /* try one cause and pass to next */
  li	s1, EXC_TLB_REFILL
  bne a0, s1, 1f
  nop
  PRINTSTR("\r\nEARLY_PANIC: Exception TLB Refill")
  b print_cause
  nop
1:
  li	s1, EXC_CACHE_ERR
  bne a0, s1, 1f
  nop
  PRINTSTR("\r\nEARLY_PANIC: CACHE Error: ")
  mfc0 a0, CP0_CACHEERR
  bal hexserial
  nop
  b print_cause
  nop
1:
  li	s1, EXC_GEN
  bne a0, s1, 1f
  nop
  PRINTSTR("\r\nEARLY_PANIC: General Exception")
  b print_cause
  nop
1:
  li	s1, EXC_INT
  bne a0, s1, print_cause /* if all exceptions in a0 not reached,
                          * print_cause directly*/
  nop
  PRINTSTR("\r\nEARLY_PANIC: Interrupt Exception")
print_cause:
  PRINTSTR("\r\nCAUSE=")
  mfc0	a0, CP0_CAUSE
  bal	hexserial
  nop

  PRINTSTR("\r\nSTATUS=")
  mfc0	a0, CP0_STATUS
  bal	hexserial
  nop

  PRINTSTR("\r\nERRORPC=")
  mfc0	a0, CP0_ERROREPC
  bal	hexserial
  nop

  PRINTSTR("\r\nEPC=")
  mfc0	a0, CP0_EPC
  bal	hexserial
  nop

  PRINTSTR("\r\nBADADDR=")
  mfc0	a0, CP0_BADVADDR
  bal	hexserial
  nop

  PRINTSTR("\r\nEARLY: LOOP! Noting to do")
1: /* Make a dead loop here, wait user to reset the MCU */
  b 1b
  nop

/* locate here, continue the start progress */

locate:
  /* fix the absolute address by ra */
  la  s0, start /* s0 = start */
  subu  s0, ra, s0 /* s0 = ra - s0 */
  and s0, 0xffff0000 /* s0 = s0 & 0xffff0000 */

  li	t0, 0xbfe78030 /* load PLL/SDRAM freq config register base to t0 */
  li	t2, (0x80000008 | (PLL_MULT << 8) | (0x3 << 2) | SDRAM_DIV) /* Set PLL
                                                                  * MULT and PLL DIV */
  li	t3, (0x00008003 | (CPU_DIV << 8)) /* set CPU DEV */

  li	t1, 0x2
    sw	t1, 0x4(t0) /* disable CPU_DIV_VALID firstly for adjustment */
    sw	t2, 0x0(t0) /* write START_FREQ */
    sw	t3, 0x4(t0) /* write CLK_DIV_PARAM */

/* start to initialize debug uart port */
  la	v0, LS1C_UART2_BASE /* load UART2 base to v0, only UART2 can be debug port */
1:
    li	v1, FIFO_ENABLE|FIFO_RCV_RST|FIFO_XMT_RST|FIFO_TRIGGER_4 /* clear Rx,Tx FIFO
                                                                * declear 4 bit int trigger */
    sb	v1, LS1C_UART_FCR_OFFSET(v0) /* write FCR (FIFO control register) */
    li	v1, CFCR_DLAB /* reach freq div register */
    sb	v1, LS1C_UART_LCR_OFFSET(v0) /* write LCR (Line control register)*/
    /* Set UART2 reuse with GPIO36,37*/
    li		a0, LS1C_CBUS_FIRST1 /* load CBUS_FIRST1 offset to a0 */
    lw		a1, 0x10(a0) /* load value from CBUS_SECOND1 to a1 */
    ori		a1, 0x30 /* a1 |= 0x30, GPIO36,37 as secondary function */
    sw		a1, 0x10(a0) /* write back modified CBUS_SECOND1 from a1 */
  /* Caculate PLL and bit rate */
    li		a0, 0xbfe78030 /* load START_FREQ register address to a0 */
    lw		a1, 0(a0) /* load value from START_FREQ to a1*/
    srl		a1, 8 /* a1 >>= 8 */
    andi	a1, 0xff /* a1 &= 0xff, as a1=PLL_MULT */
    li		a2, APB_CLK /* a2 = APB_CLK = 24Mhz (External Clock Freq) */
    srl		a2, 2 /* a2 = a2 >> 2 = APB_CLK/4 */
    multu	a1, a2 /* hilo = a1 * a2 = PLL_MULT * APB_CLK /4 */
    mflo	v1 /* v1 = lo. put low 32 bit of a1 * a2 to v1 as PLL freq */
    /* Determine if we need to devide the clock */
    lw		a1, 4(a0) /* load value frm CLK_DIV_PARAM to a1 */
    andi	a2, a1, DIV_CPU_SEL /* a2 = a1 & DIV_CPU_SEL, if CPU_SEL=1, devide the clock,
                            * if CPU_SEL=0, bypass the clock */
    bnez	a2, 1f /* if (a2 != 0), branch to next tag 1 */
    nop
    li		v1, APB_CLK /* v1 = APB_CLK */
    b		3f
    nop
1: /* Determine if the CPU_DIV is valid*/
    andi	a2, a1, DIV_CPU_EN /* a2 = a1 & DIV_CPU_EN */
    bnez	a2, 2f /* if (a2 != 0), branch to next tag 2 */
    nop
    srl		v1, 1 /* v1 >>= 1, so v1 = APB_CLK/4 * PLL_MULT/2 */
    b		3f
    nop
2: /* caculate CPU freq */
    andi	a1, DIV_CPU /* a1 &= DIV_CPU */
    srl		a1, DIV_CPU_SHIFT /* a1 >>= DIV_CPU_SHIFT */
    divu	v1, a1 /* lo = v1/a1, hi = v1 % a1 */
    mflo	v1 /* v1 = lo, CPU Freq */
3:
    li		a1, (16 * EARLY_DEBUG_BAUD) /* a1 = 16 * BIT RATE */
    divu	v1, v1, a1 /* v1 = v1 / a1 */
    srl     v1, 1  /* v1 >>= 1 */
    sb	v1, LS1C_UART_LSB_OFFSET(v0) /* write 8bit low into LSB */
    srl	v1, 8 /* v1 >>= 8 */
    sb	v1, LS1C_UART_MSB_OFFSET(v0) /* write 8bit low into MSB */

    li	v1, CFCR_8BITS /* 8n1, no check */
    sb	v1, LS1C_UART_LCR_OFFSET(v0) /* write to LCR (Line Control Register) */

#ifdef EARLY_DEBUG_UART_FLOW_CTRL
    li	v1, MCR_DTR|MCR_RTS /* valid DTR and RTS */
    sb	v1, LS1C_UART_MCR_OFFSET(v0) /* write to MCR (MODEM Control Register) */
#endif

    li	v1, 0x0 /* disable all the interruptions */
    sb	v1, LS1C_UART_IER_OFFSET(v0) /* write to IER (Interruptions Enable Registers) */

    PRINTSTR("\r\INFO: Loongson 1C300 Starting :) \r\n")

  /* disable all GPIOs for conflict functions */
  li a0,0xbfd00000
  sw zero,0x10c0(a0)	/* disable GPIO 0-31 */
  sw zero,0x10c4(a0)	/* disable GPIO 32-63 */
  sw zero,0x10c8(a0)	/* disable GPIO 64-95 */
  sw zero,0x10cc(a0)

  li t0, 0xffffffff
  sw t0, 0x10d0(a0)
  sw t0, 0x10d4(a0)
  sw t0, 0x10d8(a0)
  sw t0, 0x10dc(a0)

  sw t0, 0x10f0(a0)
  sw t0, 0x10f4(a0)
  sw t0, 0x10f8(a0)
  sw t0, 0x10fc(a0)

  PRINTSTR("\r\INFO: All GPIOs are disabled\r\n")

  /* SDRAM initialize starts here */

  li msize, MEM_SIZE

#ifdef EJTAG_SEL_AS_SDRAM_CS1
  li		a0, 0xbfd011c0
  lw		a1, 0x40(a0)
  ori	a1, 0x01
  sw		a1, 0x40(a0)
  PRINTSTR("\r\INFO: EJTAG_SEL PIN as SDRAM_CS1\r\n")
#endif

/*
* recommanded by user manual, we should write SD_CONFIG[31:0] first, then
* write SD_CONFIG[63:32]. Repeat writing for three times, valid the config in
* the last time.
*/

/* write first time */
li  	t1, 0xbfd00410 /* load SD_CONFIG[31:0] address to t1 */
li		a1, SD_PARA0 /* get the memory config from macro SD_PARA0 */
sw		a1, 0x0(t1) /* write to SD_CONFIG[31:0] */
li		a1, SD_PARA1
sw		a1, 0x4(t1) /* write to SD_CONFIG[63:32] with offset */
PRINTSTR("\r\INFO: SDRAM Config Pass1\r\n")

/* write second time,the same */
li		a1, SD_PARA0
sw		a1, 0x0(t1)
li		a1, SD_PARA1
sw		a1, 0x4(t1)
PRINTSTR("\r\INFO: SDRAM Config Pass2\r\n")

/* write third time, enable controller this time */
li		a1, SD_PARA0
sw		a1, 0x0(t1)
li		a1, SD_PARA1_EN /* enable it */
sw		a1, 0x4(t1)
PRINTSTR("\r\INFO: SDRAM initialize compeleted\r\n")


/* initialize cache */
bal     cache_init /* branch to cache_init */
nop

/* enable cache */
mfc0   a0, CP0_CONFIG /* load cp0 config to a0 */
and    a0, a0, ~((1<<12) | 7) /* a0 = a0 & ~((1<<12) | 7) */
or     a0, a0, 2 /* a0 |= 2 */
mtc0   a0, CP0_CONFIG /* write back to CP0 config */

/*
* relocate: copy selfboot code to memory in kseg0, fix PC and jump to kseg0.
* in order to speed up the copy progress, we will execute copy code in kseg0
*/

PRINTSTR("\r\INFO: Relocating")
la		t0, text_copy_start /* load the adress of start tag to t0 */
move		t2, t0
addu		t0, s0 /* correct t0 address in rom by s0 */
la		t1, text_copy_end

selfboot_copy_loop:
lw		v0, (t0) /* copy from memory address in t0 to register v0  */
sw		v0, (t2) /* write data in register v0 to memory address t0 */
addiu		t0, 0x4 /* t0 moves forward 4 bytes */
addiu		t2, 0x4 /* t2 moves forward 4 bytes */
ble		t2, t1, selfboot_copy_loop /* if t1 <= t2 loop to continue the copy */
nop

la		t0, text_copy_start /* load start address to t0 */
jr		t0 /* jump to 122 in kseg0 to start copy code progress */
nop

text_copy_start:
/* Copy code to memory*/
la		a0, start /* load address of start symbol to a0  */
addu		a1, a0, s0 /* correct a0 to address in flash */
la		a2, _edata /* load symbol _edata address to a2 */
subu	t1, a2, a0 /* t1 = a2 - a0, the space of text area */

move	t0, a0 /* the start address in ram */
move	t1, a1 /* the start address in rom */
move	t2, a2 /* the end address in rom (symbol _edata) */

/* copy text section */
1:
and	t3, t0, 0x0000ffff /* t3 = t0 & 0x0000ffff, get low 16 bit */
bnez	t3, 2f /* if t3 != 0, jump to next tag 2 */
nop
2:
lw		t3, 0(t1) /* copy 4 bit from memory address t1 to register t3 */
nop
sw		t3, 0(t0) /* copy 4 bit from register t3 to memory address in t0 */
addu	t0, 4 /* t0 move forward 4 bytes */
addu	t1, 4 /* t1 move forward 4 bytes */
bne	t2, t0, 1b /* if t2 != t0, branch to last tag 1 to continue copy */
nop
/* copy text section done. */

move	a0, msize  /* a0 = msize, will be passed to main */
srl	a0, 20 /* a0 >>= 20, convert to unit in MB */

/* execute main */
la		v0, _rtthread_entry /* load address of function main to v0 */
jalr	v0 /* call address in v0, congrats! all low_level things done!
          * switch brain out of assembly */
nop
text_copy_end: /* end of self-copy in memory */

loop: /* impossible to reach here, make a dead loop */
b	loop
nop

/* functions here */

LEAF(stringserial) /* print out the string in address passed in a0  */
    nop
    move	a2, ra  /* save the return address to a2 */
    addu	a1, a0, s0 /* correct the address in ROM */
    lbu	a0, 0(a1) /* read the first byte in memory address a1 to a0 */
1:
    beqz	a0, 2f /* if a0 == 0, jump to next tag 2, empty char */
    nop
    bal	tgt_putchar /* print a char */
    addiu	a1, 1 /* a1 += 1 move forward to next byte */
    b	1b /* branch to the last tag 1, continue */
    lbu	a0, 0(a1) /* load the next bit from address a1 to a0, in delay solt,
                * will be execuated before branch */
2:
    j	a2 /* return */
    nop
END(stringserial)


LEAF(hexserial) /* print out single hex char passed in register a0 */
    nop
    move	a2, ra /* move return address from ra to a2  */
    move	a1, a0 /* move hex char from register a0 to a1 */
    li	a3, 7 /* load 7 to a3 */
1:
    rol	a0, a1, 4 /* rotate left ward shift for 4 bit in a1 to a0 */
    move	a1, a0
    and	a0, 0xf
    la	v0, hexchar

.pushsection .selfboot_data
.align	4
hexchar:
        .ascii	"0123456789abcdef"
.popsection
.align	4

    addu	v0, s0
    addu	v0, a0
    bal	tgt_putchar
    lbu	a0, 0(v0)

    bnez	a3, 1b
    addu	a3, -1

    j	a2
    nop
END(hexserial)

LEAF(tgt_putchar) /* print out a char in a0 */
    la	v0, LS1C_UART2_BASE /* load UART register address to a0 */
    lbu	v1, LS1C_UART_LSR_OFFSET(v0) /* load value from LSR to v0 */
1:
    and	v1, LSR_TXRDY /* v1 &= LSR_TXRDY determine wether we can send by TFE bit */
    beqz	v1, 1b /* if (v1 == 0) jump to last 1 tag, waiting until TFE is 1 */
    lbu	v1, LS1C_UART_LSR_OFFSET(v0) /* load value from LSR to v0 again, in delay solt */

    sb	a0, LS1C_UART_DAT_OFFSET(v0) /* write a0 into DAT, send out */
    j	ra /*  */
    nop
END(tgt_putchar)

LEAF(CPU_SetSR) /* modify SR value, arg 1 = set bits, arg 2 = clear bits. */
    mfc0    v0, CP0_STATUS
    not v1, a1
    and v1, v0
    or  v1, a0
    mtc0    v1, CP0_STATUS
    nop
        nop
        nop
        nop
        nop
        nop
        nop
        nop
    j   ra
    nop
END(CPU_SetSR)

cache_init:
    move t1, ra
####part 2####
cache_detect_4way:
    mfc0	t4, CP0_CONFIG,1 /* move CP0 CONFIG to t4 */
    lui		v0, 0x7 /* v0 = 0x7 << 16 */
    and		v0, t4, v0 /* v0 = t4 & v0 */
    srl		t3, v0, 16 /* t3 = v0 >> 16  Icache组相联数 IA */

    li		t5, 0x800 		//32*64
    srl		v1, t4,22		//v1 = t4 >> 22
    andi	v1, 7			//Icache每路的组数 64x2^S IS
    sll		t5, v1			//InstCacheSetSize
    sll		t5, t3			//t5 InstCacheSize


    andi	v0, t4, 0x0380
    srl		t7, v0, 7		//DA

    li		t6, 0x800       // 32*64
    srl		v1, t4,13
    andi	v1, 7			//DS
    sll		t6, v1          // DataCacheSetSize
    sll		t6, t7          // t5 DataCacheSize

####part 3####
    lui		a0, 0x8000			//a0 = 0x8000 << 16
    addu	a1, $0, t5
    addu	a2, $0, t6
cache_init_d2way:
/* a0=0x80000000, a1=icache_size, a2=dcache_size */
/* a3, v0 and v1 used as local registers */
    mtc0	$0, CP0_TAGHI
    addu	v0, $0, a0 /* v0 = 0 + a0 */
    addu	v1, a0, a2 /* v1 = a0 + a2 */
1:	slt		a3, v0, v1 /* a3 = v0 < v1 ? 1 : 0 */
    beq		a3, $0, 1f /* if (a3 == 0) goto 1f */
    nop
    mtc0	$0, CP0_TAGLO
    cache	Index_Store_Tag_D, 0x0(v0) /* 1 way */
4:	beq		$0, $0, 1b
    addiu	v0, v0, 0x20
1:
cache_flush_i2way:
    addu	v0, $0, a0
    addu	v1, a0, a1
1:
    slt		a3, v0, v1
    beq		a3, $0, 1f
    nop
    cache	Index_Invalidate_I, 0x0(v0) /* 1 way */
4:
    beq		$0, $0, 1b
    addiu	v0, v0, 0x20
1:
cache_flush_d2way:
    addu	v0, $0, a0
    addu	v1, a0, a2
1:	slt		a3, v0, v1
    beq		a3, $0, 1f
    nop
    cache	Index_Writeback_Inv_D, 0x0(v0) /* 1 way */
4:	beq		$0, $0, 1b
    addiu	v0, v0, 0x20

1:
cache_init_finish:
    jr	t1
    nop
#endif