Exynos4412裸机开发系列教程－－启动流程

最新推荐文章于 2024-03-07 18:48:24 发布

QQ8192542

最新推荐文章于 2024-03-07 18:48:24 发布

阅读量5.9k

点赞数 5

分类专栏： Exynos4412 文章标签： x4412 exynos4412 exynos4 裸机

本文链接：https://blog.csdn.net/obobodog/article/details/38582285

版权

Exynos4412 专栏收录该内容

5 篇文章 1 订阅

订阅专栏

看过前两篇教程的朋友，发现裸机开发怎么的如此简单，从这篇文章开始，我们来的有点难度的，启动流程。这个可以说是整个裸机开发的核心了，如果这一步无法跨越，您的一颗LED灯也点不亮，当然，如果您跨越了这一步，那么神马裸机开发都是一小点心而已。好，闲话少说，干货拿来。

在Exynos4412上电后，其内部的IROM会首先运行，下面是一张IROM运行流程图：

由流程图可以看出，首先关闭看门狗，关闭中断及MMU，关闭数据缓存，打开指令缓存，清除TLB，然后将其他核进入IDLE模式，只留CPU0，这里有了第一个跳转分支，IROM判断当前启动模式，是冷启动还是唤醒，如果是唤醒模式，那么就是直接跳转到BL1，在BL1里面我们会再次判断是否是唤醒模式，如果是就直接跳转到唤醒函数，一般都是linux内核的唤醒句柄。当然在裸机里都是冷启动的哈，休眠唤醒一般是不需要关注的，当然如果你的裸机程序需要支持休眠唤醒，就需要增加相应的代码了。

好了，继续我们的冷启动，设置IRQ及SVC模式的栈空间，这个时间，栈地址是其内部的一片IRAM，这小片RAM是IROM运行的外部随机存储器，没有这片小内存，IROM是无法运行的。接下了就是初始化IROM里面所使用的各种变量，初始化只读数据段，未初始化数据段清零，导出部分核心函数，这个函数可以在BL1中使用，获取当前复位的状态，设置系统时钟分频，获取OM管脚配置模式，这里可以从多种外设启动，具体启动模式如下表:

我们整个逻机教程都是从外部SD卡启动的，根据OM启动模式，从相应的存储器拷贝前8K代码，拷贝失败的话，系统就宕机了，只能复位重启了，如果拷贝成功，就验证校验和，BL1的前16个字节就是提供给IROM用来标识BL1相关信息的，具体信息如下：

/*
 * bl1 header infomation for irom
 *
 * 0x0 - bl1 size
 * 0x4 - reserved (should be 0)
 * 0x8 - check sum
 * 0xc - reserved (should be 0)
 */
	.word 0x2000
	.word 0x0
	.word 0x0
	.word 0x0

首先是描述BL1的大小，然后还有一个BL1的校验和，那我们怎么知道BL1的校验和呢，这个是在编译生成最终的二进制文件后，通过mk4412程序制作的，参考源码包里已经提供了相应的制作工具，可直接使用。

那拷贝的前8K代码，究竟从SD里的哪里开始拷贝呢，这里有个图可以参考，需要注意的是，拷贝是从第一个扇区开始，前面有一个扇区保留，每个扇区512字节，如果有同学对DOS分区表有过研究，就能明白其中的道理了，第一个扇区是分区表的配置区，一个磁盘里最多的４个主分区就是在这里配置的，当然逻辑扇区可以指定到其他位置。

IROM计算校验和且验证通过后并解密BL1成功后就可以跳转到BL1了，至此IROM已执行完备，权限已交由BL1了，补充说明一下，解密BL1是加密模式启动时才需要的，非加密模式启动是无需解密BL1的。

BL1就是我们可以控制编写的代码，但是对于samsung官方的uboot，这个BL1是不提供源码的，只提供一个bin文件，原因嘛，就是这个BL1是加密启动的，没关系，没有我们可以自己写个BL1,一样实现他的功能。

首先，填充16个字节用于后期制作校验和信息，然后就是标准的ARM异常向量表：

/*
 * bl1 header infomation for irom
 */
	.word 0x2000
	.word 0x0
	.word 0x0
	.word 0x0

	.global	_start
_start:

/* 0x00: reset */
	b	reset

/* 0x04: undefined instruction exception */
	ldr	pc, _undefined_instruction

/* 0x08: software interrupt exception */
	ldr	pc, _software_interrupt

/* 0x0c: prefetch abort */
	ldr	pc, _prefetch_abort

/* 0x10: data access memory abort */
	ldr	pc, _data_abort

/* 0x14: not used */
	ldr	pc, _not_used

/* 0x18: interrupt request exception */
	ldr	pc, _irq

