0%

发表于 更新于 分类于 阅读次数：
本文字数： 600 阅读时长 ≈ 1 分钟

2018年2月9日 下午8:43

  1. 中断原则上来说是异常的一种，因为中断发生时也是跳转到中断向量表处，开始中断过程。但是从触发的过程上来说，在2440中有专门的INTERRUPT CONTROLLER进行控制，这个控制器最主要的作用是：分辨中断源+使能+设置不同的模式。这个有专人服务的贵宾待遇啊！
  2. 编程之前要有的整体意识：
    1. 我总结下来当涉及到中断时，大体需要三个控制器
      1. INTERRUPT CONTROLLER控制器
      2. 一个2440的内部可以触发中断的控制器
        1. 定时器使用的是PWM TIMER
        2. 按键使用的是GPIO
        3. ADC使用时ADC AND TOUCH SCREEN INTERFACE
      3. 在中断处理过程中，根据功能可能还涉及到一个控制器
    2. ”可以触发中断的控制器“和“中断控制器”之间的关系，我见过三种
      1. 定时器使用的是PWM TIMER
        1. 直接将中断信号连接到中断控制器，中间没有任何寄存器和设备。 所以，不需要设置。
      2. 按键使用的是GPIO
        1. 部分引脚的数据要通过EINTMASK寄存器的使能设置。
        2. 按键在中断控制器中，走的路线是（without sub register）
      3. ADC使用时ADC AND TOUCH SCREEN INTERFACE
        1. 双引脚引入中断控制器的，但公用一个引脚，所以一定需要寄存器进行区分
        2. 并且，在中断控制器中走的路线是（with sub register）
  3. 在中断中的第三个部分：中断触发执行的过程
    1. 这个过程与我们们一般执行普通arm程序一样，没啥区别

发表于 更新于 分类于 阅读次数：
本文字数： 577 阅读时长 ≈ 1 分钟

2018年2月9日 下午8:40

前言：

  1. 这篇文章的前奏是 对ARM的理解和整体上去理解2440结构这两篇文章。
  2. 在篇文章我有些观点与对ARM的理解不太合拍，我认为我现在这篇是更加合适更加让我舒服的理解。

正文：

  1. 【核心】： 站在硬件arm板设计者的角度去思考问题 ，在这个过程中只能从现实生活出发，思考：如过你是一个硬件的设计者，哪些情况需要考虑？比如说可扩展性、复用性、操作灵活性等等，整个流程中需要哪些必不可少的组成部分？
    1. 这个过程，其实和我算法部分的认识是一致的！
  2. 其次，才是我以前认为最重要的寄存器。如果你认为寄存器是最终的，那么整个arm的核心点就是去记忆这些寄存器，把arm编程了一种体力活，这是初学者最容易犯的一个错误❌。

方法、技巧：

  1. 在我们 站在硬件arm版设计者的角度去思考问题 时
  2. 【关键】：原理图 + 时序图 + block diagram 这些都是站在不同的角度去说明同一个问题。这些图最终的目的：就是说明arm板设计者是如何考虑问题的，他提出的设计方案是啥。
  3. 我们虽然不可能将这种设计方案通过硬件去实现，但是我们一定要去思考🤔，为啥设计者要这样去设计整个系统？
  4. ::简单来说就是：我已经给你设计好了，你最起码也得理解其中的奥秘吧::。
  5. 我总结的一些设计时常常要考虑的内容：
    1. 高_低电平有效、上_下降沿
    2. 使能的观点
    3. 支持多种模式
    4. 单引脚多用途
    5. 时序，考虑硬件相应
    6. ……..

附件：我的笔记


发表于 更新于 分类于 阅读次数：
本文字数： 66 阅读时长 ≈ 1 分钟

2018年2月9日 下午8:36

注：这篇文章只是想了解一下大致的硬件原理就行。

LCD硬件原理：

ADC和触摸屏硬件原理：

I2C硬件原理：

发表于 更新于 分类于 阅读次数：
本文字数： 10k 阅读时长 ≈ 9 分钟

2018年2月9日 下午8:36

注：代码是009_div_017_010这节的内容

回答几个关键问题：

  1. 这个问题由几个部分组成？
    1. 第一部分：给lcd控制器中的寄存器初始化
      1. Lcd.c团体
      2. lcd_controller.c团体
    2. 第二部分：从配置好的寄存器中查出LCD屏的性质，然后编程实现具体内容的输出到LCD屏幕上。
  2. 当前情况的特点？
    1. lcd.c团体代表的是值，lcd_controller.c团体代表是方法
    2. lcd.c团体有点像是javaEE中的实体这个概念
  3. 需要的角色，以及各个角色的作用
    1. 【程序的最终目的】：用具体的数值去赋值给lcd控制器的寄存器
    2. 【采用面向对象设计模式的作用目的】：两个团体最主要的目的是实现扩展性，将值与赋值给寄存器两个部分分开，否则根本分不需要分两个团体
    3. 由扩展性带来的问题：
      1. 如何能让多个lcd屏幕（参数），多个lcd控制器（寄存器）有统一的接口
        1. .h文件用来限制。类似于javaEE中的抽象类和接口的作用。
        2. 区别是：一个用结构体保存变量，一个用结构体保存函数指针
      2. 必然每个有各自的管理者，各自管理者要有怎样的功能？。在这里我们分别是lcd.c和lcd_controller.c。
        1. lcd.c
        2. lcd_controller.c
        3. 注：上面的两幅图可以说是整体的一个精华。我一开始就不太理解
          1. 这其中蕴含着一种思考方法🤔：从上层和下层两个方面来思考。
          2. 这种类似于提供接口式的思考方式，可以说是面向对象设计的一个关键点
          3. 在这种注册机制中，有一点要注意：管理者提供了注册方法，这个方法是小弟去调用完成注册的，而不是管理者进行注册！这个问题容易忽略

代码：

lcd_test.c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
lcd_test.c

#include "geometry.h"
#include "font.h"

void lcd_test(void)
{
	unsigned int fb_base;
	int xres, yres, bpp;
	int x, y;
	unsigned short *p;
	unsigned int *p2;
		
	/* 初始化LCD */
	lcd_init();

	/* 使能LCD */
	lcd_enable();

	/* 获得LCD的参数: fb_base, xres, yres, bpp */
	get_lcd_params(&fb_base, &xres, &yres, &bpp);
	fb_get_lcd_params();
	font_init();
	
	/* 往framebuffer中写数据 */
	if (bpp == 16)
	{
		/* 让LCD输出整屏的红色 */

		/* 565: 0xf800 */

		p = (unsigned short *)fb_base;
		for (x = 0; x < xres; x++)
			for (y = 0; y < yres; y++)
				*p++ = 0xf800;

		/* green */
		p = (unsigned short *)fb_base;
		for (x = 0; x < xres; x++)
			for (y = 0; y < yres; y++)
				*p++ = 0x7e0;

		/* blue */
		p = (unsigned short *)fb_base;
		for (x = 0; x < xres; x++)
			for (y = 0; y < yres; y++)
				*p++ = 0x1f;

		/* black */
		p = (unsigned short *)fb_base;
		for (x = 0; x < xres; x++)
			for (y = 0; y < yres; y++)
				*p++ = 0;
			
	}
	else if (bpp == 32)
	{
		/* 让LCD输出整屏的红色 */

		/* 0xRRGGBB */

		p2 = (unsigned int *)fb_base;
		for (x = 0; x < xres; x++)
			for (y = 0; y < yres; y++)
				*p2++ = 0xff0000;

		/* green */
		p2 = (unsigned int *)fb_base;
		for (x = 0; x < xres; x++)
			for (y = 0; y < yres; y++)
				*p2++ = 0x00ff00;

		/* blue */
		p2 = (unsigned int *)fb_base;
		for (x = 0; x < xres; x++)
			for (y = 0; y < yres; y++)
				*p2++ = 0x0000ff;

		/* black */
		p2 = (unsigned int *)fb_base;
		for (x = 0; x < xres; x++)
			for (y = 0; y < yres; y++)
				*p2++ = 0;

	}

	delay(1000000);
	
	/* 画线 */
	draw_line(0, 0, xres - 1, 0, 0xff0000);
	draw_line(xres - 1, 0, xres - 1, yres - 1, 0xffff00);
	draw_line(0, yres - 1, xres - 1, yres - 1, 0xff00aa);
	draw_line(0, 0, 0, yres - 1, 0xff00ef);
	draw_line(0, 0, xres - 1, yres - 1, 0xff4500);
	draw_line(xres - 1, 0, 0, yres - 1, 0xff0780);

	delay(1000000);

	/* 画圆 */
	draw_circle(xres/2, yres/2, yres/4, 0xff00);

	/* 输出文字 */
	fb_print_string(10, 10, "www.100ask.net\n\r100ask.taobao.com", 0xff00);
}

lcd.c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
lcd.c
#include "lcd.h"
#include "lcd_controller.h"

#define LCD_NUM 10

static p_lcd_params p_array_lcd[LCD_NUM];
static p_lcd_params g_p_lcd_selected;

int register_lcd(p_lcd_params plcd)
{
	int i;
	for (i = 0; i < LCD_NUM; i++)
	{
		if (!p_array_lcd[i])
		{
			p_array_lcd[i] = plcd;
			return i;
		}
	}
	return -1;		
}

int select_lcd(char *name)
{
	int i;
	for (i = 0; i < LCD_NUM; i++)
	{
		if (p_array_lcd[i] && !strcmp(p_array_lcd[i]->name, name))
		{
			g_p_lcd_selected = p_array_lcd[i];
			return i;
		}
	}
	return -1;		
}

void get_lcd_params(unsigned int *fb_base, int *xres, int *yres, int *bpp)
{
	*fb_base = g_p_lcd_selected->fb_base;
	*xres = g_p_lcd_selected->xres;
	*yres = g_p_lcd_selected->yres;
	*bpp = g_p_lcd_selected->bpp;
}

void lcd_enable(void)
{
	lcd_controller_enable();
}

void lcd_disable(void)
{
	lcd_controller_disable();
}

int lcd_init(void)
{
	/* 注册LCD */
	lcd_4_3_add();

	/* 注册LCD控制器 */
	lcd_contoller_add();
	
	/* 选择某款LCD */
	select_lcd("lcd_4.3");

	/* 选择某款LCD控制器 */
	select_lcd_controller("s3c2440");

	/* 使用LCD的参数, 初始化LCD控制器 */
	lcd_controller_init(g_p_lcd_selected);
}

Lcd.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
lcd.h


#ifndef _LCD_H
#define _LCD_H


enum {
	NORMAL = 0,
	INVERT = 1,
};

