lk编译机制

Ⅰ 如何编译预置obj 文件

1. 如何在preloader 中预置obj 文件？
Branch: GB, GB2, ICS, ICS2, JB, JB2
Step1. 首先获取obj 文件，如果是preloader 已有的Source code 需要预置为obj 文
件，那么可到如下路径获取obj 文件：mediatek/[source]/preloader/out
Step2. 在mediatek/[source]/preloader 目录下创建文件夹：myobjs，将Step1 中获取
的obj 文件放到该文件夹中
Step3. 修改mediatek/[source]/preloader/Makefile 文件，在该文件如下Code：
$(D_BIN)/$(PL_IMAGE_NAME).elf:
之前添加：
MYOBJS := $(D_ROOT)/myobj
Step4. 修改mediatek/[source]/preloader/Makefile 中$(D_BIN)/$(PL_IMAGE_NAME).elf
生成命令，将MYOBJS 加入：如下：
$(D_BIN)/$(PL_IMAGE_NAME).elf:
$(LD) --gc-sections -Bstatic -T$(MTK_PATH_PLATFORM)/link_descriptor.ld \
$(wildcard $(D_OBJ)/*) $(wildcard $(MYOBJS)/*) $(SECURITY_LIB) -Map
system.map -o $(D_BIN)/$(PL_IMAGE_NAME).elf
Step5. 如果添加的obj 文件在preloader 中有对应的Source code，还需要修改
Source code 对应的make File 文件，将该Source code 从make File 文件中删除，以
bmt.c 为例，需要修改medaitek/platform/$platform/preloader/src/drivers/makefile，
将bmt.c 从该文件的MOD_SRC 中删除
说明：preloader 的Source code 位于如下路径：
– mediatek/platform/$platform/preloader/
– mediatek/custom/$platform/preloader/
– mediatek/custom/common/preloader/
– mediatek/custom/$porject/preloader/
2. 如何在uboot 中预置obj 文件？
Branch: GB, GB2, ICS, ICS2
Case1. 该obj 文件是从第三方处获取，在codebase 原本不存在.c 文件，不需要编
译进某个lib 文件
Step1. 首先获取obj 文件
Step2. 在bootable/bootloader/uboot 目录下添加myobjs 文件夹，将Step1 中获取的
obj 文件放到该文件夹中
Step3. 修改bootable/bootloader/uboot/Makefile，在该文件如下Code：
GEN_UBOOT = \
之前添加：
MYCUSTOMOBJS := $(wildcard myobjs/*)
MEDIATEK CONFIDENTIAL
FOR zhanghui@ vanzotec.com USE ONLY
[email protected],time=2013-10-08 19:27:59,ip=180.166.121.198,doctitle=如何在preloader、uboot、lk、kernel中预置obj文件.docx,company=Vanzo_WCX
Step4. 修改bootable/bootloader/uboot/Makefile，将MYOBJSDIR 中的obj 文件添加
到u-boot 的生成命令中，如下：
GEN_UBOOT = \
UNDEF_SYM=`$(OBJDUMP) -x $(LIBBOARD) $(LIBS) | \
sed -n -e 's/.*$(SYM_PREFIX)__u_boot_cmd_.*/-u\1/p'|sort|uniq`;\
cd $(LNDIR) && $(LD) $(LDFLAGS) $$UNDEF_SYM $(MYCUSTOMOBJS)
$(__OBJS) \
Case2. 该obj 文件在Codebase 中存在对应的.c 文件，现在需要将.c 文件删除，替
换为obj 文件
Step1. 编译生成obj 文件，uboot 编译生成的obj 文件与其.c 文件位于同级目录下
Step2.在原先obj 文件目录下创建一个文件夹prebuilt，并将obj 文件放入其中，同
时将.c 文件删除
Step3. 修改包含该.c 文件的Makefile 文件(一般与.c 文件位于同级目录下)，将该obj
文件的名称从OBJS 变量中删除，同时在该Makefile 中添加一个变量，MYOBJS，将
该obj 文件添加到MYOBJS 中，以
bootable/bootloader/uboot/drivers/video/cfb_console.c 为例，修改该目录下的
Makefile 文件，将cfb_console.o 从变量OBJS 中删除，同时添加一行：
MYOBJS := cfb_console.o
Step4. 继续修改Step3 中的Makefile，将MYOBJS 添加到生成LIB 的命令中，如下：
$(LIB): $(OBJS) $(SOBJS)
$(AR) $(ARFLAGS) $@ $(OBJS) $(MYOBJS) $(SOBJS)
Case3. 某些模块，Uboot 和kernel 共用同一份Source code，比如LCM，这种情况
需要做特殊处理，以LCM 为例，如下：
Step1. 首先编译出obj 文件，路径位于：mediatek/custom/out/$project/uboot/lcm，
同时将要替换的Source code 删除(mediate/custom/common/kernel/lcm)
Step2. 在mediatek/custom/$project/uboot 下面添加lcm 文件夹，同时将Step1 中获
取到的obj 文件添加到该文件夹下，同时将原目录下的obj 文件删除(这里获取的
obj 文件一定要是Uboot 目录下的，不要到kernel 目录下获取这些obj 文件)
Step3. 修改mediatek/custom/common/uboot/Makefile 文件，将要替换的obj 文件
名称从COBJS 删除：COBJS += $(patsubst %.c, %.o, $(wildcard lcm/*.c))
Step4. 继续修改Step3 中的Makefile，添加如下Code：MYOBJS := $(addprefix $(obj),
$(wildcard lcm/*.o))，同时将MYOBJS 添加到$(LIB)的编译命令中，如下：
$(LIB): $(OBJS) $(SOBJS)
$(AR) $(ARFLAGS) $@ $(OBJS) $(MYOBJS) $(SOBJS)
说明：Uboot 的Source Code 主要位于如下路径：
– bootable/bootloader/uboot/
– mediatek/platform/$platform/uboot/
MEDIATEK CONFIDENTIAL
FOR zhanghui@ vanzotec.com USE ONLY
[email protected],time=2013-10-08 19:27:59,ip=180.166.121.198,doctitle=如何在preloader、uboot、lk、kernel中预置obj文件.docx,company=Vanzo_WCX
– mediatek/custom/$platform/uboot/
– mediatek/custom/common/uboot/
– mediatek/custom/$porject/uboot/
3. 如何在kernel 中预置obj 文件？
Branch：GB, GB2, ICS
– 比如要将xxx.c 用xxx.o 替代编译
– 先正常编译出xxx.o
– 然后在xxx.c 所在目录下创建prebuilt 目录，将xxx.o 放入
• 注意prebuilt 目录的目录名不能修改，否则在clean 阶段会被清除
– 修改xxx.c 所在目录下的Makefile 文件，原本已经有obj-y := xxx.o，在其后
面添加xxx-y := prebuilt/xxx.o 即可
– mediatek/custom/[XXX]/kernel 目录下对应的Source Code 没有Makefile 文件，
自己在Source code 对应的同级目录下添加一个Makefile 即可
Branch：ICS2, JB, JB2
– 比如要将debug.c 用debug.o 替代编译
– 先正常编译出debug.o (针对kernel 和lk, uboot 共用Source Code 的情况，
如LCM，这里获取 到的obj 文件一定要是kernel/out 目录下的)
– 然后将debug.o 复制到原先debug.c 所在目录下，并重命名为
debug.o_shipped
– 原先debug.c 同级目录下的Makefile 不变，依然保持为
obj-y:=debug.o；mediatek/custom/[XXX]/kernel 目录下对应的Source Code 没有
Makefile 文件，自己在Source code 对应的同级目录下添加一个Makefile 即可
– 重新编译kernel 即可
说明：kernel 的Source code 主要位于如下路径：
– kernel/
– mediatek/platform/$platform/kernel/
– mediatek/[source]/kernel/
– mediatek/custom/$platform/kernel/
– mediatek/custom/common/kernel/
– mediatek/custom/$porject/kernel/
4. 如何在lk 中预置obj 文件
Branch：JB，JB2
Step1. 在bootable/bootloader/lk/makefile 中添加：MYOBJ :=
Step2. 获取obj 文件，Codebase 编译生成的obj 文件位于
bootable/bootloader/lk/build-$project/custom/$project/lk 目录下
Step3. 将获取的obj 文件放到与.c 文件相同目录下；同时可将.c 文件删除
MEDIATEK CONFIDENTIAL
FOR zhanghui@ vanzotec.com USE ONLY
[email protected],time=2013-10-08 19:27:59,ip=180.166.121.198,doctitle=如何在preloader、uboot、lk、kernel中预置obj文件.docx,company=Vanzo_WCX
Step4. 将相应的.c 文件从包含该.c 文件的rules.mk(一般与.c 文件位于同级目录)中删
除
Step5. 将Step3 中添加的.o 文件在rules.mk 中添加到MYOBJ，比如MYOBJ += test.o
Step6. 打开bootable/bootloader/lk/make/build.mk，将MYOBJ 添加到OUTELF 的生
成命令中，如下：
else
$(OUTELF): $(ALLOBJS) $(LINKER_SCRIPT)
@echo linking $@
$(NOECHO)$(LD) $(LDFLAGS) -T $(LINKER_SCRIPT) $(ALLOBJS)
$(MYOBJ) $(LIBGCC) -o $@ endif
Step7. 如果要替换的.c 文件是lk 与kernel 共用的，比如lcm 模块，那么Step2 需要
做一下修改：将获取的obj 文件放到mediatek/custom/$project/lk/lcm 中，同时要
确保这里获取的obj 文件是bootable/bootloader/lk/build-
$project/custom/$project/lk 目录下的，不要到kernel/out 目录下获取这些obj 文件
说明：lk 的Source Code 主要位于如下路径：
– mediatek/platform/$platform/lk/
– mediatek/custom/$platform/lk/
– mediatek/custom/common/lk/
– mediatek/custom/$porject/lk/
– bootable/bootloader/lk/
MEDIATEK CONFIDENTIAL

Ⅱ QVector<QVector<cv::Point>> lk； qt平台中报错 怎么解决

声明lk时要在两个“>”之间加一个空格，否则与“>>”运算符相同了，编译器就认为是“>>”运算符了；也就是把声明语句改为:

QVector<QVector<cv::Point>>lk;

Ⅲ lk是什么意思

lk是like的缩写。

like

英 [laɪk] 美 [laɪk]

prep. 像

conj. 如同

adv. 大概；和......一样

adj. 相似的；同样的

v. 喜欢；想；愿意

n. 类似的人或物

At a distance he looks a bit like James Bond.

从远处看，他有点像詹姆斯·邦德。

近义词

fancy核心词汇

英 ['fænsi] 美 ['fænsi]

adj. 华丽装饰的；复杂的；引人注目的；时髦的；昂贵的；好的

n. 喜爱；幻想；想象力

vt. 想象；希望；迷恋

I have taken a fancy to that new bicycle.

我非常喜欢那辆新自行车。

Ⅳ 初学python，感受和C的不同

从开始看Python到现在也有半个多月了，前后看了Python核心编程和Dive
into
Python两本书。话说半个月看两本，是个人都知道有多囫囵吞枣，这也是因为我暂时没有需求拿这个做大型开发，主要是平时的小程序test用一用。所以我的策略是，整体浏览，用到时候现查。话说这核心编程第一版太古老了，老在讲2.2之前的东西，我看的翻译电子版，翻译得也不好，很晦涩。看完这个后还有点云里雾里，看网上人家说DIP好，啄木鸟还有免费电子文档，就找来看这个。怎么说呢，讲的比核心编程好，但不适合第一次看的初学者。我之所以觉得讲得好，是因为看核心编程，有些概念还有些模糊，看了这本书就明白不少了。要是初学者上来就看这本，保证不好理解。

下面就是在学习的过程中，在翻阅资料的过程中，总结的一些C和python比较明显的不同之处，有大方向的，也有细节的。肯定没有总结完，比如动态函数，lambda这些，我都懒得往上写了。实际上，作为两种完全不同的语言，下面这些差异只是冰山一角而已。权当抛砖引玉吧，至少应该对和我有相同研究兴趣，正在考虑是否学习另一门语言的朋友有点帮助。此文也算是DIP的学习笔记吧。顺带说一句，要是有朋友了解，可以帮忙推荐一下实战性强的Python教材，语言这东西，不多练手，光比划，是不可能学好的。

学习目的

我的以后的研究方向是嵌入式，显然，C语言是我的主要语言。我不是一个语言爱好者，我以前觉得，对于做研究而不是应用的人来说，了解多门语言，不如精通一门语言。之所以去看python，主要还是因为python更有利于快速开发一些程序，也是因为现在认识到，研究和应用是不能分离的。个人以为，要想在计算机工程的竞争中立足，必须懂C语言。因为真正要做高性能编程,
不可能将机器的体系架构抛到脑后让Python虚拟机（或Java虚拟机等）帮你搞定所有底层。越来越多的CPU
core，越来越恐怖的内存性能瓶颈，对于上层开发人员来说，无所谓，但是对高性能程序开发人员来说，这些是无法透明的。很多应用，还是自己掌控比较有效。这些场合中，汇编和C还是不可替代的。但是，光知道C是不够的，掌握一门面向对象语言，相对更高层的语言，不仅对以后的个人发展有利，也会对自己的技术认识产生帮助。

如果要问对我来说谁更重要，我觉得还是C更重要。C的学习曲线更陡，貌似简单，实际上到处都是陷阱，看上去比较简单低效的程序，也不是学1，2个月就能搞定的。谈到优化的深层次和难度嘛，需要的功底是按年算的。但是一旦你C语言的基础打好了，对计算机的理解，对其他语言的理解都是大有裨益的。比如，如果你有C基础，可以说，学过1天python，就能写的出来一些不短的程序。后面的优化也不是什么大不了的算法，都是非常基本的语句换来换去。当然这里不是说
Python不好，实际上，上层应用，Python比C方便的不是一个层次。

很多人觉得，既然懂C了，那么进一步掌握C＋＋应该是水到渠成，但C++不是C的超集，而我又不喜欢C＋＋的繁琐和巨大，所以才决定看一看Python。我很喜欢Python的优雅与快捷。

语言类型

和C不一样，Python是一种动态类型语言，又是强类型语言。这个分类怎么理解呢？大概是可以按照下列说明来分类的：

静态类型语言

一种在编译期间就确定数据类型的语言。大多数静态类型语言是通过要求在使用任一变量之前声明其数据类型来保证这一点的。Java和 C 是静态类型语言。

动态类型语言

一种在运行期间才去确定数据类型的语言，与静态类型相反。Python 是动态类型的，因为它们确定一个变量的类型是在您第一次给它赋值的时候。

强类型语言

一种总是强制类型定义的语言。Java 和 Python 是强制类型定义的。您有一个整数，如果不明确地进行转换 ，不能将把它当成一个字符串。

弱类型语言

一种类型可以被忽略的语言，与强类型相反。VBScript 是弱类型的。在 VBScript 中，您可以将字符串 ’12′ 和整数 3 进行连接得到字符串’123′，然后可以把它看成整数 123 ，所有这些都不需要任何的显示转换。

对象机制

具体怎么来理解这个“动态确定变量类型”，就要从Python的Object对象机制说起了。Objects（以下称对象）是Python对于数据的抽象，Python中所有的数据，都是由对象或者对象之间的关系表示的，函数是对象，字符串是对象，每个东西都是对象的概念。每一个对象都有三种属性：实体，类型和值。理解实体是理解对象中很重要的一步，实体一旦被创建，那么就一直不会改变，也不会被显式摧毁，同时通常意义来讲，决定对象所支持的操作方式的类型（type，包括number，string，tuple及其他）也不会改变，改变的只可能是它的值。如果要找一个具体点的说明，实体就相当于对象在内存中的地址，是本质存在。而类型和值都只是实体的外在呈现。然后Python提供一些接口让使用者和对象交互，比如id(）函数用来获得对象实体的整形表示（实际在这里就是地址），type()函数获取其类型。

这个object机制，就是c所不具备的，主要体现在下面几点：

1 刚才说了，c是一个静态类型语言，我们可以定义int a, char
b等等，但必须是在源代码里面事先规定。比如我们可以在Python里面任意一处直接规定a =
“lk”，这样，a的类型就是string，这是在其赋值的时候才决定的，我们无须在代码中明确写出。而在C里面，我们必须显式规定char *a =
“lk”，也就是人工事先规定好a的类型

2 由于在C中，没有对象这个概念，只有“数据的表示”，比如说，如果有两个int变量a和b，我们想比较大小，可以用a ＝＝
b来判断，但是如果是两个字符串变量a和b，我们就不得不用strcmp来比较了，因为此时，a和b本质上是指向字符串的指针，如果直接还是用＝＝比较，那比较的实际是指针中存储的值——地址。

在Java中呢，我们通过使用 str1 == str2 可以确定两个字符串变量是否指向同一块物理内存位置，这叫做“对象同一性”。在 Java 中要比较两个字符串值，你要使用 str1.equals(str2)。

然后在Python中，和前两者都不一样，由于对象的引入，我们可以用“is”这个运算符来比较两个对象的实体，和具体对象的type就没有关系了，比如你的对象是tuple也好，string也好，甚至class也好，都可以用”is”来比较，本质上就是“对象同一性”的比较，和Java中的＝＝类似，和
C中的pointer比较类似。Python中也有＝＝比较，这个就是值比较了。

3
由于对象机制的引入，让Python的使用非常灵活，比如我们可以用自省方法来查看内存中以对象形式存在的其它模块和函数，获取它们的信息，并对它们进行操作。用这种方法，你可以定义没有名称的函数，不按函数声明的参数顺序调用函数，甚至引用事先并不知道名称的函数。
这些操作在C中都是不可想象的。

4 还有一个很有意思的细节，就是类型对对象行为的影响是各方面的，比如说，a = 1; b =
1这个语句中，在Python里面引发的，可能是a，b同时指向一个值为1的对象，也可能是分别指向两个值为1的对象。而例如这个语句，c = []; d
= []，那么c和d是肯定指向不同的，新创建的空list的。没完，如果是”c = d =
[]“这个语句呢？此时，c和d又指向了相同的list对象了。这些区别，都是在c中没有的。

最后，我们来说说为什么python慢。主要原因就是function call overhead比较大。因为所有东西现在都是对象了，contruct 和destroy 花费也大。连1 + 1 都是 function call，像’12′+’45′ 这样的要 create a third string object, then calls the string obj’s __add。可想而知，速度如何能快起来？

列表和数组

分析Python中的list和C中的数组总是很有趣的。相信可能一些朋友和一样，初学列表的时候，都是把它当作是数组来学的。最初对于list和数组区别的定性，主要是集中在两点。首先，list可以包含很多不同的数据类型，比如

["this", 1, "is", "an", "array"]

这个List，如果放在C中，其实是一个字符串数组，相当于二维的了。

其次呢，list有很多方法，其本身就是一个对象，这个和C的单纯数组是不同的。对于List的操作很多样，因为有方法也有重载的运算符。也带来一些问题，比如下面这个例子：

加入我们要产生一个多维列表，用下面这个语句

A = [[None] * 2] * 3

结果，A的值会是

[[None, None], [None, None], [None, None]]

初一看没问题，典型的二维数组形式的列表。好，现在我们想修改第一个None的值，用语句

A[0][0] = 5

现在我们再来看看A的值：

[[5, None], [5, None], [5, None]]

发现问题没有？这是因为用 * 来复制时，只是创建了对这个对象的引用，而不是真正的创建了它。 *3 创建了一个包含三个引用的列表，这三个引用都指向同一个长度为2的列表。其中一个行的改变会显示在所有行中，这当然不是你想要的。解决方法当然有，我们这样来创建

A = [None]*3
for i in range(3):
A[i] = [None] * 2

这样创建了一个包含三个不同的长度为2的列表。

所以，还是一直强调的，越复杂的东西，越灵活，也越容易出错。

代码优化

C是一个很简单的语言，当我们考虑优化的时候，通常想得也很简单，比如系统级调用越少越好（缓冲区机制），消除循环的低效率和不必要的系统引用，等等，其实主要都是基于系统和硬件细节考虑的。而Python就完全不一样了，当然上面说的这些优化形式，对于Python仍然是实用的，但由于
Python的语法形式千差万别，库和模块多种多样，所以对于语言本身而言，就有很多值得注意的优化要点，举几个例子吧。

比如我们有一个list L1，想要构建一个新的list L2，L2包括L1的头4个元素。按照最直接的想法，代码应该是

L2 = []
for i in range[3]:
L2.append(L1[i])

而更加优化和优美的版本是

L2 = L1[:3]

再比如，如果s1..s7是大字符串(10K+)，那么join([s1,s2,s3,s4,s5,s6,s7])就会比
s1+s2+s3+s4+s5+s6+s7快得多,因为后者会计算很多次子表达式，而join()则在一次过程中完成所有的复制。还有，对于字符串操作，对字符串对象使用replace()方法。仅当在没有固定字符串模式时才使用正则表达式。

所以说，以优化为评判标准，如果说C是短小精悍，Python就是博大精深。

include和import

在C语言中的include非常简单，因为形式单一，意义明确，当你需要用到外部函数等资源时，就用include。而Python中有一个相似的机制，就是import。乍一看，这两个家伙挺像的，不都是我们要用外部资源（最常见的就是函数或者模块（Python））时就用这个来指明么？其实不然，两者的处理机制本质区别在于，C中的include是用于告诉预处理器，这个include指定的文件的内容，你都给我当作在本地源文件中出现过。而

import呢，不是简单的将后面的内容*直接*插入到本地里面去，这玩意更加灵活。事实上，几乎所有类似的机制，Python都比C灵活。这里不是说C不好，C很简练，我其实更喜欢C。

简单说说这个灵活性。import在python中有三种形式，import X, from X import *( or a,b,c……), X =
__import__(‘x’)。最常用的是第二种，因为比较方便，不像第一种那样老是用X.mole来调用模块。from X import
*只是import那些public的mole(一般都是不以__命名的模块)，也可以指定a,b,c来import。

什么时候用哪一种形式呢？应该说，在大多数的模块文档里，都会明确告诉你应该用哪种形式。如果需要用到很多对象，那么from X import
*可能更合适一些，但是，就目前来看，大多数第三方Python库都不推荐使用from molename import *
这种格式。这样做会使引入者的namespace混乱。很多人甚至对于那些专门设计用于这种模式的模块（包括Tkinter,
threading和matplot）都不采用这种方式。而如果你仅仅需要某个对象类a，那么用from X import a比用import
X.a更好，因为以后你调用a的函数直接用a.function()既可以了，不用加X。

如果你连自己希望import的模块都不知道怎么办？请注意，此时Python的优势就体现出来了，我们可以用
__import__(mole)来调用mole，其中这个mole是字符串，这样，可以在运行时再决定，你到底要调用什么mole。举个例子：

def classFromMole (mole, Name):
mod = __import__ (mole)
return getattr (mod, Name)

这里，定义了一个函数classFromMole，你可以在代码的任何时候调用它，

o = classFromMole (MoleOfTheClass, NameOfTheAttribute)()

只需要传入字符串形式的你希望import的模块MoleOfTheClass和其中属性的名字NameOfTheAttribute（当然可以是数据也可以是方法），就能调用了，这个名字字符串不用事先指定，而是根据当时运行的情况来判断。

顺带说一句，Python中import的顺序也有默认规定，这个和C中的include有点类似，因为我们一般都是先include系统文件，再
include自己的头文件（而且还有<>和“”的区别）。Python中呢，一般应该按照以下顺序import模块：

1. 标准库模块 — 如 sys, os, getopt 等

2. 第三方模块

3. 本地实现的模块。

全局变量

这里谈全局变量呢，倒不是说Python和c的全局变量概念不同，他们的概念是相同的。只是在使用机制上，是有一些差异的。举个例子：

– mole.py –
globalvar = 1

def func():
print globalvar
# This makes someglobal readonly,
# any attempt to write to someglobal
# would create a new local variable.

def func2():
global globalvar
globalvar = 2
# this allows you to manipulate the global
# variable

在 func这个函数中，globalvar是只读的。如果你使用了globalvar =
xxx这种赋值语句，Python会重新创造一个新的本地对象并将新值赋给它，原来的对象值不变。而在func2函数中，由于我们事先申明了
globalvar是global的，那么此时的更改就直接在全局变量上生效。

很明显这和c中的使用机制是不一样的，在c中，我们只要在函数外的全局区域申明了变量，就可以在函数中直接对其操作，不用还申明一个global。

Published 2008-06-22

Filed in c,code,python and
tagged c, python

Ⅳ android bootloader lk阶段能读取文件吗

1.主要功能,红色部分是android特有的一些功能，如fastboot，recovery模式等：
* Variety of nand devices for bootup
* USB driver to enable upgrading images over usb ring development
* Keypad driver to enable developers enter ‘fastboot’ mode for image upgrades
* Display driver for debugging and splash screen
* Enable Android recovery image and image upgrades

2.配置dram内存大小，供linux kernel使用
The memory tags can be customized inlk/target/<target_name>/atags.c

3.fastboot模式，可以自行打开或者关闭
如，在boot中关闭按键或者usb 驱动，都可以达到此目的
相关文件
k/app/aboot/fastboot.c
lk/app/aboot/aboot.c

4.MTD block setting
可以配置各个mtd image 分区在如下 文件中
lk\target\tcc8900_evm\init.c
static struct ptentry board_part_list[]

5.打开或者关闭splash screen in the bootloader
DISPLAY_SPLASH_SCREEN功能可以来打开关闭
开机时候，boot会从’splash’ MTD分区中读取原始的文件到framebuffer中显示，所以也需要加载display 的驱动
入口函数在 kernel/main.c 中的 kmain(), 以下就来读读这一段 code.

void kmain(void)
{
// get us into some sort of thread context
thread_init_early();
// early arch stuff
arch_early_init();
// do any super early platform initialization
platform_early_init();
// do any super early target initialization
target_early_init();
dprintf(INFO, "welcome to lk/n/n");

// deal with any static constructors
dprintf(SPEW, "calling constructors/n");
call_constructors();
// bring up the kernel heap
dprintf(SPEW, "initializing heap/n");
heap_init();
// initialize the threading system
dprintf(SPEW, "initializing threads/n");
thread_init();
// initialize the dpc system
dprintf(SPEW, "initializing dpc/n");
dpc_init();
// initialize kernel timers
dprintf(SPEW, "initializing timers/n");
timer_init();
#if (!ENABLE_NANDWRITE)
// create a thread to complete system initialization
dprintf(SPEW, "creating bootstrap completion thread/n");
thread_resume(thread_create("bootstrap2", &bootstrap2, NULL, DEFAULT_PRIORITY, DEFAULT_STACK_SIZE));
// enable interrupts
exit_critical_section();
// become the idle thread
thread_become_idle();
#else
bootstrap_nandwrite();
#endif
}

In include/debug.h: 我们可以看到 dprintf 的第一个参数是代表 debug level.

/* debug levels */
#define CRITICAL 0
#define ALWAYS 0
#define INFO 1
#define SPEW 2
In include/debug.h:

view plainprint?
#define dprintf(level, x...) do { if ((level) <= DEBUGLEVEL) { _dprintf(x); } } while (0)

所以 dprintf 会依 DEBUGLEVEL 来判断是否输出信息.

来看第一个 call 的函数: thread_init_early, define in thread.c

view plainprint?
void thread_init_early(void)
{
int i;
/* initialize the run queues */
for (i=0; i < NUM_PRIORITIES; i++)
list_initialize(&run_queue[i]);
/* initialize the thread list */
list_initialize(&thread_list);
/* create a thread to cover the current running state */
thread_t *t = &bootstrap_thread;
init_thread_struct(t, "bootstrap");
/* half construct this thread, since we're already running */
t->priority = HIGHEST_PRIORITY;
t->state = THREAD_RUNNING;
t->saved_critical_section_count = 1;
list_add_head(&thread_list, &t->thread_list_node);
current_thread = t;
}

#define NUM_PRIORITIES 32 in include/kernel/thread.h

list_initialize() defined in include/list.h: initialized a list

view plainprint?
static inline void list_initialize(struct list_node *list)
{
list->prev = list->next = list;
}

run_queue 是 static struct list_node run_queue[NUM_PRIORITIES]

thread_list 是 static struct list_node thread_list

再来要 call 的函数是: arch_early_init() defined in arch/arm/arch.c

view plainprint?
void arch_early_init(void)
{
/* turn off the cache */
arch_disable_cache(UCACHE);
/* set the vector base to our exception vectors so we dont need to double map at 0 */
#if ARM_CPU_CORTEX_A8
set_vector_base(MEMBASE);
#endif
#if ARM_WITH_MMU
arm_mmu_init();
platform_init_mmu_mappings();
#endif
/* turn the cache back on */
arch_enable_cache(UCACHE);
#if ARM_WITH_NEON
/* enable cp10 and cp11 */
uint32_t val;
__asm__ volatile("mrc p15, 0, %0, c1, c0, 2" : "=r" (val));
val |= (3<<22)|(3<<20);
__asm__ volatile("mcr p15, 0, %0, c1, c0, 2" :: "r" (val));
/* set enable bit in fpexc */
val = (1<<30);
__asm__ volatile("mcr p10, 7, %0, c8, c0, 0" :: "r" (val));
#endif
}

现代操作系统普遍采用虚拟内存管理（Virtual Memory Management）机制，这需要处理器中的MMU（Memory Management Unit，
内存管理单元）提供支持。
CPU执行单元发出的内存地址将被MMU截获，从CPU到MMU的地址称为虚拟地址（Virtual Address，以下简称VA），而MMU将这个地
址翻译成另一个地址发到CPU芯片的外部地址引脚上，也就是将VA映射成PA
MMU将VA映射到PA是以页（Page）为单位的，32位处理器的页尺寸通常是4KB。例如，MMU可以通过一个映射项将VA的一页
0xb7001000~0xb7001fff映射到PA的一页0x2000~0x2fff，如果CPU执行单元要访问虚拟地址0xb7001008，则实际访问到的物理地
址是0x2008。物理内存中的页称为物理页面或者页帧（Page Frame）。虚拟内存的哪个页面映射到物理内存的哪个页帧是通过页
表（Page Table）来描述的，页表保存在物理内存中，MMU会查找页表来确定一个VA应该映射到什么PA。

操作系统和MMU是这样配合的：

1. 操作系统在初始化或分配、释放内存时会执行一些指令在物理内存中填写页表，然后用指令设置MMU，告诉MMU页表在物理内存中
的什么位置。
2. 设置好之后，CPU每次执行访问内存的指令都会自动引发MMU做查表和地址转换操作，地址转换操作由硬件自动完成，不需要用指令
控制MMU去做。

MMU除了做地址转换之外，还提供内存保护机制。各种体系结构都有用户模式（User Mode）和特权模式（Privileged Mode）之分，
操作系统可以在页表中设置每个内存页面的访问权限，有些页面不允许访问，有些页面只有在CPU处于特权模式时才允许访问，有些页面
在用户模式和特权模式都可以访问，访问权限又分为可读、可写和可执行三种。这样设定好之后，当CPU要访问一个VA时，MMU会检查
CPU当前处于用户模式还是特权模式，访问内存的目的是读数据、写数据还是取指令，如果和操作系统设定的页面权限相符，就允许访
问，把它转换成PA，否则不允许访问，产生一个异常（Exception）

常见的 segmentation fault 产生的原因:
用户程序要访问一段 VA, 经 MMU 检查后无权访问, MMU 会产生异常, CPU 从用户模式切换到特权模式, 跳转到内核代码中执行异常服务程序.
内核就会把这个异常解释为 segmentation fault, 将引发异常的程序终止.