/* 0x1c: fast interrupt request exception */
	ldr	pc, _fiq


_undefined_instruction:
	.long undefined_instruction
_software_interrupt:
	.long software_interrupt
_prefetch_abort:
	.long prefetch_abort
_data_abort:
	.long data_abort
_not_used:
	.long not_used
_irq:
	.long irq
_fiq:
	.long fiq

复位向量入口，就是我们开始的第一句代码，关闭看门狗，其实这个IROM已经实现了，但再做一遍也不为多，对吧，其实对于健壮的代码本质上就是不相信任何前提条件，都是自给自足的。

	/* Disable watchdog */
	ldr	r0, =0x10060000
	mov	r1, #0
	str	r1, [r0]

再进入SVC模式，打开NEON及VFP指令支持，关闭MMU，初始化cache等等，这些跟IROM里面做的类似。

	/* Set the cpu to supervisor mode */
	mrs	r0, cpsr
	bic	r0, r0, #0x1f
	orr	r0, r0, #0xd3
	msr	cpsr, r0

	/* Enable NEON & VFP unit */
	mrc p15, #0, r1, c1, c0, #2
	orr r1, r1, #(0xf << 20)
	mcr p15, #0, r1, c1, c0, #2
	mov r1, #0
	mcr p15, #0, r1, c7, c5, #4
	mov r0, #0x40000000
	fmxr fpexc, r0

	/* Cache init */
	mrc	p15, 0, r0, c0, c0, 0		/* read main ID register */
	and	r1, r0, #0x00f00000			/* variant */
	and	r2, r0, #0x0000000f			/* revision */
	orr	r2, r2, r1, lsr #20-4		/* combine variant and revision */
	cmp	r2, #0x30
	mrceq	p15, 0, r0, c1, c0, 1	/* read ACTLR */
	orreq	r0, r0, #0x6			/* Enable DP1(2), DP2(1) */
	mcreq	p15, 0, r0, c1, c0, 1	/* write ACTLR */

	/* Invalidate L1 I/D */
	mov	r0, #0						/* set up for MCR */
	mcr	p15, 0, r0, c8, c7, 0		/* invalidate TLBs */
	mcr	p15, 0, r0, c7, c5, 0		/* invalidate icache */

	/* Disable mmu stuff and caches */
	mrc	p15, 0, r0, c1, c0, 0
	bic	r0, r0, #0x00002000			/* clear bits 13 (--v-) */
	bic	r0, r0, #0x00000007			/* clear bits 2:0 (-cam) */
	orr	r0, r0, #0x00000002			/* set bit 1 (--a-) align */
	orr	r0, r0, #0x00000800			/* set bit 12 (z---) btb */
	mcr	p15, 0, r0, c1, c0, 0

下面就是一些初始化代码，比如电源自锁，初始化时钟，初始化外部DDR,这些就不做细节分析了，可以参考源码，自行阅读。

接下来就是比较关键的自拷贝了，这里使用了IROM里的从外部SD卡拷贝到内存的函数，IROM里其实提供了一系列的从各种外部存储器拷贝到内存的方法

	/* copyself to ram using irom */
	adr	r0, _start
	ldr r1, =_start
	cmp	r0, r1
	beq	have_copyed
	bl	irom_copyself
have_copyed:
	nop

其中irom_copyself函数是用C实现的，代码如下：

extern u8_t	__text_start[];
extern u8_t __text_end[];
extern u8_t __data_shadow_start[];
extern u8_t __data_shadow_end[];
extern u8_t __data_start[];
extern u8_t __data_end[];
extern u8_t __bss_start[];
extern u8_t __bss_end[];
extern u8_t __heap_start[];
extern u8_t __heap_end[];
extern u8_t __stack_start[];
extern u8_t __stack_end[];

#define irom_sdmmc_to_mem(sector, count, mem)		\
		(((u32_t(*)(u32_t, u32_t, u32_t *))(*((u32_t *)(0x02020030))))(sector, count, mem))

/*
 * read a 32-bits value from register.
 */
static u32_t reg_read(u32_t addr)
{
	return( *((volatile u32_t *)(addr)) );
}

/*
 * only support irom booting.
 */