/* NORMAL : 正常极性
 * INVERT : 反转极性
 */
typedef struct pins_polarity {
	int de;    /* normal: 高电平时可以传输数据 */
	int pwren; /* normal: 高电平有效 */
	int vclk;  /* normal: 在下降沿获取数据 */
	int rgb;   /* normal: 高电平表示1 */
	int hsync; /* normal: 高脉冲 */
	int vsync; /* normal: 高脉冲 */
}pins_polarity, *p_pins_polarity;

typedef struct time_sequence {
	/* 垂直方向 */
	int tvp; /* vysnc脉冲宽度 */
	int tvb; /* 上边黑框, Vertical Back porch */
	int tvf; /* 下边黑框, Vertical Front porch */

	/* 水平方向 */
	int thp; /* hsync脉冲宽度 */
	int thb; /* 左边黑框, Horizontal Back porch */
	int thf; /* 右边黑框, Horizontal Front porch */

	int vclk;
}time_sequence, *p_time_sequence;


typedef struct lcd_params {
	char *name;
	
	/* 引脚极性 */
	pins_polarity pins_pol;
	
	/* 时序 */
	time_sequence time_seq;
	
	/* 分辨率, bpp */
	int xres;
	int yres;
	int bpp;
	
	/* framebuffer的地址 */
	unsigned int fb_base;
}lcd_params, *p_lcd_params;

void get_lcd_params(unsigned int *fb_base, int *xres, int *yres, int *bpp);

#endif /* _LCD_H */

lcd_4.3.c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
lcd_4.3.c

#include "lcd.h"

#define LCD_FB_BASE 0x33c00000

lcd_params lcd_4_3_params = {
	.name = "lcd_4.3",
	.pins_pol = {
		.de    = NORMAL,	/* normal: 高电平时可以传输数据 */
		.pwren = NORMAL,    /* normal: 高电平有效 */
		.vclk  = NORMAL,	/* normal: 在下降沿获取数据 */
		.rgb   = NORMAL,	/* normal: 高电平表示1 */
		.hsync = INVERT,    /* normal: 高脉冲 */
		.vsync = INVERT, 	/* normal: 高脉冲 */
	},
	.time_seq = {
		/* 垂直方向 */
		.tvp=	10, /* vysnc脉冲宽度 */
		.tvb=	2,  /* 上边黑框, Vertical Back porch */
		.tvf=	2,  /* 下边黑框, Vertical Front porch */

		/* 水平方向 */
		.thp=	41, /* hsync脉冲宽度 */
		.thb=	2,  /* 左边黑框, Horizontal Back porch */
		.thf=	2,  /* 右边黑框, Horizontal Front porch */

		.vclk=	9,  /* MHz */
	},
	.xres = 480,
	.yres = 272,
	.bpp  = 32,  /* 16, no 24bpp */
	.fb_base = LCD_FB_BASE,
};


void lcd_4_3_add(void)
{
	register_lcd(&lcd_4_3_params);
}

Lcd_controller.c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
lcd_controller.c

#include "lcd_controller.h"

#define LCD_CONTROLLER_NUM 10

static p_lcd_controller p_array_lcd_controller[LCD_CONTROLLER_NUM];
static p_lcd_controller g_p_lcd_controller_selected;

int register_lcd_controller(p_lcd_controller plcdcon)
{
	int i;
	for (i = 0; i < LCD_CONTROLLER_NUM; i++)
	{
		if (!p_array_lcd_controller[i])
		{
			p_array_lcd_controller[i] = plcdcon;
			return i;
		}
	}
	return -1;		
}

int select_lcd_controller(char *name)
{
	int i;
	for (i = 0; i < LCD_CONTROLLER_NUM; i++)
	{
		if (p_array_lcd_controller[i] && !strcmp(p_array_lcd_controller[i]->name, name))
		{
			g_p_lcd_controller_selected = p_array_lcd_controller[i];
			return i;
		}
	}
	return -1;		
}


/* 向上: 接收不同LCD的参数
 * 向下: 使用这些参数设置对应的LCD控制器
 */

int lcd_controller_init(p_lcd_params plcdparams)
{
	/* 调用所选择的LCD控制器的初始化函数 */
	if (g_p_lcd_controller_selected)
	{
		g_p_lcd_controller_selected->init(plcdparams);
		return 0;
	}
	return -1;
}

void lcd_controller_enable(void)
{
	if (g_p_lcd_controller_selected)
	{
		g_p_lcd_controller_selected->enable();
	}
}

void lcd_controller_disable(void)
{
	if (g_p_lcd_controller_selected)
	{
		g_p_lcd_controller_selected->disable();
	}
}


void lcd_contoller_add(void)
{
	s3c2440_lcd_contoller_add();
}

Lcd_controller.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Lcd_controller.h

#ifndef _LCD_CONTROLLER_H
#define _LCD_CONTROLLER_H

#include "lcd.h"

typedef struct lcd_controller {
	char *name;
	void (*init)(p_lcd_params plcdparams);
	void (*enable)(void);
	void (*disable)(void);
}lcd_controller, *p_lcd_controller;

#endif /* _LCD_CONTROLLER_H */

s3c2440_lcd_controller.c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
s3c2440_lcd_controller.c

#include "lcd.h"
#include "lcd_controller.h"
#include "../s3c2440_soc.h"

#define HCLK 100

void jz2440_lcd_pin_init(void)
{
	/* 初始化引脚 : 背光引脚 */
	GPBCON &= ~0x3;
	GPBCON |= 0x01;

	/* LCD专用引脚 */
	GPCCON = 0xaaaaaaaa;
	GPDCON = 0xaaaaaaaa;

	/* PWREN */
	GPGCON |= (3<<8);
}


/* 根据传入的LCD参数设置LCD控制器 */
void s3c2440_lcd_controller_init(p_lcd_params plcdparams)
{
	int pixelplace;
	unsigned int addr;

	jz2440_lcd_pin_init();
	
	/* [17:8]: clkval, vclk = HCLK / [(CLKVAL+1) x 2]
	 *                   9   = 100M /[(CLKVAL+1) x 2], clkval = 4.5 = 5
	 *                 CLKVAL = 100/vclk/2-1
	 * [6:5]: 0b11, tft lcd
	 * [4:1]: bpp mode
	 * [0]  : LCD video output and the logic enable/disable
	 */
	int clkval = (float)HCLK/plcdparams->time_seq.vclk/2-1+0.5;
	//int clkval = 5;
	int bppmode = plcdparams->bpp == 8  ? 0xb :\
				  plcdparams->bpp == 16 ? 0xc :\
				  0xd;  /* 0xd: 24,32bpp */
	LCDCON1 = (clkval<<8) | (3<<5) | (bppmode<<1) ;

	/* [31:24] : VBPD    = tvb - 1
	 * [23:14] : LINEVAL = line - 1
	 * [13:6]  : VFPD    = tvf - 1
	 * [5:0]   : VSPW    = tvp - 1
	 */
	LCDCON2 = 	((plcdparams->time_seq.tvb - 1)<<24) | \
	            ((plcdparams->yres - 1)<<14)         | \
				((plcdparams->time_seq.tvf - 1)<<6)  | \
				((plcdparams->time_seq.tvp - 1)<<0);

	/* [25:19] : HBPD	 = thb - 1
	 * [18:8]  : HOZVAL  = 列 - 1
	 * [7:0]   : HFPD	 = thf - 1
	 */
	LCDCON3 =	((plcdparams->time_seq.thb - 1)<<19) | \
				((plcdparams->xres - 1)<<8)		      | \
				((plcdparams->time_seq.thf - 1)<<0);

	/* 
	 * [7:0]   : HSPW	 = thp - 1
	 */
	LCDCON4 =	((plcdparams->time_seq.thp - 1)<<0);

    /* 用来设置引脚极性, 设置16bpp, 设置内存中象素存放的格式
     * [12] : BPP24BL
	 * [11] : FRM565, 1-565
	 * [10] : INVVCLK, 0 = The video data is fetched at VCLK falling edge
	 * [9]  : HSYNC是否反转
	 * [8]  : VSYNC是否反转
	 * [7]  : INVVD, rgb是否反转
	 * [6]  : INVVDEN
	 * [5]  : INVPWREN
	 * [4]  : INVLEND
	 * [3]  : PWREN, LCD_PWREN output signal enable/disable
	 * [2]  : ENLEND
	 * [1]  : BSWP
	 * [0]  : HWSWP
	 */

	pixelplace = plcdparams->bpp == 32 ? (0) : \
	             plcdparams->bpp == 16 ? (1) : \
	             (1<<1);  /* 8bpp */
	
	LCDCON5 = (plcdparams->pins_pol.vclk<<10) |\
	          (plcdparams->pins_pol.rgb<<7)   |\
	          (plcdparams->pins_pol.hsync<<9) |\
	          (plcdparams->pins_pol.vsync<<8) |\
 			  (plcdparams->pins_pol.de<<6)    |\
			  (plcdparams->pins_pol.pwren<<5) |\
			  (1<<11) | pixelplace;

	/* framebuffer地址 */
	/*
	 * [29:21] : LCDBANK, A[30:22] of fb
	 * [20:0]  : LCDBASEU, A[21:1] of fb
	 */
	addr = plcdparams->fb_base & ~(1<<31);
	LCDSADDR1 = (addr >> 1);

	/* 
	 * [20:0] : LCDBASEL, A[21:1] of end addr
	 */
	addr = plcdparams->fb_base + plcdparams->xres*plcdparams->yres*plcdparams->bpp/8;
	addr >>=1;
	addr &= 0x1fffff;
	LCDSADDR2 = addr;//	
}

void s3c2440_lcd_controller_enalbe(void)
{
	/* 背光引脚 : GPB0 */
	GPBDAT |= (1<<0);
	
	/* pwren    : 给LCD提供AVDD  */
	LCDCON5 |= (1<<3);
	
	/* LCDCON1'BIT 0 : 设置LCD控制器是否输出信号 */
	LCDCON1 |= (1<<0);
}

void s3c2440_lcd_controller_disable(void)
{
	/* 背光引脚 : GPB0 */
	GPBDAT &= ~(1<<0);

	/* pwren	: 给LCD提供AVDD  */
	LCDCON5 &= ~(1<<3);

	/* LCDCON1'BIT 0 : 设置LCD控制器是否输出信号 */
	LCDCON1 &= ~(1<<0);
}

struct lcd_controller s3c2440_lcd_controller = {
	.name    = "s3c2440",
	.init    = s3c2440_lcd_controller_init,
	.enable  = s3c2440_lcd_controller_enalbe,
	.disable = s3c2440_lcd_controller_disable,
};