void irom_copyself(void)
{
	u32_t om;
	u32_t * mem;
	u32_t size;

	/*
	 * read om register, om[5..1]
	 */
	om = (u32_t)((reg_read(EXYNOS4412_PMU_OM_STAT) >> 1) & 0x1f);

	/* SDMMC CH2 */
	if(om == 0x2)
	{
		/*
		 * the xboot's memory base address.
		 */
		mem = (u32_t *)__text_start;

		/*
		 * the size which will be copyed, the 'size' is
		 * 1 : 256KB, 2 : 512KB, 3 : 768KB, 4 : 1024KB ...
		 */
		size = (__data_shadow_end - __text_start + 0x00040000) >> 18;

		/*
		 * how many blocks the 'size' is , 512 bytes per block.
		 * size * 256 *1024 / 512 = size * 2^9 = size << 9
		 */
		size = size << 9;

		/*
		 * copy xboot to memory from sdmmc ch2.
		 */
		irom_sdmmc_to_mem(1, size, mem);
	}

	/* eMMC43 CH0 */
	else if(om == 0x3)
	{

	}

	/* eMMC44 CH4 */
	else if(om == 0x4)
	{

	}

	/* NAND 512B 8ECC */
	else if(om == 0x8)
	{

	}

	/* NAND 2KB OVER */
	else if(om == 0x9)
	{

	}

	/*=============*/
	/* eMMC43 CH0 */
	else if(om == 0x13)
	{

	}

	/* eMMC44 CH4 */
	else if(om == 0x14)
	{

	}

	/* NAND 512B 8ECC */
	else if(om == 0x18)
	{

	}

	/* NAND 2KB OVER */
	else if(om == 0x19)
	{

	}

	/* Not support */
	else
	{
		return;
	}
}

这个函数的实现千万不能使用switch case语句，因为这条语句很有可能会编译成跳转表，而现在C语言环境还未完全准备起来，只能使用局部变量以及用if elseif来代替。

这里有个define，将某格地址转化为函数的指针，然后执行，这个其实就是IROM里面导出的函数了。下面是一组IROM导出的函数表，可以参考：

自拷贝完成后，我们就需要初始化最终的栈空间，初始化已初始化数据段，将未初始化数据段清零。

	/* initialize stacks */
	bl	init_stacks

	/* copy shadow of data section */
copy_shadow_data:
	ldr	r0, _data_shadow_start
	ldr	r1, _data_start
	ldr	r2, _data_shadow_end
	bl	mem_copy

	/* clear bss section */
clear_bss:
	ldr	r0, _bss_start
	ldr	r1, _bss_end
	mov r2, #0x00000000
	bl	mem_clear

/*
 * initialize stacks
 */
init_stacks:
	mrs	r0, cpsr
	bic	r0, r0, #MODE_MASK | NO_INT
	orr	r1, r0, #UDF_MODE
	msr	cpsr_cxsf, r1
	ldr	sp, _stack_und_end

	bic	r0, r0, #MODE_MASK | NO_INT
	orr	r1, r0, #ABT_MODE
	msr	cpsr_cxsf, r1
	ldr	sp, _stack_abt_end

	bic	r0, r0, #MODE_MASK | NO_INT
	orr	r1, r0, #IRQ_MODE
	msr	cpsr_cxsf, r1
	ldr	sp, _stack_irq_end

	bic	r0, r0, #MODE_MASK | NO_INT
	orr	r1, r0, #FIQ_MODE
	msr	cpsr_cxsf, r1
	ldr	sp, _stack_fiq_end

	bic	r0, r0, #MODE_MASK | NO_INT
	orr	r1, r0, #SVC_MODE
	msr	cpsr_cxsf, r1
	ldr	sp, _stack_srv_end
	mov	pc, lr

/*
 * memory copy
 */
mem_copy:
	sub	r2, r2, #32
	cmp	r0, r2
	ble	3f
1:	ldmia r0!, {r3-r10}
	stmia r1!, {r3-r10}
	cmp	r0, r2
	ble	1b
3:	add	r2, r2, #32
2:	ldr	r3, [r0], #4
	str	r3, [r1], #4
	cmp	r0, r2
	blt	2b
	mov	pc, lr

/*
 * memory clear zero
 */
mem_clear:
	sub	r1, r1, #32
	cmp	r0, r1
	ble	cp
	mov r3, #0
	mov r4, #0
	mov r5, #0
	mov r6, #0
	mov r7, #0
	mov r8, #0
	mov r9, #0
	mov r10, #0
1:	stmia r0!, {r3-r10}
	cmp	r0, r1
	ble	1b
cp:	add	r1, r1, #32
2:	str	r2, [r0], #4
	cmp	r0, r1
	blt	2b
	mov	pc, lr

最后就是跳转到DDR中的main函数了，至此整个启动流程已经执行完备。

	/* jump to ram */
	ldr	r1, =on_the_ram
	mov	pc, r1
on_the_ram:
	/* jump to main fuction */
	mov r0, #1;
	mov r1, #0;
	bl	main
	b	on_the_ram

到这里，大家可能就疑惑了，只有BL1啊，没有BL2，怎么就完了呢，其实这里用了个高级技巧将所谓的BL2跟所谓的BL1合并为一个程序了，细心的朋友可以仔细研究下上面的自拷贝函数以及跳转到DDR中的main函数，这两个函数是实现这个技巧的关键。

在自拷贝函数中，需要知道当前的代码的链接地址及范围，而这些都是由链接脚本提供的，下面是完整链接脚本。

OUTPUT_FORMAT("elf32-littlearm", "elf32-bigarm", "elf32-littlearm")
OUTPUT_ARCH(arm)
ENTRY(_start)

STACK_FIQ_SIZE 	= 0x0400;
STACK_IRQ_SIZE 	= 0x0400;
STACK_ABT_SIZE 	= 0x0400;
STACK_UND_SIZE 	= 0x0400;
STACK_SRV_SIZE 	= 0x8000;

MEMORY
{
	rom (rx)	: org = 0x40000000, len = 0x02000000	/* 32 MB */
	ram (rwx)	: org = 0x42000000, len = 0x0a000000	/* 160 MB */
}

SECTIONS
{   
	.text :
	{
		. = ALIGN(8);
		PROVIDE (__text_start = .);
		.obj/source/startup/start.o (.text)
		.obj/source/startup/clock_init_smdk4212.o (.text)
		.obj/source/startup/mem_init_smdk4212.o (.text)
		.obj/source/startup/exynos4412-irom.o (.text)
		*(.text)
		*(.text.*)

		. = ALIGN(8);
		*(.rodata);
		*(.rodata.*);

		. = ALIGN(8);
		*(.glue_7);
		*(.glue_7t);

		. = ALIGN(8);
		PROVIDE (__text_end = .);
	} > rom

	.data_shadow ALIGN(8) :
	{
		PROVIDE (__data_shadow_start = .);
		PROVIDE (__data_shadow_end = (. + SIZEOF (.data)) );
	} > rom

	.data : AT ( ADDR (.data_shadow) )
	{
		PROVIDE (__data_start = .);	
		*(.data)
		. = ALIGN(8);
  		PROVIDE (__data_end = .);		
	} > ram

	.ARM.exidx :
	{
		. = ALIGN(8);
		PROVIDE (__exidx_start = .);
		*(.ARM.exidx*)
		PROVIDE (__exidx_end = .);
	} > ram

	.ARM.extab :
	{
		PROVIDE (__extab_start = .);
		*(.ARM.extab*)
		PROVIDE (__extab_end = .);
	} > ram

	.bss ALIGN(8) (NOLOAD) :
	{
		PROVIDE (__bss_start = .);
		*(.bss)
		*(.bss.*)
		*(.sbss)
		*(COMMON)
		PROVIDE (__bss_end = .);
		
		. = ALIGN(8);
		PROVIDE (__heap_start = .);
		*(.heap)
		. = ALIGN(8);
		PROVIDE (__heap_end = .);
		
		. = ALIGN(8);
		PROVIDE (__stack_start = .);
		PROVIDE (__stack_fiq_start = .);
		. += STACK_FIQ_SIZE;
		PROVIDE (__stack_fiq_end = .);
		. = ALIGN(8);
		PROVIDE (__stack_irq_start = .);
		. += STACK_IRQ_SIZE;
		PROVIDE (__stack_irq_end = .);
		. = ALIGN(8);
		PROVIDE (__stack_abt_start = .);
		. += STACK_ABT_SIZE;
		PROVIDE (__stack_abt_end = .);
		. = ALIGN(8);
		PROVIDE (__stack_und_start = .);
		. += STACK_UND_SIZE;
		PROVIDE (__stack_und_end = .);
		. = ALIGN(8);
		PROVIDE (__stack_srv_start = .);
		. += STACK_SRV_SIZE;
		PROVIDE (__stack_srv_end = .);
		. = ALIGN(8);
		PROVIDE (__stack_end = .);
	} > ram

	/*
	 * Stabs debugging sections.
	 */
	.stab 0 : { *(.stab) }
	.stabstr 0 : { *(.stabstr) }
	.stab.excl 0 : { *(.stab.excl) }
	.stab.exclstr 0 : { *(.stab.exclstr) }
	.stab.index 0 : { *(.stab.index) }
	.stab.indexstr 0 : { *(.stab.indexstr) }
	.comment 0 : { *(.comment) }
	.debug_abbrev 0 : { *(.debug_abbrev) }
	.debug_info 0 : { *(.debug_info) }
	.debug_line 0 : { *(.debug_line) }
	.debug_pubnames 0 : { *(.debug_pubnames) }
	.debug_aranges 0 : { *(.debug_aranges) }
}

这个教程算是比较关键的一章了，很多裸机的核心技术都在此教程讲述，大家慢慢消化，有疑问的可以留言，或者直接加QQ咨询：8192542