void s3c2440_lcd_contoller_add(void)
{
	register_lcd_controller(&s3c2440_lcd_controller);
}

发表于 更新于 分类于 阅读次数：
本文字数： 347 阅读时长 ≈ 1 分钟

2018年2月9日 下午4:15

我参考了一些文章，例如：五大常用算法：分治、动态规划、贪心、回溯和分支界定 - CSDN博客。但是我觉得总结的并不是那么的容易理解。

我的理解从两个方面去描述：

  1. 【主要】：数学上的前后结果规律是否存存在？以及我们找这个规律的过程，回花费我们做题时间的60~80%，足以体现出他的重要性
  2. 【次要】：从解决的问题上来说。dp最后要的结果往往是一些具体的数值，比如说求最大最小等问题。在分治中，一般结果往往是一些“现象”，比如说排序等问题。

一般规律：

  1. 这里的前后结果往往都会涉及多个前结果的组合，关键是我们如何找到有哪些组合，以及组合之间的关系！！
    1. eg：不等式数列_牛客网
    2. 这里就有四个不同前结果去组合表示下一个结果。

方法：

  1. 举具体的例子🌰去测试，这个过程没啥技巧吧，就是不断地尝试。

发表于 更新于 分类于 阅读次数：
本文字数： 7.2k 阅读时长 ≈ 7 分钟

2018年2月6日 上午9:59

程序流程图：

  1. 可以很直观的看到：初始化在arm中真的是一个非常非常简单，但是却十分关键的步骤
    1. 这样的本质原因是：ARM大部分功能都是基于在开发板上人家已经实现的功能，在java框架使用中，我们使用的是他们类的接口，而在ARM中我们使用的是寄存器接口
  2. 流线的让你去真正的是先功能的步骤，相比而言就少了很多

程序代码：（重要点都在注释中）

几个重要的易错知识点

  1. 使用字符串时要4字节对齐：

  2. 在.S中调用c函数时，会自动保存R4~R11 和 fp,sp其他的需要自己保存（有证明）。
    证明：


    所以当我们需要在调用函数前后，使用未保存的寄存器如LR。那么需要我们自己手动保存。

  3. 对于程序运行过程中调用异常处理程序，在.S文件中基本所有的寄存器都需要我们自己保存，只有当前异常对应的有备份的特有寄存器才可以不保存。

    具体的情况看下图

注：调用c函数的过程和调用异常处理函数的过程是两个相互独立的过程，所以那些寄存器该不该手动保存有着不同的评判方式，我一开始就没有区分开他们两个。
4. 考虑特殊情况：当我们从Nand flash启动，程序读入到SRAM中
1. 当 start.S文件 < 4kb & .c文件不能全部读入SRAM中
1. 当我们调用c函数时，一定要使用绝对跳转/前一步已经绝对跳转，这样就能保证一定调用SDRAM中复制过来的c函数


2. 当 start.S文件 > 4kb （光.S文件就到达了4k，更别说.c文件了）

5. start.S文件中的函数名，本质就是一个地址值，也可以理解成汇编文件中的一个变量，这个变量的值是一个地址。
6. 进入到start.S文件的中断程序之后，我们设置的sp，是当前异常模式下的SP，虽然他们在写程序时都是使用相同的名字SP，但在arm硬件中他们是不同的寄存器。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
start.S

.text
.global _start

_start:
	b reset          /* vector 0 : reset */
	ldr pc, und_addr /* vector 4 : und */
	ldr pc, swi_addr /* vector 8 : swi */
	b halt			 /* vector 0x0c : prefetch aboot */
	b halt			 /* vector 0x10 : data abort */
	b halt			 /* vector 0x14 : reserved */
	ldr pc, irq_addr /* vector 0x18 : irq */
	b halt			 /* vector 0x1c : fiq */
/* 这里要区分ldr pc, irq_addr 与 ldr pc, =irq_addr*/
/* 第一个：代表要获取irq_addr地址处的值，理解成*irq_addr */
/* 第二个：代表要获取irq_addr本身这个地址值，理解成& irq_addr*/
und_addr:
	.word do_und

swi_addr:
	.word do_swi

irq_addr:
	.word do_irq

do_und:
	/* 执行到这里之前:
	 * 1. lr_und保存有被中断模式中的下一条即将执行的指令的地址
	 * 2. SPSR_und保存有被中断模式的CPSR
	 * 3. CPSR中的M4-M0被设置为11011, 进入到und模式
	 * 4. 跳到0x4的地方执行程序 
	 */

	/* sp_und未设置, 先设置它 */
	ldr sp, =0x34000000

	/* 在und异常处理函数中有可能会修改r0-r12, 所以先保存 */
	/* lr是异常处理完后的返回地址, 也要保存 */
	stmdb sp!, {r0-r12, lr}  
	
	/* 保存现场 */
	/* 处理und异常 */
	mrs r0, cpsr
	ldr r1, =und_string
	bl printException
	
	/* 恢复现场 */
	ldmia sp!, {r0-r12, pc}^  /* ^会把spsr的值恢复到cpsr里 */
	
und_string:
	.string "undefined instruction exception"

.align 4

do_swi:
	/* 执行到这里之前:
	 * 1. lr_svc保存有被中断模式中的下一条即将执行的指令的地址
	 * 2. SPSR_svc保存有被中断模式的CPSR
	 * 3. CPSR中的M4-M0被设置为10011, 进入到svc模式
	 * 4. 跳到0x08的地方执行程序 
	 */

	/* sp_svc未设置, 先设置它 */
	ldr sp, =0x33e00000

	/* 保存现场 */
	/* 在swi异常处理函数中有可能会修改r0-r12, 所以先保存 */
	/* lr是异常处理完后的返回地址, 也要保存 */
	stmdb sp!, {r0-r12, lr}  

	mov r4, lr
	
	/* 处理swi异常 */
	mrs r0, cpsr
	ldr r1, =swi_string
	bl printException

	sub r0, r4, #4
	bl printSWIVal
	
	/* 恢复现场 */
	ldmia sp!, {r0-r12, pc}^  /* ^会把spsr的值恢复到cpsr里 */
	
swi_string:
	.string "swi exception"

.align 4

do_irq:
	/* 执行到这里之前:
	 * 1. lr_irq保存有被中断模式中的下一条即将执行的指令的地址
	 * 2. SPSR_irq保存有被中断模式的CPSR
	 * 3. CPSR中的M4-M0被设置为10010, 进入到irq模式
	 * 4. 跳到0x18的地方执行程序 
	 */

	/* sp_irq未设置, 先设置它 */
	ldr sp, =0x33d00000

	/* 保存现场 */
	/* 在irq异常处理函数中有可能会修改r0-r12, 所以先保存 */
	/* lr-4是异常处理完后的返回地址, 也要保存 */
	sub lr, lr, #4
	stmdb sp!, {r0-r12, lr}  
	
	/* 处理irq异常 */
	bl handle_irq_c
	
	/* 恢复现场 */
	ldmia sp!, {r0-r12, pc}^  /* ^会把spsr_irq的值恢复到cpsr里 */


reset:
	/* 关闭看门狗 */
	ldr r0, =0x53000000
	ldr r1, =0
	str r1, [r0]

	/* 设置MPLL, FCLK : HCLK : PCLK = 400m : 100m : 50m */
	/* LOCKTIME(0x4C000000) = 0xFFFFFFFF */
	ldr r0, =0x4C000000
	ldr r1, =0xFFFFFFFF
	str r1, [r0]

	/* CLKDIVN(0x4C000014) = 0X5, tFCLK:tHCLK:tPCLK = 1:4:8  */
	ldr r0, =0x4C000014
	ldr r1, =0x5
	str r1, [r0]

	/* 设置CPU工作于异步模式 */
	mrc p15,0,r0,c1,c0,0
	orr r0,r0,#0xc0000000   //R1_nF:OR:R1_iA
	mcr p15,0,r0,c1,c0,0

	/* 设置MPLLCON(0x4C000004) = (92<<12)|(1<<4)|(1<<0) 
	 *  m = MDIV+8 = 92+8=100
	 *  p = PDIV+2 = 1+2 = 3
	 *  s = SDIV = 1
	 *  FCLK = 2*m*Fin/(p*2^s) = 2*100*12/(3*2^1)=400M
	 */
	ldr r0, =0x4C000004
	ldr r1, =(92<<12)|(1<<4)|(1<<0)
	str r1, [r0]

	/* 一旦设置PLL, 就会锁定lock time直到PLL输出稳定
	 * 然后CPU工作于新的频率FCLK
	 */
	
	

	/* 设置内存: sp 栈 */
	/* 分辨是nor/nand启动
	 * 写0到0地址, 再读出来
	 * 如果得到0, 表示0地址上的内容被修改了, 它对应ram, 这就是nand启动
	 * 否则就是nor启动
	 */
	mov r1, #0
	ldr r0, [r1] /* 读出原来的值备份 */
	str r1, [r1] /* 0->[0] */ 
	ldr r2, [r1] /* r2=[0] */
	cmp r1, r2   /* r1==r2? 如果相等表示是NAND启动 */
	ldr sp, =0x40000000+4096 /* 先假设是nor启动 */
	moveq sp, #4096  /* nand启动 */
	streq r0, [r1]   /* 恢复原来的值 */

	bl sdram_init
	//bl sdram_init2	 /* 用到有初始值的数组, 不是位置无关码 */

	/* 重定位text, rodata, data段整个程序 */
	bl copy2sdram

	/* 清除BSS段 */
	bl clean_bss

	/* 复位之后, cpu处于svc模式
	 * 现在, 切换到usr模式
	 */
	mrs r0, cpsr         /* 读出cpsr */
	bic r0, r0, #0xf     /* 修改M4-M0为0b10000, 进入usr模式 */
	bic r0, r0, #(1<<7)  /* 清除I位, 使能中断 */
	msr cpsr, r0

	/* 设置 sp_usr */
	ldr sp, =0x33f00000

	ldr pc, =sdram
sdram:
	bl uart0_init

	bl print1
	/* 故意加入一条未定义指令 */
und_code:
	.word 0xdeadc0de  /* 未定义指令 */
	bl print2

	swi 0x123  /* 执行此命令, 触发SWI异常, 进入0x8执行 */

	//bl main  /* 使用BL命令相对跳转, 程序仍然在NOR/sram执行 */
	ldr pc, =main  /* 绝对跳转, 跳到SDRAM */

halt:
	b halt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
mian.c

#include "s3c2440_soc.h"
#include "uart.h"
#include "init.h"

char g_Char = 'A';
char g_Char3 = 'a';
const char g_Char2 = 'B';
int g_A = 0;
int g_B;

int main(void)
{
	led_init();
	interrupt_init();  /* 初始化中断控制器 */
	key_eint_init();   /* 初始化按键, 设为中断源 */
	
	puts("\n\rg_A = ");
	printHex(g_A);
	puts("\n\r");

	while (1)
	{
#if 0		
		puts("\n\rg_Char = ");
		printHex(g_Char);
		puts("\n\r");

 		puts("\n\rg_Char3 = ");
		printHex(g_Char3);
		puts("\n\r");
#endif
		putchar(g_Char);
		g_Char++;

		putchar(g_Char3);
		g_Char3++;
		delay(1000000);
	}

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
interrupt.c
#include "s3c2440_soc.h"

// interrupt controller章节
/* SRCPND 用来显示哪个中断产生了, 需要清除对应位
 * bit0-eint0
 * bit2-eint2
 * bit5-eint8_23
 */

/* INTMSK 用来屏蔽中断, 1-masked
 * bit0-eint0
 * bit2-eint2
 * bit5-eint8_23
 */

/* INTPND 用来显示当前优先级最高的、正在发生的中断, 需要清除对应位
 * bit0-eint0
 * bit2-eint2
 * bit5-eint8_23
 */

/* INTOFFSET : 用来显示INTPND中哪一位被设置为1
 */

/* 初始化中断控制器 */
void interrupt_init(void)
{
	INTMSK &= ~((1<<0) | (1<<2) | (1<<5));
}

// I/O port章节
/* 初始化按键, 设为中断源 */
void key_eint_init(void)
{
	/* 配置GPIO为中断引脚 */
	GPFCON &= ~((3<<0) | (3<<4));
	GPFCON |= ((2<<0) | (2<<4));   /* S2,S3被配置为中断引脚 */

	GPGCON &= ~((3<<6) | (3<<22));
	GPGCON |= ((2<<6) | (2<<22));   /* S4,S5被配置为中断引脚 */
	

	/* 设置中断触发方式: 双边沿触发 */
	EXTINT0 |= (7<<0) | (7<<8);     /* S2,S3 */
	EXTINT1 |= (7<<12);             /* S4 */
	EXTINT2 |= (7<<12);             /* S5 */

	/* 设置EINTMASK使能eint11,19 */
	EINTMASK &= ~((1<<11) | (1<<19));
}

/* 读EINTPEND分辨率哪个EINT产生(eint4~23)
 * 清除中断时, 写EINTPEND的相应位
 */


void key_eint_irq(int irq)
{
	unsigned int val = EINTPEND;
	unsigned int val1 = GPFDAT;
	unsigned int val2 = GPGDAT;
	
	if (irq == 0) /* eint0 : s2 控制 D12 */
	{
		if (val1 & (1<<0)) /* s2 --> gpf6 */
		{
			/* 松开 */
			GPFDAT |= (1<<6);
		}
		else
		{
			/* 按下 */
			GPFDAT &= ~(1<<6);
		}
		
	}
	else if (irq == 2) /* eint2 : s3 控制 D11 */
	{
		if (val1 & (1<<2)) /* s3 --> gpf5 */
		{
			/* 松开 */
			GPFDAT |= (1<<5);
		}
		else
		{
			/* 按下 */
			GPFDAT &= ~(1<<5);
		}
		
	}
	else if (irq == 5) /* eint8_23, eint11--s4 控制 D10, eint19---s5 控制所有LED */
	{
		if (val & (1<<11)) /* eint11 */
		{
			if (val2 & (1<<3)) /* s4 --> gpf4 */
			{
				/* 松开 */
				GPFDAT |= (1<<4);
			}
			else
			{
				/* 按下 */
				GPFDAT &= ~(1<<4);
			}
		}
		else if (val & (1<<19)) /* eint19 */
		{
			if (val2 & (1<<11))
			{
				/* 松开 */
				/* 熄灭所有LED */
				GPFDAT |= ((1<<4) | (1<<5) | (1<<6));
			}
			else
			{
				/* 按下: 点亮所有LED */
				GPFDAT &= ~((1<<4) | (1<<5) | (1<<6));
			}
		}
	}

	EINTPEND = val;
}


void handle_irq_c(void)
{
	/* 分辨中断源 */
	int bit = INTOFFSET;

	/* 调用对应的处理函数 */
	if (bit == 0 || bit == 2 || bit == 5)  /* eint0,2,eint8_23 */
	{
		key_eint_irq(bit); /* 处理中断, 清中断源EINTPEND */
	}

	/* 清中断 : 从源头开始清 */
	SRCPND = (1<<bit);
	INTPND = (1<<bit);	
}

发表于 更新于 分类于 阅读次数：
本文字数： 800 阅读时长 ≈ 1 分钟

2018年2月4日 下午11:51

概述：

有两个角度

  1. 与我在算法中总结的思路进行对比
  2. 反过头去看我在这段时间学的关于arm的所有知识点，有一个整体的认识
  3. 总结：在分析功能，写代码的时候，你脑子中一定要有2440硬件结构，这样才能从总体上心里有数整体上去理解2440结构

第一个角度

  1. 在算法中，我最根本的角度是：从现实的角度出发，即使是那些分治、贪心、动态规划也是理解成一种可以脱离代码这种表达形式的一种的现实的思路。
  2. 在arm中，如果你将算法的这种思路套入arm的整个编程过程中，你会发现这根本不需要你去考虑各种各样的方法，完全水土不服。造成这个现象的原因是：arm开发板整个硬件已经规定了基本上所有东西的用法，你只是用用而已，你没法改变。

我现在总结出来的关于arm中的思考体系是：

  1. （容易）第一步：根据现实的功能，分析我要使用那些2440部件？
    1. UART
    2. GPIO
    3. memory controller
    4. interrupt controller
    5. nor flash
    6. SDRAM
    7. SRAM
    8. nand flash controller
    9. ….LCD…SPI….PWM…CLOCK
  2. （难）第二步：继续明确我们要使用一个部件中的哪些寄存器？
    1. 这需要你两个能力：
      1. 2440各个部件的工作原理你要知道
      2. ::2440给你开放了哪些功能，能让你去编程控制（以寄存器的形式）::
    2. 当你把这个问题回答清楚之后，整个项目就完成了80%，省下的20%就是简单的代码去实现而已了
    3. 代码实现，这一点和算法是相同的，都不是最核心、最难的部分
  3. （容易）第三部：写代码去实现去吧，这个容易，写法是固定的

第二个角度：

Arm这门课中其实最核心的知识点应该是：讲解2440各个部件的工作原理+寄存器控制。但是却讲了很多其他的内容，eglinux makefile gcc c语言 vi等等，从章节上来说反而这些不重要的东西占据了大量的课时。这就说明arm这门知识本身并不多，而是arm周边的整套编程环境和琐碎。

发表于 更新于 分类于 阅读次数：
本文字数： 22k 阅读时长 ≈ 20 分钟

2018年2月3日 下午6:25

.dis

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
sdram.dis

sdram.elf:     file format elf32-littlearm

Disassembly of section .text:

30000000 <_start>:
30000000:	e3a00453 	mov	r0, #1392508928	; 0x53000000
30000004:	e3a01000 	mov	r1, #0	; 0x0
30000008:	e5801000 	str	r1, [r0]
3000000c:	e3a00313 	mov	r0, #1275068416	; 0x4c000000
30000010:	e3e01000 	mvn	r1, #0	; 0x0
30000014:	e5801000 	str	r1, [r0]
30000018:	e59f0050 	ldr	r0, [pc, #80]	; 30000070 <.text+0x70>
3000001c:	e3a01005 	mov	r1, #5	; 0x5
30000020:	e5801000 	str	r1, [r0]
30000024:	ee110f10 	mrc	15, 0, r0, cr1, cr0, {0}
30000028:	e3800103 	orr	r0, r0, #-1073741824	; 0xc0000000
3000002c:	ee010f10 	mcr	15, 0, r0, cr1, cr0, {0}
30000030:	e59f003c 	ldr	r0, [pc, #60]	; 30000074 <.text+0x74>
30000034:	e59f103c 	ldr	r1, [pc, #60]	; 30000078 <.text+0x78>
30000038:	e5801000 	str	r1, [r0]
3000003c:	e3a01000 	mov	r1, #0	; 0x0
30000040:	e5910000 	ldr	r0, [r1]
30000044:	e5811000 	str	r1, [r1]
30000048:	e5912000 	ldr	r2, [r1]
3000004c:	e1510002 	cmp	r1, r2
30000050:	e59fd024 	ldr	sp, [pc, #36]	; 3000007c <.text+0x7c>
30000054:	03a0da01 	moveq	sp, #4096	; 0x1000
30000058:	05810000 	streq	r0, [r1]
3000005c:	eb0000f5 	bl	30000438 <sdram_init>
30000060:	eb000170 	bl	30000628 <copy2sdram>
30000064:	eb00018d 	bl	300006a0 <clean_bss>
30000068:	e59ff010 	ldr	pc, [pc, #16]	; 30000080 <.text+0x80>

3000006c <halt>:
3000006c:	eafffffe 	b	3000006c <halt>
30000070:	4c000014 	stcmi	0, cr0, [r0], {20}
30000074:	4c000004 	stcmi	0, cr0, [r0], {4}
30000078:	0005c011 	andeq	ip, r5, r1, lsl r0
3000007c:	40001000 	andmi	r1, r0, r0
30000080:	30000700 	andcc	r0, r0, r0, lsl #14

30000084 <delay>:
30000084:	e1a0c00d 	mov	ip, sp
30000088:	e92dd800 	stmdb	sp!, {fp, ip, lr, pc}
3000008c:	e24cb004 	sub	fp, ip, #4	; 0x4
30000090:	e24dd004 	sub	sp, sp, #4	; 0x4
30000094:	e50b0010 	str	r0, [fp, #-16]
30000098:	e51b3010 	ldr	r3, [fp, #-16]
3000009c:	e2433001 	sub	r3, r3, #1	; 0x1
300000a0:	e50b3010 	str	r3, [fp, #-16]
300000a4:	e51b3010 	ldr	r3, [fp, #-16]
300000a8:	e3730001 	cmn	r3, #1	; 0x1
300000ac:	0a000000 	beq	300000b4 <delay+0x30>
300000b0:	eafffff8 	b	30000098 <delay+0x14>
300000b4:	e89da808 	ldmia	sp, {r3, fp, sp, pc}

300000b8 <led_test>:
300000b8:	e1a0c00d 	mov	ip, sp
300000bc:	e92dd800 	stmdb	sp!, {fp, ip, lr, pc}
300000c0:	e24cb004 	sub	fp, ip, #4	; 0x4
300000c4:	e24dd008 	sub	sp, sp, #8	; 0x8
300000c8:	e3a03000 	mov	r3, #0	; 0x0
300000cc:	e50b3010 	str	r3, [fp, #-16]
300000d0:	e3a02456 	mov	r2, #1442840576	; 0x56000000
300000d4:	e2822050 	add	r2, r2, #80	; 0x50
300000d8:	e3a03456 	mov	r3, #1442840576	; 0x56000000
300000dc:	e2833050 	add	r3, r3, #80	; 0x50
300000e0:	e5933000 	ldr	r3, [r3]
300000e4:	e3c33c3f 	bic	r3, r3, #16128	; 0x3f00
300000e8:	e5823000 	str	r3, [r2]
300000ec:	e3a02456 	mov	r2, #1442840576	; 0x56000000
300000f0:	e2822050 	add	r2, r2, #80	; 0x50
300000f4:	e3a03456 	mov	r3, #1442840576	; 0x56000000
300000f8:	e2833050 	add	r3, r3, #80	; 0x50
300000fc:	e5933000 	ldr	r3, [r3]
30000100:	e3833c15 	orr	r3, r3, #5376	; 0x1500
30000104:	e5823000 	str	r3, [r2]
30000108:	e51b3010 	ldr	r3, [fp, #-16]
3000010c:	e1e03003 	mvn	r3, r3
30000110:	e50b3014 	str	r3, [fp, #-20]
30000114:	e51b3014 	ldr	r3, [fp, #-20]
30000118:	e2033007 	and	r3, r3, #7	; 0x7
3000011c:	e50b3014 	str	r3, [fp, #-20]
30000120:	e3a02456 	mov	r2, #1442840576	; 0x56000000
30000124:	e2822054 	add	r2, r2, #84	; 0x54
30000128:	e3a03456 	mov	r3, #1442840576	; 0x56000000
3000012c:	e2833054 	add	r3, r3, #84	; 0x54
30000130:	e5933000 	ldr	r3, [r3]
30000134:	e3c33070 	bic	r3, r3, #112	; 0x70
30000138:	e5823000 	str	r3, [r2]
3000013c:	e3a01456 	mov	r1, #1442840576	; 0x56000000
30000140:	e2811054 	add	r1, r1, #84	; 0x54
30000144:	e3a03456 	mov	r3, #1442840576	; 0x56000000
30000148:	e2833054 	add	r3, r3, #84	; 0x54
3000014c:	e51b2014 	ldr	r2, [fp, #-20]
30000150:	e1a02202 	mov	r2, r2, lsl #4
30000154:	e5933000 	ldr	r3, [r3]
30000158:	e1833002 	orr	r3, r3, r2
3000015c:	e5813000 	str	r3, [r1]
30000160:	e3a00b61 	mov	r0, #99328	; 0x18400
30000164:	e2800e2a 	add	r0, r0, #672	; 0x2a0
30000168:	ebffffc5 	bl	30000084 <delay>
3000016c:	e51b3010 	ldr	r3, [fp, #-16]
30000170:	e2833001 	add	r3, r3, #1	; 0x1
30000174:	e50b3010 	str	r3, [fp, #-16]
30000178:	e51b3010 	ldr	r3, [fp, #-16]
3000017c:	e3530008 	cmp	r3, #8	; 0x8
30000180:	1affffe0 	bne	30000108 <led_test+0x50>
30000184:	e3a03000 	mov	r3, #0	; 0x0
30000188:	e50b3010 	str	r3, [fp, #-16]
3000018c:	eaffffdd 	b	30000108 <led_test+0x50>

30000190 <uart0_init>:
30000190:	e1a0c00d 	mov	ip, sp
30000194:	e92dd800 	stmdb	sp!, {fp, ip, lr, pc}
30000198:	e24cb004 	sub	fp, ip, #4	; 0x4
3000019c:	e3a02456 	mov	r2, #1442840576	; 0x56000000
300001a0:	e2822070 	add	r2, r2, #112	; 0x70
300001a4:	e3a03456 	mov	r3, #1442840576	; 0x56000000
300001a8:	e2833070 	add	r3, r3, #112	; 0x70
300001ac:	e5933000 	ldr	r3, [r3]
300001b0:	e3c330f0 	bic	r3, r3, #240	; 0xf0
300001b4:	e5823000 	str	r3, [r2]
300001b8:	e3a02456 	mov	r2, #1442840576	; 0x56000000
300001bc:	e2822070 	add	r2, r2, #112	; 0x70
300001c0:	e3a03456 	mov	r3, #1442840576	; 0x56000000
300001c4:	e2833070 	add	r3, r3, #112	; 0x70
300001c8:	e5933000 	ldr	r3, [r3]
300001cc:	e38330a0 	orr	r3, r3, #160	; 0xa0
300001d0:	e5823000 	str	r3, [r2]
300001d4:	e3a02456 	mov	r2, #1442840576	; 0x56000000
300001d8:	e2822078 	add	r2, r2, #120	; 0x78
300001dc:	e3a03456 	mov	r3, #1442840576	; 0x56000000
300001e0:	e2833078 	add	r3, r3, #120	; 0x78
300001e4:	e5933000 	ldr	r3, [r3]
300001e8:	e3c3300c 	bic	r3, r3, #12	; 0xc
300001ec:	e5823000 	str	r3, [r2]
300001f0:	e3a02245 	mov	r2, #1342177284	; 0x50000004
300001f4:	e3a03005 	mov	r3, #5	; 0x5
300001f8:	e5823000 	str	r3, [r2]
300001fc:	e3a03205 	mov	r3, #1342177280	; 0x50000000
30000200:	e2833028 	add	r3, r3, #40	; 0x28
30000204:	e3a0201a 	mov	r2, #26	; 0x1a
30000208:	e5832000 	str	r2, [r3]
3000020c:	e3a02205 	mov	r2, #1342177280	; 0x50000000
30000210:	e3a03003 	mov	r3, #3	; 0x3
30000214:	e5823000 	str	r3, [r2]
30000218:	e89da800 	ldmia	sp, {fp, sp, pc}

3000021c <putchar>:
3000021c:	e1a0c00d 	mov	ip, sp
30000220:	e92dd800 	stmdb	sp!, {fp, ip, lr, pc}
30000224:	e24cb004 	sub	fp, ip, #4	; 0x4
30000228:	e24dd004 	sub	sp, sp, #4	; 0x4
3000022c:	e50b0010 	str	r0, [fp, #-16]
30000230:	e3a03205 	mov	r3, #1342177280	; 0x50000000
30000234:	e2833010 	add	r3, r3, #16	; 0x10
30000238:	e5933000 	ldr	r3, [r3]
3000023c:	e2033004 	and	r3, r3, #4	; 0x4
30000240:	e3530000 	cmp	r3, #0	; 0x0
30000244:	1a000000 	bne	3000024c <putchar+0x30>
30000248:	eafffff8 	b	30000230 <putchar+0x14>
3000024c:	e3a03205 	mov	r3, #1342177280	; 0x50000000
30000250:	e2833020 	add	r3, r3, #32	; 0x20
30000254:	e51b2010 	ldr	r2, [fp, #-16]
30000258:	e5c32000 	strb	r2, [r3]
3000025c:	e1a00003 	mov	r0, r3
30000260:	e89da808 	ldmia	sp, {r3, fp, sp, pc}

30000264 <getchar>:
30000264:	e1a0c00d 	mov	ip, sp
30000268:	e92dd800 	stmdb	sp!, {fp, ip, lr, pc}
3000026c:	e24cb004 	sub	fp, ip, #4	; 0x4
30000270:	e3a03205 	mov	r3, #1342177280	; 0x50000000
30000274:	e2833010 	add	r3, r3, #16	; 0x10
30000278:	e5933000 	ldr	r3, [r3]
3000027c:	e2033001 	and	r3, r3, #1	; 0x1
30000280:	e3530000 	cmp	r3, #0	; 0x0
30000284:	1a000000 	bne	3000028c <getchar+0x28>
30000288:	eafffff8 	b	30000270 <getchar+0xc>
3000028c:	e3a03205 	mov	r3, #1342177280	; 0x50000000
30000290:	e2833024 	add	r3, r3, #36	; 0x24
30000294:	e5d33000 	ldrb	r3, [r3]
30000298:	e20330ff 	and	r3, r3, #255	; 0xff
3000029c:	e1a00003 	mov	r0, r3
300002a0:	e89da800 	ldmia	sp, {fp, sp, pc}

300002a4 <puts>:
300002a4:	e1a0c00d 	mov	ip, sp
300002a8:	e92dd800 	stmdb	sp!, {fp, ip, lr, pc}
300002ac:	e24cb004 	sub	fp, ip, #4	; 0x4
300002b0:	e24dd004 	sub	sp, sp, #4	; 0x4
300002b4:	e50b0010 	str	r0, [fp, #-16]
300002b8:	e51b3010 	ldr	r3, [fp, #-16]
300002bc:	e5d33000 	ldrb	r3, [r3]
300002c0:	e3530000 	cmp	r3, #0	; 0x0
300002c4:	0a000007 	beq	300002e8 <puts+0x44>
300002c8:	e51b3010 	ldr	r3, [fp, #-16]
300002cc:	e5d33000 	ldrb	r3, [r3]
300002d0:	e1a00003 	mov	r0, r3
300002d4:	ebffffd0 	bl	3000021c <putchar>
300002d8:	e51b3010 	ldr	r3, [fp, #-16]
300002dc:	e2833001 	add	r3, r3, #1	; 0x1
300002e0:	e50b3010 	str	r3, [fp, #-16]
300002e4:	eafffff3 	b	300002b8 <puts+0x14>
300002e8:	e1a00003 	mov	r0, r3
300002ec:	e89da808 	ldmia	sp, {r3, fp, sp, pc}

300002f0 <printHex>:
300002f0:	e1a0c00d 	mov	ip, sp
300002f4:	e92dd800 	stmdb	sp!, {fp, ip, lr, pc}
300002f8:	e24cb004 	sub	fp, ip, #4	; 0x4
300002fc:	e24dd010 	sub	sp, sp, #16	; 0x10
30000300:	e50b0010 	str	r0, [fp, #-16]
30000304:	e3a03000 	mov	r3, #0	; 0x0
30000308:	e50b3014 	str	r3, [fp, #-20]
3000030c:	e51b3014 	ldr	r3, [fp, #-20]
30000310:	e3530007 	cmp	r3, #7	; 0x7
30000314:	ca00000e 	bgt	30000354 <printHex+0x64>
30000318:	e3e0200f 	mvn	r2, #15	; 0xf
3000031c:	e51b3014 	ldr	r3, [fp, #-20]
30000320:	e24b100c 	sub	r1, fp, #12	; 0xc
30000324:	e0813003 	add	r3, r1, r3
30000328:	e0832002 	add	r2, r3, r2
3000032c:	e51b3010 	ldr	r3, [fp, #-16]
30000330:	e203300f 	and	r3, r3, #15	; 0xf
30000334:	e5c23000 	strb	r3, [r2]
30000338:	e51b3010 	ldr	r3, [fp, #-16]
3000033c:	e1a03223 	mov	r3, r3, lsr #4
30000340:	e50b3010 	str	r3, [fp, #-16]
30000344:	e51b3014 	ldr	r3, [fp, #-20]
30000348:	e2833001 	add	r3, r3, #1	; 0x1
3000034c:	e50b3014 	str	r3, [fp, #-20]
30000350:	eaffffed 	b	3000030c <printHex+0x1c>
30000354:	e59f00d8 	ldr	r0, [pc, #216]	; 30000434 <.text+0x434>
30000358:	ebffffd1 	bl	300002a4 <puts>
3000035c:	e3a03007 	mov	r3, #7	; 0x7
30000360:	e50b3014 	str	r3, [fp, #-20]
30000364:	e51b3014 	ldr	r3, [fp, #-20]
30000368:	e3530000 	cmp	r3, #0	; 0x0
3000036c:	ba00002e 	blt	3000042c <printHex+0x13c>
30000370:	e3e0200f 	mvn	r2, #15	; 0xf
30000374:	e51b3014 	ldr	r3, [fp, #-20]
30000378:	e24b100c 	sub	r1, fp, #12	; 0xc
3000037c:	e0813003 	add	r3, r1, r3
30000380:	e0833002 	add	r3, r3, r2
30000384:	e5d33000 	ldrb	r3, [r3]
30000388:	e3530009 	cmp	r3, #9	; 0x9
3000038c:	8a000009 	bhi	300003b8 <printHex+0xc8>
30000390:	e3e0200f 	mvn	r2, #15	; 0xf
30000394:	e51b3014 	ldr	r3, [fp, #-20]
30000398:	e24b100c 	sub	r1, fp, #12	; 0xc
3000039c:	e0813003 	add	r3, r1, r3
300003a0:	e0833002 	add	r3, r3, r2
300003a4:	e5d33000 	ldrb	r3, [r3]
300003a8:	e2833030 	add	r3, r3, #48	; 0x30
300003ac:	e1a00003 	mov	r0, r3
300003b0:	ebffff99 	bl	3000021c <putchar>
300003b4:	ea000018 	b	3000041c <printHex+0x12c>
300003b8:	e3e0200f 	mvn	r2, #15	; 0xf
300003bc:	e51b3014 	ldr	r3, [fp, #-20]
300003c0:	e24b100c 	sub	r1, fp, #12	; 0xc
300003c4:	e0813003 	add	r3, r1, r3
300003c8:	e0833002 	add	r3, r3, r2
300003cc:	e5d33000 	ldrb	r3, [r3]
300003d0:	e3530009 	cmp	r3, #9	; 0x9
300003d4:	9a000010 	bls	3000041c <printHex+0x12c>
300003d8:	e3e0200f 	mvn	r2, #15	; 0xf
300003dc:	e51b3014 	ldr	r3, [fp, #-20]
300003e0:	e24b100c 	sub	r1, fp, #12	; 0xc
300003e4:	e0813003 	add	r3, r1, r3
300003e8:	e0833002 	add	r3, r3, r2
300003ec:	e5d33000 	ldrb	r3, [r3]
300003f0:	e353000f 	cmp	r3, #15	; 0xf
300003f4:	8a000008 	bhi	3000041c <printHex+0x12c>
300003f8:	e3e0200f 	mvn	r2, #15	; 0xf
300003fc:	e51b3014 	ldr	r3, [fp, #-20]
30000400:	e24b100c 	sub	r1, fp, #12	; 0xc
30000404:	e0813003 	add	r3, r1, r3
30000408:	e0833002 	add	r3, r3, r2
3000040c:	e5d33000 	ldrb	r3, [r3]
30000410:	e2833037 	add	r3, r3, #55	; 0x37
30000414:	e1a00003 	mov	r0, r3
30000418:	ebffff7f 	bl	3000021c <putchar>
3000041c:	e51b3014 	ldr	r3, [fp, #-20]
30000420:	e2433001 	sub	r3, r3, #1	; 0x1
30000424:	e50b3014 	str	r3, [fp, #-20]
30000428:	eaffffcd 	b	30000364 <printHex+0x74>
3000042c:	e24bd00c 	sub	sp, fp, #12	; 0xc
30000430:	e89da800 	ldmia	sp, {fp, sp, pc}
30000434:	30000798 	mulcc	r0, r8, r7

30000438 <sdram_init>:
30000438:	e1a0c00d 	mov	ip, sp
3000043c:	e92dd800 	stmdb	sp!, {fp, ip, lr, pc}
30000440:	e24cb004 	sub	fp, ip, #4	; 0x4
30000444:	e3a02312 	mov	r2, #1207959552	; 0x48000000
30000448:	e3a03422 	mov	r3, #570425344	; 0x22000000
3000044c:	e5823000 	str	r3, [r2]
30000450:	e3a02312 	mov	r2, #1207959552	; 0x48000000
30000454:	e282201c 	add	r2, r2, #28	; 0x1c
30000458:	e3a03906 	mov	r3, #98304	; 0x18000
3000045c:	e2833001 	add	r3, r3, #1	; 0x1
30000460:	e5823000 	str	r3, [r2]
30000464:	e3a02312 	mov	r2, #1207959552	; 0x48000000
30000468:	e2822020 	add	r2, r2, #32	; 0x20
3000046c:	e3a03906 	mov	r3, #98304	; 0x18000
30000470:	e2833001 	add	r3, r3, #1	; 0x1
30000474:	e5823000 	str	r3, [r2]
30000478:	e3a02312 	mov	r2, #1207959552	; 0x48000000
3000047c:	e2822024 	add	r2, r2, #36	; 0x24
30000480:	e3a03721 	mov	r3, #8650752	; 0x840000
30000484:	e2833e4f 	add	r3, r3, #1264	; 0x4f0
30000488:	e2833005 	add	r3, r3, #5	; 0x5
3000048c:	e5823000 	str	r3, [r2]
30000490:	e3a03312 	mov	r3, #1207959552	; 0x48000000
30000494:	e2833028 	add	r3, r3, #40	; 0x28
30000498:	e3a020b1 	mov	r2, #177	; 0xb1
3000049c:	e5832000 	str	r2, [r3]
300004a0:	e3a03312 	mov	r3, #1207959552	; 0x48000000
300004a4:	e283302c 	add	r3, r3, #44	; 0x2c
300004a8:	e3a02020 	mov	r2, #32	; 0x20
300004ac:	e5832000 	str	r2, [r3]
300004b0:	e3a03312 	mov	r3, #1207959552	; 0x48000000
300004b4:	e2833030 	add	r3, r3, #48	; 0x30
300004b8:	e3a02020 	mov	r2, #32	; 0x20
300004bc:	e5832000 	str	r2, [r3]
300004c0:	e89da800 	ldmia	sp, {fp, sp, pc}

300004c4 <sdram_init2>:
300004c4:	e1a0c00d 	mov	ip, sp
300004c8:	e92dd800 	stmdb	sp!, {fp, ip, lr, pc}
300004cc:	e24cb004 	sub	fp, ip, #4	; 0x4
300004d0:	e24dd03c 	sub	sp, sp, #60	; 0x3c
300004d4:	e59f3088 	ldr	r3, [pc, #136]	; 30000564 <.text+0x564>
300004d8:	e24be040 	sub	lr, fp, #64	; 0x40
300004dc:	e1a0c003 	mov	ip, r3
300004e0:	e8bc000f 	ldmia	ip!, {r0, r1, r2, r3}
300004e4:	e8ae000f 	stmia	lr!, {r0, r1, r2, r3}
300004e8:	e8bc000f 	ldmia	ip!, {r0, r1, r2, r3}
300004ec:	e8ae000f 	stmia	lr!, {r0, r1, r2, r3}
300004f0:	e8bc000f 	ldmia	ip!, {r0, r1, r2, r3}
300004f4:	e8ae000f 	stmia	lr!, {r0, r1, r2, r3}
300004f8:	e59c3000 	ldr	r3, [ip]
300004fc:	e58e3000 	str	r3, [lr]
30000500:	e3a03312 	mov	r3, #1207959552	; 0x48000000
30000504:	e50b3044 	str	r3, [fp, #-68]
30000508:	e3a03000 	mov	r3, #0	; 0x0
3000050c:	e50b3048 	str	r3, [fp, #-72]
30000510:	e51b3048 	ldr	r3, [fp, #-72]
30000514:	e353000c 	cmp	r3, #12	; 0xc
30000518:	ca00000f 	bgt	3000055c <sdram_init2+0x98>
3000051c:	e51b1044 	ldr	r1, [fp, #-68]
30000520:	e51b3048 	ldr	r3, [fp, #-72]
30000524:	e3e02033 	mvn	r2, #51	; 0x33
30000528:	e1a03103 	mov	r3, r3, lsl #2
3000052c:	e24b000c 	sub	r0, fp, #12	; 0xc
30000530:	e0833000 	add	r3, r3, r0
30000534:	e0833002 	add	r3, r3, r2
30000538:	e5933000 	ldr	r3, [r3]
3000053c:	e5813000 	str	r3, [r1]
30000540:	e51b3044 	ldr	r3, [fp, #-68]
30000544:	e2833004 	add	r3, r3, #4	; 0x4
30000548:	e50b3044 	str	r3, [fp, #-68]
3000054c:	e51b3048 	ldr	r3, [fp, #-72]
30000550:	e2833001 	add	r3, r3, #1	; 0x1
30000554:	e50b3048 	str	r3, [fp, #-72]
30000558:	eaffffec 	b	30000510 <sdram_init2+0x4c>
3000055c:	e24bd00c 	sub	sp, fp, #12	; 0xc
30000560:	e89da800 	ldmia	sp, {fp, sp, pc}
30000564:	3000079c 	mulcc	r0, ip, r7

30000568 <sdram_test>:
30000568:	e1a0c00d 	mov	ip, sp
3000056c:	e92dd800 	stmdb	sp!, {fp, ip, lr, pc}
30000570:	e24cb004 	sub	fp, ip, #4	; 0x4
30000574:	e24dd00c 	sub	sp, sp, #12	; 0xc
30000578:	e3a03203 	mov	r3, #805306368	; 0x30000000
3000057c:	e50b3010 	str	r3, [fp, #-16]
30000580:	e3a03000 	mov	r3, #0	; 0x0
30000584:	e50b3014 	str	r3, [fp, #-20]
30000588:	e51b2014 	ldr	r2, [fp, #-20]
3000058c:	e3a03ff9 	mov	r3, #996	; 0x3e4
30000590:	e2833003 	add	r3, r3, #3	; 0x3
30000594:	e1520003 	cmp	r2, r3
30000598:	ca000008 	bgt	300005c0 <sdram_test+0x58>
3000059c:	e51b2010 	ldr	r2, [fp, #-16]
300005a0:	e51b3014 	ldr	r3, [fp, #-20]
300005a4:	e0822003 	add	r2, r2, r3
300005a8:	e3a03055 	mov	r3, #85	; 0x55
300005ac:	e5c23000 	strb	r3, [r2]
300005b0:	e51b3014 	ldr	r3, [fp, #-20]
300005b4:	e2833001 	add	r3, r3, #1	; 0x1
300005b8:	e50b3014 	str	r3, [fp, #-20]
300005bc:	eafffff1 	b	30000588 <sdram_test+0x20>
300005c0:	e3a03000 	mov	r3, #0	; 0x0
300005c4:	e50b3014 	str	r3, [fp, #-20]
300005c8:	e51b2014 	ldr	r2, [fp, #-20]
300005cc:	e3a03ff9 	mov	r3, #996	; 0x3e4
300005d0:	e2833003 	add	r3, r3, #3	; 0x3
300005d4:	e1520003 	cmp	r2, r3
300005d8:	ca00000d 	bgt	30000614 <sdram_test+0xac>
300005dc:	e51b2010 	ldr	r2, [fp, #-16]
300005e0:	e51b3014 	ldr	r3, [fp, #-20]
300005e4:	e0823003 	add	r3, r2, r3
300005e8:	e5d33000 	ldrb	r3, [r3]
300005ec:	e20330ff 	and	r3, r3, #255	; 0xff
300005f0:	e3530055 	cmp	r3, #85	; 0x55
300005f4:	0a000002 	beq	30000604 <sdram_test+0x9c>
300005f8:	e3e03000 	mvn	r3, #0	; 0x0
300005fc:	e50b3018 	str	r3, [fp, #-24]
30000600:	ea000005 	b	3000061c <sdram_test+0xb4>
30000604:	e51b3014 	ldr	r3, [fp, #-20]
30000608:	e2833001 	add	r3, r3, #1	; 0x1
3000060c:	e50b3014 	str	r3, [fp, #-20]
30000610:	eaffffec 	b	300005c8 <sdram_test+0x60>
30000614:	e3a03000 	mov	r3, #0	; 0x0
30000618:	e50b3018 	str	r3, [fp, #-24]
3000061c:	e51b0018 	ldr	r0, [fp, #-24]
30000620:	e24bd00c 	sub	sp, fp, #12	; 0xc
30000624:	e89da800 	ldmia	sp, {fp, sp, pc}

30000628 <copy2sdram>:
30000628:	e1a0c00d 	mov	ip, sp
3000062c:	e92dd800 	stmdb	sp!, {fp, ip, lr, pc}
30000630:	e24cb004 	sub	fp, ip, #4	; 0x4
30000634:	e24dd00c 	sub	sp, sp, #12	; 0xc
30000638:	e59f3058 	ldr	r3, [pc, #88]	; 30000698 <.text+0x698>
3000063c:	e50b3010 	str	r3, [fp, #-16]
30000640:	e59f3054 	ldr	r3, [pc, #84]	; 3000069c <.text+0x69c>
30000644:	e50b3014 	str	r3, [fp, #-20]
30000648:	e3a03000 	mov	r3, #0	; 0x0
3000064c:	e50b3018 	str	r3, [fp, #-24]
30000650:	e51b2010 	ldr	r2, [fp, #-16]
30000654:	e51b3014 	ldr	r3, [fp, #-20]
30000658:	e1520003 	cmp	r2, r3
3000065c:	2a00000b 	bcs	30000690 <copy2sdram+0x68>
30000660:	e24bc010 	sub	ip, fp, #16	; 0x10
30000664:	e59c2000 	ldr	r2, [ip]
30000668:	e24b1018 	sub	r1, fp, #24	; 0x18
3000066c:	e5913000 	ldr	r3, [r1]
30000670:	e5930000 	ldr	r0, [r3]
30000674:	e2833004 	add	r3, r3, #4	; 0x4
30000678:	e5813000 	str	r3, [r1]
3000067c:	e1a03002 	mov	r3, r2
30000680:	e5830000 	str	r0, [r3]
30000684:	e2822004 	add	r2, r2, #4	; 0x4
30000688:	e58c2000 	str	r2, [ip]
3000068c:	eaffffef 	b	30000650 <copy2sdram+0x28>
30000690:	e24bd00c 	sub	sp, fp, #12	; 0xc
30000694:	e89da800 	ldmia	sp, {fp, sp, pc}
30000698:	30000000 	andcc	r0, r0, r0
3000069c:	300007e8 	andcc	r0, r0, r8, ror #15

300006a0 <clean_bss>:
300006a0:	e1a0c00d 	mov	ip, sp
300006a4:	e92dd800 	stmdb	sp!, {fp, ip, lr, pc}
300006a8:	e24cb004 	sub	fp, ip, #4	; 0x4
300006ac:	e24dd008 	sub	sp, sp, #8	; 0x8
300006b0:	e59f3040 	ldr	r3, [pc, #64]	; 300006f8 <.text+0x6f8>
300006b4:	e50b3010 	str	r3, [fp, #-16]
300006b8:	e59f303c 	ldr	r3, [pc, #60]	; 300006fc <.text+0x6fc>
300006bc:	e50b3014 	str	r3, [fp, #-20]
300006c0:	e51b2010 	ldr	r2, [fp, #-16]
300006c4:	e51b3014 	ldr	r3, [fp, #-20]
300006c8:	e1520003 	cmp	r2, r3
300006cc:	8a000007 	bhi	300006f0 <clean_bss+0x50>
300006d0:	e24b0010 	sub	r0, fp, #16	; 0x10
300006d4:	e5903000 	ldr	r3, [r0]
300006d8:	e1a01003 	mov	r1, r3
300006dc:	e3a02000 	mov	r2, #0	; 0x0
300006e0:	e5812000 	str	r2, [r1]
300006e4:	e2833004 	add	r3, r3, #4	; 0x4
300006e8:	e5803000 	str	r3, [r0]
300006ec:	eafffff3 	b	300006c0 <clean_bss+0x20>
300006f0:	e24bd00c 	sub	sp, fp, #12	; 0xc
300006f4:	e89da800 	ldmia	sp, {fp, sp, pc}
300006f8:	300007e8 	andcc	r0, r0, r8, ror #15
300006fc:	300007f0 	strccd	r0, [r0], -r0

30000700 <main>:
30000700:	e1a0c00d 	mov	ip, sp
30000704:	e92dd800 	stmdb	sp!, {fp, ip, lr, pc}
30000708:	e24cb004 	sub	fp, ip, #4	; 0x4
3000070c:	ebfffe9f 	bl	30000190 <uart0_init>
30000710:	e59f006c 	ldr	r0, [pc, #108]	; 30000784 <.text+0x784>
30000714:	ebfffee2 	bl	300002a4 <puts>
30000718:	e59f3068 	ldr	r3, [pc, #104]	; 30000788 <.text+0x788>
3000071c:	e5930000 	ldr	r0, [r3]
30000720:	ebfffef2 	bl	300002f0 <printHex>
30000724:	e59f0060 	ldr	r0, [pc, #96]	; 3000078c <.text+0x78c>
30000728:	ebfffedd 	bl	300002a4 <puts>
3000072c:	e59f305c 	ldr	r3, [pc, #92]	; 30000790 <.text+0x790>
30000730:	e5d33000 	ldrb	r3, [r3]
30000734:	e1a00003 	mov	r0, r3
30000738:	ebfffeb7 	bl	3000021c <putchar>
3000073c:	e59f204c 	ldr	r2, [pc, #76]	; 30000790 <.text+0x790>
30000740:	e59f3048 	ldr	r3, [pc, #72]	; 30000790 <.text+0x790>
30000744:	e5d33000 	ldrb	r3, [r3]
30000748:	e2833001 	add	r3, r3, #1	; 0x1
3000074c:	e5c23000 	strb	r3, [r2]
30000750:	e59f303c 	ldr	r3, [pc, #60]	; 30000794 <.text+0x794>
30000754:	e5d33000 	ldrb	r3, [r3]
30000758:	e1a00003 	mov	r0, r3
3000075c:	ebfffeae 	bl	3000021c <putchar>
30000760:	e59f202c 	ldr	r2, [pc, #44]	; 30000794 <.text+0x794>
30000764:	e59f3028 	ldr	r3, [pc, #40]	; 30000794 <.text+0x794>
30000768:	e5d33000 	ldrb	r3, [r3]
3000076c:	e2833001 	add	r3, r3, #1	; 0x1
30000770:	e5c23000 	strb	r3, [r2]
30000774:	e3a0093d 	mov	r0, #999424	; 0xf4000
30000778:	e2800d09 	add	r0, r0, #576	; 0x240
3000077c:	ebfffe40 	bl	30000084 <delay>
30000780:	eaffffe9 	b	3000072c <main+0x2c>
30000784:	300007d4 	ldrccd	r0, [r0], -r4
30000788:	300007e8 	andcc	r0, r0, r8, ror #15
3000078c:	300007e0 	andcc	r0, r0, r0, ror #15
30000790:	300007e4 	andcc	r0, r0, r4, ror #15
30000794:	300007e5 	andcc	r0, r0, r5, ror #15
Disassembly of section .rodata:

30000798 <.rodata>:
30000798:	00007830 	andeq	r7, r0, r0, lsr r8
3000079c:	22000000 	andcs	r0, r0, #0	; 0x0
300007a0:	00000700 	andeq	r0, r0, r0, lsl #14
300007a4:	00000700 	andeq	r0, r0, r0, lsl #14
300007a8:	00000700 	andeq	r0, r0, r0, lsl #14
300007ac:	00000700 	andeq	r0, r0, r0, lsl #14
300007b0:	00000700 	andeq	r0, r0, r0, lsl #14
300007b4:	00000700 	andeq	r0, r0, r0, lsl #14
300007b8:	00018001 	andeq	r8, r1, r1
300007bc:	00018001 	andeq	r8, r1, r1
300007c0:	008404f5 	streqd	r0, [r4], r5
300007c4:	000000b1 	streqh	r0, [r0], -r1
300007c8:	00000020 	andeq	r0, r0, r0, lsr #32
300007cc:	00000020 	andeq	r0, r0, r0, lsr #32
300007d0:	00000042 	andeq	r0, r0, r2, asr #32
300007d4:	5f670d0a 	swipl	0x00670d0a
300007d8:	203d2041 	eorcss	r2, sp, r1, asr #32
300007dc:	00000000 	andeq	r0, r0, r0
300007e0:	00000d0a 	andeq	r0, r0, sl, lsl #26
Disassembly of section .data:

300007e4 <g_Char>:
300007e4:	Address 0x300007e4 is out of bounds.


300007e5 <g_Char3>:
300007e5:	Address 0x300007e5 is out of bounds.

Disassembly of section .bss:

300007e8 <g_A>:
300007e8:	00000000 	andeq	r0, r0, r0

300007ec <g_B>:
300007ec:	00000000 	andeq	r0, r0, r0
Disassembly of section .comment:

00000000 <.comment>:
   0:	43434700 	cmpmi	r3, #0	; 0x0
   4:	4728203a 	undefined
   8:	2029554e 	eorcs	r5, r9, lr, asr #10
   c:	2e342e33 	mrccs	14, 1, r2, cr4, cr3, {1}
  10:	47000035 	smladxmi	r0, r5, r0, r0
  14:	203a4343 	eorcss	r4, sl, r3, asr #6
  18:	554e4728 	strplb	r4, [lr, #-1832]
  1c:	2e332029 	cdpcs	0, 3, cr2, cr3, cr9, {1}
  20:	00352e34 	eoreqs	r2, r5, r4, lsr lr
  24:	43434700 	cmpmi	r3, #0	; 0x0
  28:	4728203a 	undefined
  2c:	2029554e 	eorcs	r5, r9, lr, asr #10
  30:	2e342e33 	mrccs	14, 1, r2, cr4, cr3, {1}
  34:	47000035 	smladxmi	r0, r5, r0, r0
  38:	203a4343 	eorcss	r4, sl, r3, asr #6
  3c:	554e4728 	strplb	r4, [lr, #-1832]
  40:	2e332029 	cdpcs	0, 3, cr2, cr3, cr9, {1}
  44:	00352e34 	eoreqs	r2, r5, r4, lsr lr

.lds

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
sdram.lds

SECTIONS
{
	. = 0x30000000;

	__code_start = .;

	. = ALIGN(4);
	.text      :
	{
	  *(.text)
	}

	. = ALIGN(4);
	.rodata : { *(.rodata) }

	. = ALIGN(4);
	.data : { *(.data) }

	. = ALIGN(4);
	__bss_start = .;
	.bss : { *(.bss) *(.COMMON) }
	_end = .;
}

Makefile

1
2
3
4
5
6
7
8
9
10
11
12
all:
	arm-linux-gcc -c -o led.o led.c
	arm-linux-gcc -c -o uart.o uart.c
	arm-linux-gcc -c -o init.o init.c
	arm-linux-gcc -c -o main.o main.c
	arm-linux-gcc -c -o start.o start.S
	#arm-linux-ld -Ttext 0 -Tdata 0x30000000  start.o led.o uart.o init.o main.o -o sdram.elf
	arm-linux-ld -T sdram.lds start.o led.o uart.o init.o main.o -o sdram.elf
	arm-linux-objcopy -O binary -S sdram.elf sdram.bin
	arm-linux-objdump -D sdram.elf > sdram.dis
clean:
	rm *.bin *.o *.elf *.dis

发表于 更新于 分类于 阅读次数：
本文字数： 4.5k 阅读时长 ≈ 4 分钟

2018年2月3日 下午6:21

.c代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
init.c

#include "s3c2440_soc.h"

void sdram_init(void)
{
	BWSCON = 0x22000000;

	BANKCON6 = 0x18001;
	BANKCON7 = 0x18001;

	REFRESH  = 0x8404f5;

	BANKSIZE = 0xb1;

	MRSRB6   = 0x20;
	MRSRB7   = 0x20;
}

#if 0


/**************************************************************************   
* 设置控制SDRAM的13个寄存器
* 使用位置无关代码
**************************************************************************/   
void memsetup(void)
{
	unsigned long *p = (unsigned long *)MEM_CTL_BASE;	
	p[0] = 0x22111110;		//BWSCON
	p[1] = 0x00000700;		//BANKCON0
	p[2] = 0x00000700;		//BANKCON1
	p[3] = 0x00000700;		//BANKCON2
	p[4] = 0x00000700;		//BANKCON3	
	p[5] = 0x00000700;		//BANKCON4
	p[6] = 0x00000700;		//BANKCON5
	p[7] = 0x00018005;		//BANKCON6
	p[8] = 0x00018005;		//BANKCON7
	p[9] = 0x008e07a3;		//REFRESH,HCLK=12MHz:0x008e07a3,HCLK=100MHz:0x008e04f4
	p[10] = 0x000000b2;		//BANKSIZE
	p[11] = 0x00000030;		//MRSRB6
	p[12] = 0x00000030;		//MRSRB7
}


#endif

void sdram_init2(void)
{
	unsigned int arr[] = {
		0x22000000, 	//BWSCON
		0x00000700, 	//BANKCON0
		0x00000700, 	//BANKCON1
		0x00000700, 	//BANKCON2
		0x00000700, 	//BANKCON3	
		0x00000700, 	//BANKCON4
		0x00000700, 	//BANKCON5
		0x18001, 	//BANKCON6
		0x18001, 	//BANKCON7
		0x8404f5, 	//REFRESH,HCLK=12MHz:0x008e07a3,HCLK=100MHz:0x008e04f4
		 0xb1,	//BANKSIZE
		 0x20,	//MRSRB6
		 0x20,	//MRSRB7

		};
	volatile unsigned int * p = (volatile unsigned int *)0x48000000;
	int i;

	for (i = 0; i < 13; i++)
	{
		*p = arr[i];
		p++;
	}
	
}


int sdram_test(void)
{
	volatile unsigned char *p = (volatile unsigned char *)0x30000000;
	int i;

	// write sdram
	for (i = 0; i < 1000; i++)
		p[i] = 0x55;

	// read sdram
	for (i = 0; i < 1000; i++)
		if (p[i] != 0x55)
			return -1;

	return 0;
}

void copy2sdram(void)
{
	/* 要从lds文件中获得 __code_start, __bss_start
	 * 然后从0地址把数据复制到__code_start
	 */

	extern int __code_start, __bss_start;

	volatile unsigned int *dest = (volatile unsigned int *)&__code_start;
	volatile unsigned int *end = (volatile unsigned int *)&__bss_start;
	volatile unsigned int *src = (volatile unsigned int *)0;

	while (dest < end)
	{
		*dest++ = *src++;
	}
}


void clean_bss(void)
{
	/* 要从lds文件中获得 __bss_start, _end
	 */
	extern int _end, __bss_start;

	volatile unsigned int *start = (volatile unsigned int *)&__bss_start;
	volatile unsigned int *end = (volatile unsigned int *)&_end;


	while (start <= end)
	{
		*start++ = 0;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
led.c

#include "s3c2440_soc.h"

void delay(volatile int d)
{
	while (d--);
}

int led_test(void)
{
	int val = 0;  /* val: 0b000, 0b111 */
	int tmp;

	/* 设置GPFCON让GPF4/5/6配置为输出引脚 */
	GPFCON &= ~((3<<8) | (3<<10) | (3<<12));
	GPFCON |=  ((1<<8) | (1<<10) | (1<<12));

	/* 循环点亮 */
	while (1)
	{
		tmp = ~val;
		tmp &= 7;
		GPFDAT &= ~(7<<4);
		GPFDAT |= (tmp<<4);
		delay(100000);
		val++;
		if (val == 8)
			val =0;
		
	}

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
main.c

#include "s3c2440_soc.h"
#include "uart.h"
#include "init.h"

char g_Char = 'A';
char g_Char3 = 'a';
const char g_Char2 = 'B';
int g_A = 0;
int g_B;

int main(void)
{
	uart0_init();

	puts("\n\rg_A = ");
	printHex(g_A);
	puts("\n\r");

	while (1)
	{
#if 0		
		puts("\n\rg_Char = ");
		printHex(g_Char);
		puts("\n\r");


		puts("\n\rg_Char3 = ");
		printHex(g_Char3);
		puts("\n\r");
#endif
		putchar(g_Char);
		g_Char++;

		putchar(g_Char3);
		g_Char3++;
		delay(1000000);
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
uart.c

#include "s3c2440_soc.h"


/* 115200,8n1 */
void uart0_init()
{
	/* 设置引脚用于串口 */
	/* GPH2,3用于TxD0, RxD0 */
	GPHCON &= ~((3<<4) | (3<<6));
	GPHCON |= ((2<<4) | (2<<6));

	GPHUP &= ~((1<<2) | (1<<3));  /* 使能内部上拉 */
	

	/* 设置波特率 */
	/* UBRDIVn = (int)( UART clock / ( buad rate x 16) ) –1
	 *  UART clock = 50M
	 *  UBRDIVn = (int)( 50000000 / ( 115200 x 16) ) –1 = 26
	 */
	UCON0 = 0x00000005; /* PCLK,中断/查询模式 */
	UBRDIV0 = 26;

	/* 设置数据格式 */
	ULCON0 = 0x00000003; /* 8n1: 8个数据位, 无较验位, 1个停止位 */

	/*  */

}

int putchar(int c)
{
	/* UTRSTAT0 */
	/* UTXH0 */

	while (!(UTRSTAT0 & (1<<2)));
	UTXH0 = (unsigned char)c;
	
}

int getchar(void)
{
	while (!(UTRSTAT0 & (1<<0)));
	return URXH0;
}

int puts(const char *s)
{
	while (*s)
	{
		putchar(*s);
		s++;
	}
}

/* 0xABCDEF12 */
void printHex(unsigned int val)
{
	int i;
	unsigned char arr[8];

	/* 先取出每一位的值 */
	for (i = 0; i < 8; i++)
	{
		arr[i] = val & 0xf;
		val >>= 4;   /* arr[0] = 2, arr[1] = 1, arr[2] = 0xF */
	}

	/* 打印 */
	puts("0x");
	for (i = 7; i >=0; i--)
	{
		if (arr[i] >= 0 && arr[i] <= 9)
			putchar(arr[i] + '0');
		else if(arr[i] >= 0xA && arr[i] <= 0xF)
			putchar(arr[i] - 0xA + 'A');
	}
}